file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_minifier/tests/pass-1/7/output.js | JavaScript | export function foo(i) {
var a;
return (a = i()).x() + a.y();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/8/input.js | JavaScript | export function MultiPoint(point) {
for (var point1, i = 0; i < 10; i++) {
return (point1 = point), 0 === distance(point1);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/8/output.js | JavaScript | export function MultiPoint(point) {
for(var i = 0; i < 10; i++)return 0 === distance(point);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/9/1/input.js | JavaScript | function outer() {
function inner(value) {
function closure() {
return value;
}
return function () {
return closure();
};
}
return inner("Hello");
}
console.log("Greeting:", outer()());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/9/1/output.js | JavaScript | console.log("Greeting:", "Hello");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/9/2/input.js | JavaScript | console.log("Greeting:", (function (value) {
return function () {
return value;
};
})("Hello")());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/9/2/output.js | JavaScript | console.log("Greeting:", "Hello");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/compute/1/input.js | JavaScript | function f() {
var a = [94, 173, 190, 239];
var b = 0;
b |= a[0];
b <<= 8;
b |= a[1];
b <<= 8;
b |= a[2];
b <<= 8;
b |= a[3];
return b;
}
console.log(f().toString(16)); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/compute/1/output.js | JavaScript | var a, b;
console.log((a = [
94,
173,
190,
239
], b = 1588444911).toString(16));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6123/1/input.js | JavaScript | const arrow = (param) => {
return Boolean(param);
}
const obj = {
method1() {
return "hello";
},
method2() {
return "goodbye"
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6123/1/output.js | JavaScript | const arrow = (param)=>!!param;
const obj = {
method1 () {
return "hello";
},
method2 () {
return "goodbye";
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6405/1/input.js | JavaScript | export const fn = () => {
let val;
if (!val) {
return undefined;
// works as expected if comment out below line
throw new Error('first');
}
if (val.a?.b !== true) { // Uncaught TypeError: Cannot read properties of undefined (reading 'a')
throw new Error('second');
}
return val;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6405/1/output.js | JavaScript | export const fn = ()=>{
let val;
if (!!val) {
if (val.a?.b !== !0) throw Error('second');
return val;
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6788/1/input.js | JavaScript | const foo = { ...(null && {}) };
const bar = { ...null };
console.log(foo, bar);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issue-6788/1/output.js | JavaScript | console.log({}, {});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issues/6407/1/input.js | JavaScript | export default class Demo {
static encode(value) {
const ranges = [];
let range = [];
let retrString = A.encode(value);
let bitField = '';
value.forEach((curValue, i) => {
bitField += B.encode(curValue);
range.push(i);
ranges.push(range);
});
retrString += '.';
retrString += C.encode(ranges);
return retrString;
}
}
console.log(Deno.encode()) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/issues/6407/1/output.js | JavaScript | export default class Demo {
static encode(value) {
const ranges = [];
let range = [], retrString = A.encode(value), bitField = '';
return value.forEach((curValue, i)=>{
bitField += B.encode(curValue);
range.push(i);
ranges.push(range);
}), retrString += '.', retrString += C.encode(ranges);
}
}
console.log(Deno.encode());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/joda/1/input.js | JavaScript | "use strict";
(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[715], {
/***/ 3266:
/***/ (function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "h": function () { return /* binding */ LocalDate; }
/* harmony export */
});
var isInit = false;
function init() {
if (isInit) {
return;
}
isInit = true;
}
init();
})
}]); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/joda/1/output.js | JavaScript | "use strict";
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
[
715
],
{
/***/ 3266: /***/ function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ h: function() {
return /* binding */ LocalDate;
}
});
var isInit = !1;
!function() {
if (!isInit) isInit = !0;
}();
}
}
]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/joda/2/input.js | JavaScript | "use strict";
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
[
715
],
{
3266: function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, {
h: function () {
return LocalDate;
}
});
var isInit = !1;
!function () {
if (!isInit) isInit = !0;
}();
}
}
]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/joda/2/output.js | JavaScript | "use strict";
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
[
715
],
{
3266: function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, {
h: function() {
return LocalDate;
}
});
var isInit = !1;
isInit = !0;
}
}
]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/regexp/1/input.js | JavaScript | export const foo = new RegExp("") | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/regexp/1/output.js | JavaScript | export const foo = RegExp("");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/seq/1/input.js | JavaScript | var MS_PER_SECOND = 1000,
MS_PER_MINUTE = 60 * MS_PER_SECOND,
MS_PER_HOUR = 60 * MS_PER_MINUTE,
MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
// actual modulo - handles negative numbers (for dates before 1970):
function mod$1(dividend, divisor) {
return ((dividend % divisor) + divisor) % divisor;
}
function localStartOfDate(y, m, d) {
// the date constructor remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0) {
// preserve leap years using a full 400 year cycle, then reset
return new Date(y + 400, m, d) - MS_PER_400_YEARS;
} else {
return new Date(y, m, d).valueOf();
}
}
function utcStartOfDate(y, m, d) {
// Date.UTC remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0) {
// preserve leap years using a full 400 year cycle, then reset
return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
} else {
return Date.UTC(y, m, d);
}
}
function startOf(units) {
var time, startOfDate;
units = normalizeUnits(units);
if (units === undefined || units === 'millisecond' || !this.isValid()) {
return this;
}
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
switch (units) {
case 'year':
time = startOfDate(this.year(), 0, 1);
break;
case 'quarter':
time = startOfDate(
this.year(),
this.month() - (this.month() % 3),
1
);
break;
case 'month':
time = startOfDate(this.year(), this.month(), 1);
break;
case 'week':
time = startOfDate(
this.year(),
this.month(),
this.date() - this.weekday()
);
break;
case 'isoWeek':
time = startOfDate(
this.year(),
this.month(),
this.date() - (this.isoWeekday() - 1)
);
break;
case 'day':
case 'date':
time = startOfDate(this.year(), this.month(), this.date());
break;
case 'hour':
time = this._d.valueOf();
time -= mod$1(
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
MS_PER_HOUR
);
break;
case 'minute':
time = this._d.valueOf();
time -= mod$1(time, MS_PER_MINUTE);
break;
case 'second':
time = this._d.valueOf();
time -= mod$1(time, MS_PER_SECOND);
break;
}
this._d.setTime(time);
hooks.updateOffset(this, true);
return this;
}
function endOf(units) {
var time, startOfDate;
units = normalizeUnits(units);
if (units === undefined || units === 'millisecond' || !this.isValid()) {
return this;
}
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
switch (units) {
case 'year':
time = startOfDate(this.year() + 1, 0, 1) - 1;
break;
case 'quarter':
time =
startOfDate(
this.year(),
this.month() - (this.month() % 3) + 3,
1
) - 1;
break;
case 'month':
time = startOfDate(this.year(), this.month() + 1, 1) - 1;
break;
case 'week':
time =
startOfDate(
this.year(),
this.month(),
this.date() - this.weekday() + 7
) - 1;
break;
case 'isoWeek':
time =
startOfDate(
this.year(),
this.month(),
this.date() - (this.isoWeekday() - 1) + 7
) - 1;
break;
case 'day':
case 'date':
time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
break;
case 'hour':
time = this._d.valueOf();
time +=
MS_PER_HOUR -
mod$1(
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
MS_PER_HOUR
) -
1;
break;
case 'minute':
time = this._d.valueOf();
time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
break;
case 'second':
time = this._d.valueOf();
time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
break;
}
this._d.setTime(time);
hooks.updateOffset(this, true);
return this;
}
function valueOf() {
return this._d.valueOf() - (this._offset || 0) * 60000;
}
function unix() {
return Math.floor(this.valueOf() / 1000);
}
function toDate() {
return new Date(this.valueOf());
}
console.log(MS_PER_400_YEARS) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/seq/1/output.js | JavaScript | var MS_PER_SECOND = 1000, MS_PER_MINUTE = 60 * 1000, MS_PER_HOUR = 60 * 1000 * 60, MS_PER_400_YEARS = 60 * 1000 * 60 * 3506328;
// actual modulo - handles negative numbers (for dates before 1970):
function mod$1(dividend, divisor) {
return (dividend % divisor + divisor) % divisor;
}
function localStartOfDate(y, m, d) {
// the date constructor remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0) // preserve leap years using a full 400 year cycle, then reset
return new Date(y + 400, m, d) - MS_PER_400_YEARS;
return new Date(y, m, d).valueOf();
}
function utcStartOfDate(y, m, d) {
// Date.UTC remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0) // preserve leap years using a full 400 year cycle, then reset
return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
return Date.UTC(y, m, d);
}
function startOf(units) {
var time, startOfDate;
if (void 0 === (units = normalizeUnits(units)) || 'millisecond' === units || !this.isValid()) return this;
switch(startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate, units){
case 'year':
time = startOfDate(this.year(), 0, 1);
break;
case 'quarter':
time = startOfDate(this.year(), this.month() - this.month() % 3, 1);
break;
case 'month':
time = startOfDate(this.year(), this.month(), 1);
break;
case 'week':
time = startOfDate(this.year(), this.month(), this.date() - this.weekday());
break;
case 'isoWeek':
time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));
break;
case 'day':
case 'date':
time = startOfDate(this.year(), this.month(), this.date());
break;
case 'hour':
time = this._d.valueOf(), time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
break;
case 'minute':
time = this._d.valueOf(), time -= mod$1(time, MS_PER_MINUTE);
break;
case 'second':
time = this._d.valueOf(), time -= mod$1(time, MS_PER_SECOND);
break;
}
return this._d.setTime(time), hooks.updateOffset(this, true), this;
}
function endOf(units) {
var time, startOfDate;
if (void 0 === (units = normalizeUnits(units)) || 'millisecond' === units || !this.isValid()) return this;
switch(startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate, units){
case 'year':
time = startOfDate(this.year() + 1, 0, 1) - 1;
break;
case 'quarter':
time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;
break;
case 'month':
time = startOfDate(this.year(), this.month() + 1, 1) - 1;
break;
case 'week':
time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;
break;
case 'isoWeek':
time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1;
break;
case 'day':
case 'date':
time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
break;
case 'hour':
time = this._d.valueOf(), time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;
break;
case 'minute':
time = this._d.valueOf(), time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
break;
case 'second':
time = this._d.valueOf(), time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
break;
}
return this._d.setTime(time), hooks.updateOffset(this, true), this;
}
function valueOf() {
return this._d.valueOf() - 60000 * (this._offset || 0);
}
function unix() {
return Math.floor(this.valueOf() / 1000);
}
function toDate() {
return new Date(this.valueOf());
}
console.log(60 * 1000 * 60 * 3506328);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/terser/1/input.js | JavaScript | def_optimize(AST_Call, function (self, compressor) {
if (compressor.option("unsafe")) {
if (
exp instanceof AST_Dot &&
exp.start.value === "Array" &&
exp.property === "from" &&
self.args.length === 1
) {
const [argument] = self.args;
if (argument instanceof AST_Array) {
return make_node(AST_Array, argument, {
elements: argument.elements,
}).optimize(compressor);
}
}
if (is_undeclared_ref(exp))
switch (exp.name) {
}
else if (exp instanceof AST_Dot)
switch (exp.property) {
case "join":
if (exp.expression instanceof AST_Array)
EXIT: {
var separator;
if (self.args.length > 0) {
separator = self.args[0].evaluate(compressor);
if (separator === self.args[0]) break EXIT; // not a constant
}
var elements = [];
var consts = [];
for (
var i = 0, len = exp.expression.elements.length;
i < len;
i++
) {
var el = exp.expression.elements[i];
if (el instanceof AST_Expansion) break EXIT;
var value = el.evaluate(compressor);
if (value !== el) {
consts.push(value);
} else {
if (consts.length > 0) {
elements.push(
make_node(AST_String, self, {
value: consts.join(separator),
})
);
consts.length = 0;
}
elements.push(el);
}
}
if (consts.length > 0) {
elements.push(
make_node(AST_String, self, {
value: consts.join(separator),
})
);
}
if (elements.length == 0)
return make_node(AST_String, self, {
value: "",
});
if (elements.length == 1) {
if (elements[0].is_string(compressor)) {
return elements[0];
}
return make_node(AST_Binary, elements[0], {
operator: "+",
left: make_node(AST_String, self, {
value: "",
}),
right: elements[0],
});
}
if (separator == "") {
var first;
if (
elements[0].is_string(compressor) ||
elements[1].is_string(compressor)
) {
first = elements.shift();
} else {
first = make_node(AST_String, self, {
value: "",
});
}
return elements
.reduce(function (prev, el) {
return make_node(AST_Binary, el, {
operator: "+",
left: prev,
right: el,
});
}, first)
.optimize(compressor);
}
// need this awkward cloning to not affect original element
// best_of will decide which one to get through.
var node = self.clone();
node.expression = node.expression.clone();
node.expression.expression =
node.expression.expression.clone();
node.expression.expression.elements = elements;
return best_of(compressor, self, node);
}
break;
}
}
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/terser/1/output.js | JavaScript | def_optimize(AST_Call, function(self, compressor) {
if (compressor.option("unsafe")) {
if (exp instanceof AST_Dot && "Array" === exp.start.value && "from" === exp.property && 1 === self.args.length) {
const [argument] = self.args;
if (argument instanceof AST_Array) return make_node(AST_Array, argument, {
elements: argument.elements
}).optimize(compressor);
}
if (is_undeclared_ref(exp)) exp.name;
else if (exp instanceof AST_Dot && "join" === exp.property) {
if (exp.expression instanceof AST_Array) {
EXIT: if (!(self.args.length > 0) || (separator = self.args[0].evaluate(compressor)) !== self.args[0]) {
for(var separator, first, elements = [], consts = [], i = 0, len = exp.expression.elements.length; i < len; i++){
var el = exp.expression.elements[i];
if (el instanceof AST_Expansion) break EXIT;
var value = el.evaluate(compressor);
value !== el ? consts.push(value) : (consts.length > 0 && (elements.push(make_node(AST_String, self, {
value: consts.join(separator)
})), consts.length = 0), elements.push(el));
}
if (consts.length > 0 && elements.push(make_node(AST_String, self, {
value: consts.join(separator)
})), 0 == elements.length) return make_node(AST_String, self, {
value: ""
});
if (1 == elements.length) {
if (elements[0].is_string(compressor)) return elements[0];
return make_node(AST_Binary, elements[0], {
operator: "+",
left: make_node(AST_String, self, {
value: ""
}),
right: elements[0]
});
}
if ("" == separator) return first = elements[0].is_string(compressor) || elements[1].is_string(compressor) ? elements.shift() : make_node(AST_String, self, {
value: ""
}), elements.reduce(function(prev, el) {
return make_node(AST_Binary, el, {
operator: "+",
left: prev,
right: el
});
}, first).optimize(compressor);
// need this awkward cloning to not affect original element
// best_of will decide which one to get through.
var node = self.clone();
return node.expression = node.expression.clone(), node.expression.expression = node.expression.expression.clone(), node.expression.expression.elements = elements, best_of(compressor, self, node);
}
}
}
}
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/terser/2/input.js | JavaScript |
self.push({
"_j": function () {
return undefinedGlobal;
}
}) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/terser/2/output.js | JavaScript | self.push({
_j: function() {
return undefinedGlobal;
}
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/uiw-codemirror/input.js | JavaScript | export class TextLeaf extends Text {
constructor(
text1,
length1 = (function textLength(text) {
let length = -1;
for (let line of text) length += line.length + 1;
return length;
})(text1)
) {
super(), (this.text = text1), (this.length = length1);
}
get lines() {
return this.text.length;
}
get children() {
return null;
}
lineInner(target, isLine, line, offset) {
for (let i = 0; ; i++) {
let string = this.text[i],
end = offset + string.length;
if ((isLine ? line : end) >= target)
return new Line(offset, end, line, string);
(offset = end + 1), line++;
}
}
decompose(from, to, target, open) {
let text =
from <= 0 && to >= this.length
? this
: new TextLeaf(
sliceText(this.text, from, to),
Math.min(to, this.length) - Math.max(0, from)
);
if (1 & open) {
let prev = target.pop(),
joined = appendText(
text.text,
prev.text.slice(),
0,
text.length
);
if (joined.length <= 32)
target.push(new TextLeaf(joined, prev.length + text.length));
else {
let mid = joined.length >> 1;
target.push(
new TextLeaf(joined.slice(0, mid)),
new TextLeaf(joined.slice(mid))
);
}
} else target.push(text);
}
replace(from, to, text) {
if (!(text instanceof TextLeaf)) return super.replace(from, to, text);
let lines = appendText(
this.text,
appendText(text.text, sliceText(this.text, 0, from)),
to
),
newLen = this.length + text.length - (to - from);
return lines.length <= 32
? new TextLeaf(lines, newLen)
: TextNode.from(TextLeaf.split(lines, []), newLen);
}
sliceString(from, to = this.length, lineSep = "\n") {
let result = "";
for (let pos = 0, i = 0; pos <= to && i < this.text.length; i++) {
let line = this.text[i],
end = pos + line.length;
pos > from && i && (result += lineSep),
from < end &&
to > pos &&
(result += line.slice(Math.max(0, from - pos), to - pos)),
(pos = end + 1);
}
return result;
}
flatten(target) {
for (let line of this.text) target.push(line);
}
scanIdentical() {
return 0;
}
static split(text, target) {
let part = [],
len = -1;
for (let line of text)
part.push(line),
(len += line.length + 1),
32 == part.length &&
(target.push(new TextLeaf(part, len)),
(part = []),
(len = -1));
return len > -1 && target.push(new TextLeaf(part, len)), target;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-1/uiw-codemirror/output.js | JavaScript | export class TextLeaf extends Text {
constructor(text1, length1 = function(text) {
let length = -1;
for (let line of text)length += line.length + 1;
return length;
}(text1)){
super(), this.text = text1, this.length = length1;
}
get lines() {
return this.text.length;
}
get children() {
return null;
}
lineInner(target, isLine, line, offset) {
for(let i = 0;; i++){
let string = this.text[i], end = offset + string.length;
if ((isLine ? line : end) >= target) return new Line(offset, end, line, string);
offset = end + 1, line++;
}
}
decompose(from, to, target, open) {
let text = from <= 0 && to >= this.length ? this : new TextLeaf(sliceText(this.text, from, to), Math.min(to, this.length) - Math.max(0, from));
if (1 & open) {
let prev = target.pop(), joined = appendText(text.text, prev.text.slice(), 0, text.length);
if (joined.length <= 32) target.push(new TextLeaf(joined, prev.length + text.length));
else {
let mid = joined.length >> 1;
target.push(new TextLeaf(joined.slice(0, mid)), new TextLeaf(joined.slice(mid)));
}
} else target.push(text);
}
replace(from, to, text) {
if (!(text instanceof TextLeaf)) return super.replace(from, to, text);
let lines = appendText(this.text, appendText(text.text, sliceText(this.text, 0, from)), to), newLen = this.length + text.length - (to - from);
return lines.length <= 32 ? new TextLeaf(lines, newLen) : TextNode.from(TextLeaf.split(lines, []), newLen);
}
sliceString(from, to = this.length, lineSep = "\n") {
let result = "";
for(let pos = 0, i = 0; pos <= to && i < this.text.length; i++){
let line = this.text[i], end = pos + line.length;
pos > from && i && (result += lineSep), from < end && to > pos && (result += line.slice(Math.max(0, from - pos), to - pos)), pos = end + 1;
}
return result;
}
flatten(target) {
for (let line of this.text)target.push(line);
}
scanIdentical() {
return 0;
}
static split(text, target) {
let part = [], len = -1;
for (let line of text)part.push(line), len += line.length + 1, 32 == part.length && (target.push(new TextLeaf(part, len)), part = [], len = -1);
return len > -1 && target.push(new TextLeaf(part, len)), target;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-default/compute/1/input.js | JavaScript | function f() {
var a = [94, 173, 190, 239];
var b = 0;
b |= a[0];
b <<= 8;
b |= a[1];
b <<= 8;
b |= a[2];
b <<= 8;
b |= a[3];
return b;
}
console.log(f().toString(16)); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/pass-default/compute/1/output.js | JavaScript | console.log("5eadbeef");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/angular-1.2.5.js | JavaScript | /**
* @license AngularJS v1.2.5
* (c) 2010-2014 Google, Inc. http://angularjs.org
* License: MIT
*/
(function (window, document, undefined) {
"use strict";
/**
* @description
*
* This object provides a utility for producing rich Error messages within
* Angular. It can be called as follows:
*
* var exampleMinErr = minErr('example');
* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
*
* The above creates an instance of minErr in the example namespace. The
* resulting error will have a namespaced error code of example.one. The
* resulting error will replace {0} with the value of foo, and {1} with the
* value of bar. The object is not restricted in the number of arguments it can
* take.
*
* If fewer arguments are specified than necessary for interpolation, the extra
* interpolation markers will be preserved in the final string.
*
* Since data will be parsed statically during a build step, some restrictions
* are applied with respect to how minErr instances are created and called.
* Instances should have names of the form namespaceMinErr for a minErr created
* using minErr('namespace') . Error codes, namespaces and template strings
* should all be static strings, not variables or general expressions.
*
* @param {string} module The namespace to use for the new minErr instance.
* @returns {function(string, string, ...): Error} instance
*/
function minErr(module) {
return function () {
var code = arguments[0],
prefix = "[" + (module ? module + ":" : "") + code + "] ",
template = arguments[1],
templateArgs = arguments,
stringify = function (obj) {
if (typeof obj === "function") {
return obj.toString().replace(/ \{[\s\S]*$/, "");
} else if (typeof obj === "undefined") {
return "undefined";
} else if (typeof obj !== "string") {
return JSON.stringify(obj);
}
return obj;
},
message,
i;
message =
prefix +
template.replace(/\{\d+\}/g, function (match) {
var index = +match.slice(1, -1),
arg;
if (index + 2 < templateArgs.length) {
arg = templateArgs[index + 2];
if (typeof arg === "function") {
return arg.toString().replace(/ ?\{[\s\S]*$/, "");
} else if (typeof arg === "undefined") {
return "undefined";
} else if (typeof arg !== "string") {
return toJson(arg);
}
return arg;
}
return match;
});
message =
message +
"\nhttp://errors.angularjs.org/1.2.5/" +
(module ? module + "/" : "") +
code;
for (i = 2; i < arguments.length; i++) {
message =
message +
(i == 2 ? "?" : "&") +
"p" +
(i - 2) +
"=" +
encodeURIComponent(stringify(arguments[i]));
}
return new Error(message);
};
}
/* We need to tell jshint what variables are being exported */
/* global
-angular,
-msie,
-jqLite,
-jQuery,
-slice,
-push,
-toString,
-ngMinErr,
-_angular,
-angularModule,
-nodeName_,
-uid,
-lowercase,
-uppercase,
-manualLowercase,
-manualUppercase,
-nodeName_,
-isArrayLike,
-forEach,
-sortedKeys,
-forEachSorted,
-reverseParams,
-nextUid,
-setHashKey,
-extend,
-int,
-inherit,
-noop,
-identity,
-valueFn,
-isUndefined,
-isDefined,
-isObject,
-isString,
-isNumber,
-isDate,
-isArray,
-isFunction,
-isRegExp,
-isWindow,
-isScope,
-isFile,
-isBoolean,
-trim,
-isElement,
-makeMap,
-map,
-size,
-includes,
-indexOf,
-arrayRemove,
-isLeafNode,
-copy,
-shallowCopy,
-equals,
-csp,
-concat,
-sliceArgs,
-bind,
-toJsonReplacer,
-toJson,
-fromJson,
-toBoolean,
-startingTag,
-tryDecodeURIComponent,
-parseKeyValue,
-toKeyValue,
-encodeUriSegment,
-encodeUriQuery,
-angularInit,
-bootstrap,
-snake_case,
-bindJQuery,
-assertArg,
-assertArgFn,
-assertNotHasOwnProperty,
-getter,
-getBlockElements,
*/
////////////////////////////////////
/**
* @ngdoc function
* @name angular.lowercase
* @function
*
* @description Converts the specified string to lowercase.
* @param {string} string String to be converted to lowercase.
* @returns {string} Lowercased string.
*/
var lowercase = function (string) {
return isString(string) ? string.toLowerCase() : string;
};
/**
* @ngdoc function
* @name angular.uppercase
* @function
*
* @description Converts the specified string to uppercase.
* @param {string} string String to be converted to uppercase.
* @returns {string} Uppercased string.
*/
var uppercase = function (string) {
return isString(string) ? string.toUpperCase() : string;
};
var manualLowercase = function (s) {
/* jshint bitwise: false */
return isString(s)
? s.replace(/[A-Z]/g, function (ch) {
return String.fromCharCode(ch.charCodeAt(0) | 32);
})
: s;
};
var manualUppercase = function (s) {
/* jshint bitwise: false */
return isString(s)
? s.replace(/[a-z]/g, function (ch) {
return String.fromCharCode(ch.charCodeAt(0) & ~32);
})
: s;
};
// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
// with correct but slower alternatives.
if ("i" !== "I".toLowerCase()) {
lowercase = manualLowercase;
uppercase = manualUppercase;
}
var /** holds major version number for IE or NaN for real browsers */
msie,
jqLite, // delay binding since jQuery could be loaded after us.
jQuery, // delay binding
slice = [].slice,
push = [].push,
toString = Object.prototype.toString,
ngMinErr = minErr("ng"),
_angular = window.angular,
/** @name angular */
angular = window.angular || (window.angular = {}),
angularModule,
nodeName_,
uid = ["0", "0", "0"];
/**
* IE 11 changed the format of the UserAgent string.
* See http://msdn.microsoft.com/en-us/library/ms537503.aspx
*/
msie = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]);
if (isNaN(msie)) {
msie = int(
(/trident\/.*; rv:(\d+)/.exec(lowercase(navigator.userAgent)) || [])[1],
);
}
/**
* @private
* @param {*} obj
* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
* String ...)
*/
function isArrayLike(obj) {
if (obj == null || isWindow(obj)) {
return false;
}
var length = obj.length;
if (obj.nodeType === 1 && length) {
return true;
}
return (
isString(obj) ||
isArray(obj) ||
length === 0 ||
(typeof length === "number" && length > 0 && length - 1 in obj)
);
}
/**
* @ngdoc function
* @name angular.forEach
* @function
*
* @description
* Invokes the `iterator` function once for each item in `obj` collection, which can be either an
* object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`
* is the value of an object property or an array element and `key` is the object property key or
* array element index. Specifying a `context` for the function is optional.
*
* Note: this function was previously known as `angular.foreach`.
*
<pre>
var values = {name: 'misko', gender: 'male'};
var log = [];
angular.forEach(values, function(value, key){
this.push(key + ': ' + value);
}, log);
expect(log).toEqual(['name: misko', 'gender:male']);
</pre>
*
* @param {Object|Array} obj Object to iterate over.
* @param {Function} iterator Iterator function.
* @param {Object=} context Object to become context (`this`) for the iterator function.
* @returns {Object|Array} Reference to `obj`.
*/
function forEach(obj, iterator, context) {
var key;
if (obj) {
if (isFunction(obj)) {
for (key in obj) {
if (
key != "prototype" &&
key != "length" &&
key != "name" &&
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) {
if (obj.hasOwnProperty(key)) {
iterator.call(context, obj[key], key);
}
}
}
}
return obj;
}
function sortedKeys(obj) {
var keys = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
keys.push(key);
}
}
return keys.sort();
}
function forEachSorted(obj, iterator, context) {
var keys = sortedKeys(obj);
for (var i = 0; i < keys.length; i++) {
iterator.call(context, obj[keys[i]], keys[i]);
}
return keys;
}
/**
* when using forEach the params are value, key, but it is often useful to have key, value.
* @param {function(string, *)} iteratorFn
* @returns {function(*, string)}
*/
function reverseParams(iteratorFn) {
return function (value, key) {
iteratorFn(key, value);
};
}
/**
* A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric
* characters such as '012ABC'. The reason why we are not using simply a number counter is that
* the number string gets longer over time, and it can also overflow, where as the nextId
* will grow much slower, it is a string, and it will never overflow.
*
* @returns an unique alpha-numeric string
*/
function nextUid() {
var index = uid.length;
var digit;
while (index) {
index--;
digit = uid[index].charCodeAt(0);
if (digit == 57 /*'9'*/) {
uid[index] = "A";
return uid.join("");
}
if (digit == 90 /*'Z'*/) {
uid[index] = "0";
} else {
uid[index] = String.fromCharCode(digit + 1);
return uid.join("");
}
}
uid.unshift("0");
return uid.join("");
}
/**
* Set or clear the hashkey for an object.
* @param obj object
* @param h the hashkey (!truthy to delete the hashkey)
*/
function setHashKey(obj, h) {
if (h) {
obj.$$hashKey = h;
} else {
delete obj.$$hashKey;
}
}
/**
* @ngdoc function
* @name angular.extend
* @function
*
* @description
* Extends the destination object `dst` by copying all of the properties from the `src` object(s)
* to `dst`. You can specify multiple `src` objects.
*
* @param {Object} dst Destination object.
* @param {...Object} src Source object(s).
* @returns {Object} Reference to `dst`.
*/
function extend(dst) {
var h = dst.$$hashKey;
forEach(arguments, function (obj) {
if (obj !== dst) {
forEach(obj, function (value, key) {
dst[key] = value;
});
}
});
setHashKey(dst, h);
return dst;
}
function int(str) {
return parseInt(str, 10);
}
function inherit(parent, extra) {
return extend(new (extend(function () {}, { prototype: parent }))(), extra);
}
/**
* @ngdoc function
* @name angular.noop
* @function
*
* @description
* A function that performs no operations. This function can be useful when writing code in the
* functional style.
<pre>
function foo(callback) {
var result = calculateResult();
(callback || angular.noop)(result);
}
</pre>
*/
function noop() {}
noop.$inject = [];
/**
* @ngdoc function
* @name angular.identity
* @function
*
* @description
* A function that returns its first argument. This function is useful when writing code in the
* functional style.
*
<pre>
function transformer(transformationFn, value) {
return (transformationFn || angular.identity)(value);
};
</pre>
*/
function identity($) {
return $;
}
identity.$inject = [];
function valueFn(value) {
return function () {
return value;
};
}
/**
* @ngdoc function
* @name angular.isUndefined
* @function
*
* @description
* Determines if a reference is undefined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is undefined.
*/
function isUndefined(value) {
return typeof value === "undefined";
}
/**
* @ngdoc function
* @name angular.isDefined
* @function
*
* @description
* Determines if a reference is defined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is defined.
*/
function isDefined(value) {
return typeof value !== "undefined";
}
/**
* @ngdoc function
* @name angular.isObject
* @function
*
* @description
* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
* considered to be objects.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Object` but not `null`.
*/
function isObject(value) {
return value != null && typeof value === "object";
}
/**
* @ngdoc function
* @name angular.isString
* @function
*
* @description
* Determines if a reference is a `String`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `String`.
*/
function isString(value) {
return typeof value === "string";
}
/**
* @ngdoc function
* @name angular.isNumber
* @function
*
* @description
* Determines if a reference is a `Number`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Number`.
*/
function isNumber(value) {
return typeof value === "number";
}
/**
* @ngdoc function
* @name angular.isDate
* @function
*
* @description
* Determines if a value is a date.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Date`.
*/
function isDate(value) {
return toString.call(value) === "[object Date]";
}
/**
* @ngdoc function
* @name angular.isArray
* @function
*
* @description
* Determines if a reference is an `Array`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Array`.
*/
function isArray(value) {
return toString.call(value) === "[object Array]";
}
/**
* @ngdoc function
* @name angular.isFunction
* @function
*
* @description
* Determines if a reference is a `Function`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Function`.
*/
function isFunction(value) {
return typeof value === "function";
}
/**
* Determines if a value is a regular expression object.
*
* @private
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `RegExp`.
*/
function isRegExp(value) {
return toString.call(value) === "[object RegExp]";
}
/**
* Checks if `obj` is a window object.
*
* @private
* @param {*} obj Object to check
* @returns {boolean} True if `obj` is a window obj.
*/
function isWindow(obj) {
return obj && obj.document && obj.location && obj.alert && obj.setInterval;
}
function isScope(obj) {
return obj && obj.$evalAsync && obj.$watch;
}
function isFile(obj) {
return toString.call(obj) === "[object File]";
}
function isBoolean(value) {
return typeof value === "boolean";
}
var trim = (function () {
// native trim is way faster: http://jsperf.com/angular-trim-test
// but IE doesn't have it... :-(
// TODO: we should move this into IE/ES5 polyfill
if (!String.prototype.trim) {
return function (value) {
return isString(value)
? value.replace(/^\s\s*/, "").replace(/\s\s*$/, "")
: value;
};
}
return function (value) {
return isString(value) ? value.trim() : value;
};
})();
/**
* @ngdoc function
* @name angular.isElement
* @function
*
* @description
* Determines if a reference is a DOM element (or wrapped jQuery element).
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
*/
function isElement(node) {
return !!(
node &&
(node.nodeName || // we are a direct element
(node.on && node.find))
); // we have an on and find method part of jQuery API
}
/**
* @param str 'key1,key2,...'
* @returns {object} in the form of {key1:true, key2:true, ...}
*/
function makeMap(str) {
var obj = {},
items = str.split(","),
i;
for (i = 0; i < items.length; i++) obj[items[i]] = true;
return obj;
}
if (msie < 9) {
nodeName_ = function (element) {
element = element.nodeName ? element : element[0];
return element.scopeName && element.scopeName != "HTML"
? uppercase(element.scopeName + ":" + element.nodeName)
: element.nodeName;
};
} else {
nodeName_ = function (element) {
return element.nodeName ? element.nodeName : element[0].nodeName;
};
}
function map(obj, iterator, context) {
var results = [];
forEach(obj, function (value, index, list) {
results.push(iterator.call(context, value, index, list));
});
return results;
}
/**
* @description
* Determines the number of elements in an array, the number of properties an object has, or
* the length of a string.
*
* Note: This function is used to augment the Object type in Angular expressions. See
* {@link angular.Object} for more information about Angular arrays.
*
* @param {Object|Array|string} obj Object, array, or string to inspect.
* @param {boolean} [ownPropsOnly=false] Count only "own" properties in an object
* @returns {number} The size of `obj` or `0` if `obj` is neither an object nor an array.
*/
function size(obj, ownPropsOnly) {
var count = 0,
key;
if (isArray(obj) || isString(obj)) {
return obj.length;
} else if (isObject(obj)) {
for (key in obj) if (!ownPropsOnly || obj.hasOwnProperty(key)) count++;
}
return count;
}
function includes(array, obj) {
return indexOf(array, obj) != -1;
}
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);
if (index >= 0) array.splice(index, 1);
return value;
}
function isLeafNode(node) {
if (node) {
switch (node.nodeName) {
case "OPTION":
case "PRE":
case "TITLE":
return true;
}
}
return false;
}
/**
* @ngdoc function
* @name angular.copy
* @function
*
* @description
* Creates a deep copy of `source`, which should be an object or an array.
*
* * If no destination is supplied, a copy of the object or array is created.
* * If a destination is provided, all of its elements (for array) or properties (for objects)
* are deleted and then all elements/properties from the source are copied to it.
* * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
* * If `source` is identical to 'destination' an exception will be thrown.
*
* @param {*} source The source that will be used to make a copy.
* Can be any type, including primitives, `null`, and `undefined`.
* @param {(Object|Array)=} destination Destination into which the source is copied. If
* provided, must be of the same type as `source`.
* @returns {*} The copy or updated `destination`, if `destination` was specified.
*
* @example
<doc:example>
<doc:source>
<div ng-controller="Controller">
<form novalidate class="simple-form">
Name: <input type="text" ng-model="user.name" /><br />
E-mail: <input type="email" ng-model="user.email" /><br />
Gender: <input type="radio" ng-model="user.gender" value="male" />male
<input type="radio" ng-model="user.gender" value="female" />female<br />
<button ng-click="reset()">RESET</button>
<button ng-click="update(user)">SAVE</button>
</form>
<pre>form = {{user | json}}</pre>
<pre>master = {{master | json}}</pre>
</div>
<script>
function Controller($scope) {
$scope.master= {};
$scope.update = function(user) {
// Example with 1 argument
$scope.master= angular.copy(user);
};
$scope.reset = function() {
// Example with 2 arguments
angular.copy($scope.master, $scope.user);
};
$scope.reset();
}
</script>
</doc:source>
</doc:example>
*/
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) {
destination = source;
if (source) {
if (isArray(source)) {
destination = copy(source, []);
} else if (isDate(source)) {
destination = new Date(source.getTime());
} else if (isRegExp(source)) {
destination = new RegExp(source.source);
} else if (isObject(source)) {
destination = copy(source, {});
}
}
} else {
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;
forEach(destination, function (value, key) {
delete destination[key];
});
for (var key in source) {
destination[key] = copy(source[key]);
}
setHashKey(destination, h);
}
}
return destination;
}
/**
* Create a shallow copy of an object
*/
function shallowCopy(src, dst) {
dst = dst || {};
for (var key in src) {
// shallowCopy is only ever called by $compile nodeLinkFn, which has control over src
// so we don't need to worry about using our custom hasOwnProperty here
if (src.hasOwnProperty(key) && key.substr(0, 2) !== "$$") {
dst[key] = src[key];
}
}
return dst;
}
/**
* @ngdoc function
* @name angular.equals
* @function
*
* @description
* Determines if two objects or two values are equivalent. Supports value types, regular
* expressions, arrays and objects.
*
* Two objects or values are considered equivalent if at least one of the following is true:
*
* * Both objects or values pass `===` comparison.
* * Both objects or values are of the same type and all of their properties are equal by
* comparing them with `angular.equals`.
* * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
* * Both values represent the same regular expression (In JavasScript,
* /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
* representation matches).
*
* During a property comparison, properties of `function` type and properties with names
* that begin with `$` are ignored.
*
* Scope and DOMWindow objects are being compared only by identify (`===`).
*
* @param {*} o1 Object or value to compare.
* @param {*} o2 Object or value to compare.
* @returns {boolean} True if arguments are equal.
*/
function equals(o1, o2) {
if (o1 === o2) return true;
if (o1 === null || o2 === null) return false;
if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
var t1 = typeof o1,
t2 = typeof o2,
length,
key,
keySet;
if (t1 == t2) {
if (t1 == "object") {
if (isArray(o1)) {
if (!isArray(o2)) return false;
if ((length = o1.length) == o2.length) {
for (key = 0; key < length; key++) {
if (!equals(o1[key], o2[key])) return false;
}
return true;
}
} else if (isDate(o1)) {
return isDate(o2) && o1.getTime() == o2.getTime();
} else if (isRegExp(o1) && isRegExp(o2)) {
return o1.toString() == o2.toString();
} else {
if (
isScope(o1) ||
isScope(o2) ||
isWindow(o1) ||
isWindow(o2) ||
isArray(o2)
)
return false;
keySet = {};
for (key in o1) {
if (key.charAt(0) === "$" || isFunction(o1[key])) continue;
if (!equals(o1[key], o2[key])) return false;
keySet[key] = true;
}
for (key in o2) {
if (
!keySet.hasOwnProperty(key) &&
key.charAt(0) !== "$" &&
o2[key] !== undefined &&
!isFunction(o2[key])
)
return false;
}
return true;
}
}
}
return false;
}
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);
}
/* jshint -W101 */
/**
* @ngdoc function
* @name angular.bind
* @function
*
* @description
* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
* `fn`). You can supply optional `args` that are prebound to the function. This feature is also
* known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
* distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
*
* @param {Object} self Context which `fn` should be evaluated in.
* @param {function()} fn Function to be bound.
* @param {...*} args Optional arguments to be prebound to the `fn` function call.
* @returns {function()} Function that wraps the `fn` with all the specified bindings.
*/
/* jshint +W101 */
function bind(self, fn) {
var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
if (isFunction(fn) && !(fn instanceof RegExp)) {
return 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);
};
} else {
// in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
return fn;
}
}
function toJsonReplacer(key, value) {
var val = value;
if (typeof key === "string" && key.charAt(0) === "$") {
val = undefined;
} else if (isWindow(value)) {
val = "$WINDOW";
} else if (value && document === value) {
val = "$DOCUMENT";
} else if (isScope(value)) {
val = "$SCOPE";
}
return val;
}
/**
* @ngdoc function
* @name angular.toJson
* @function
*
* @description
* Serializes input into a JSON-formatted string. Properties with leading $ characters will be
* stripped since angular uses this notation internally.
*
* @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
* @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.
* @returns {string|undefined} JSON-ified string representing `obj`.
*/
function toJson(obj, pretty) {
if (typeof obj === "undefined") return undefined;
return JSON.stringify(obj, toJsonReplacer, pretty ? " " : null);
}
/**
* @ngdoc function
* @name angular.fromJson
* @function
*
* @description
* Deserializes a JSON string.
*
* @param {string} json JSON string to deserialize.
* @returns {Object|Array|Date|string|number} Deserialized thingy.
*/
function fromJson(json) {
return isString(json) ? JSON.parse(json) : json;
}
function toBoolean(value) {
if (value && value.length !== 0) {
var v = lowercase("" + value);
value = !(
v == "f" ||
v == "0" ||
v == "false" ||
v == "no" ||
v == "n" ||
v == "[]"
);
} else {
value = false;
}
return value;
}
/**
* @returns {string} Returns the string representation of the element.
*/
function startingTag(element) {
element = jqLite(element).clone();
try {
// turns out IE does not let you set .html() on elements which
// are not allowed to have children. So we just ignore it.
element.empty();
} catch (e) {}
// As Per DOM Standards
var TEXT_NODE = 3;
var elemHtml = jqLite("<div>").append(element).html();
try {
return element[0].nodeType === TEXT_NODE
? lowercase(elemHtml)
: elemHtml
.match(/^(<[^>]+>)/)[1]
.replace(/^<([\w\-]+)/, function (match, nodeName) {
return "<" + lowercase(nodeName);
});
} catch (e) {
return lowercase(elemHtml);
}
}
/////////////////////////////////////////////////
/**
* Tries to decode the URI component without throwing an exception.
*
* @private
* @param str value potential URI component to check.
* @returns {boolean} True if `value` can be decoded
* with the decodeURIComponent function.
*/
function tryDecodeURIComponent(value) {
try {
return decodeURIComponent(value);
} catch (e) {
// Ignore any invalid uri component
}
}
/**
* Parses an escaped url query string into key-value pairs.
* @returns Object.<(string|boolean)>
*/
function parseKeyValue(/**string*/ keyValue) {
var obj = {},
key_value,
key;
forEach((keyValue || "").split("&"), function (keyValue) {
if (keyValue) {
key_value = keyValue.split("=");
key = tryDecodeURIComponent(key_value[0]);
if (isDefined(key)) {
var val = isDefined(key_value[1])
? tryDecodeURIComponent(key_value[1])
: true;
if (!obj[key]) {
obj[key] = val;
} else if (isArray(obj[key])) {
obj[key].push(val);
} else {
obj[key] = [obj[key], val];
}
}
}
});
return obj;
}
function toKeyValue(obj) {
var parts = [];
forEach(obj, function (value, key) {
if (isArray(value)) {
forEach(value, function (arrayValue) {
parts.push(
encodeUriQuery(key, true) +
(arrayValue === true
? ""
: "=" + encodeUriQuery(arrayValue, true)),
);
});
} else {
parts.push(
encodeUriQuery(key, true) +
(value === true ? "" : "=" + encodeUriQuery(value, true)),
);
}
});
return parts.length ? parts.join("&") : "";
}
/**
* We need our custom method because encodeURIComponent is too aggressive and doesn't follow
* http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
* segments:
* segment = *pchar
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* pct-encoded = "%" HEXDIG HEXDIG
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/
function encodeUriSegment(val) {
return encodeUriQuery(val, true)
.replace(/%26/gi, "&")
.replace(/%3D/gi, "=")
.replace(/%2B/gi, "+");
}
/**
* This method is intended for encoding *key* or *value* parts of query component. We need a custom
* method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
* encoded per http://tools.ietf.org/html/rfc3986:
* query = *( pchar / "/" / "?" )
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* pct-encoded = "%" HEXDIG HEXDIG
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/
function encodeUriQuery(val, pctEncodeSpaces) {
return encodeURIComponent(val)
.replace(/%40/gi, "@")
.replace(/%3A/gi, ":")
.replace(/%24/g, "$")
.replace(/%2C/gi, ",")
.replace(/%20/g, pctEncodeSpaces ? "%20" : "+");
}
/**
* @ngdoc directive
* @name ng.directive:ngApp
*
* @element ANY
* @param {angular.Module} ngApp an optional application
* {@link angular.module module} name to load.
*
* @description
*
* Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
* designates the **root element** of the application and is typically placed near the root element
* of the page - e.g. on the `<body>` or `<html>` tags.
*
* Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
* found in the document will be used to define the root element to auto-bootstrap as an
* application. To run multiple applications in an HTML document you must manually bootstrap them using
* {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
*
* You can specify an **AngularJS module** to be used as the root module for the application. This
* module will be loaded into the {@link AUTO.$injector} when the application is bootstrapped and
* should contain the application code needed or have dependencies on other modules that will
* contain the code. See {@link angular.module} for more information.
*
* In the example below if the `ngApp` directive were not placed on the `html` element then the
* document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
* would not be resolved to `3`.
*
* `ngApp` is the easiest, and most common, way to bootstrap an application.
*
<example module="ngAppDemo">
<file name="index.html">
<div ng-controller="ngAppDemoController">
I can add: {{a}} + {{b}} = {{ a+b }}
</file>
<file name="script.js">
angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
$scope.a = 1;
$scope.b = 2;
});
</file>
</example>
*
*/
function angularInit(element, bootstrap) {
var elements = [element],
appElement,
module,
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] = true;
append(document.getElementById(name));
name = name.replace(":", "\\:");
if (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 + " ";
var match = NG_APP_CLASS_REGEXP.exec(className);
if (match) {
appElement = element;
module = (match[2] || "").replace(/\s+/g, ",");
} else {
forEach(element.attributes, function (attr) {
if (!appElement && names[attr.name]) {
appElement = element;
module = attr.value;
}
});
}
}
});
if (appElement) {
bootstrap(appElement, module ? [module] : []);
}
}
/**
* @ngdoc function
* @name angular.bootstrap
* @description
* Use this function to manually start up angular application.
*
* See: {@link guide/bootstrap Bootstrap}
*
* Note that ngScenario-based end-to-end tests cannot use this function to bootstrap manually.
* They must use {@link api/ng.directive:ngApp ngApp}.
*
* @param {Element} element DOM element which is the root of angular application.
* @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
* Each item in the array should be the name of a predefined module or a (DI annotated)
* function that will be invoked by the injector as a run block.
* See: {@link angular.module modules}
* @returns {AUTO.$injector} Returns the newly created injector for this app.
*/
function bootstrap(element, modules) {
var doBootstrap = function () {
element = jqLite(element);
if (element.injector()) {
var tag = element[0] === document ? "document" : startingTag(element);
throw ngMinErr(
"btstrpd",
"App Already Bootstrapped with this Element '{0}'",
tag,
);
}
modules = modules || [];
modules.unshift([
"$provide",
function ($provide) {
$provide.value("$rootElement", element);
},
]);
modules.unshift("ng");
var injector = createInjector(modules);
injector.invoke([
"$rootScope",
"$rootElement",
"$compile",
"$injector",
"$animate",
function (scope, element, compile, injector, animate) {
scope.$apply(function () {
element.data("$injector", injector);
compile(element)(scope);
});
},
]);
return injector;
};
var 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();
};
}
var SNAKE_CASE_REGEXP = /[A-Z]/g;
function snake_case(name, separator) {
separator = separator || "_";
return name.replace(SNAKE_CASE_REGEXP, function (letter, pos) {
return (pos ? separator : "") + letter.toLowerCase();
});
}
function bindJQuery() {
// bind to jQuery if present;
jQuery = window.jQuery;
// reset to jQuery or default to us.
if (jQuery) {
jqLite = jQuery;
extend(jQuery.fn, {
scope: JQLitePrototype.scope,
isolateScope: JQLitePrototype.isolateScope,
controller: JQLitePrototype.controller,
injector: JQLitePrototype.injector,
inheritedData: JQLitePrototype.inheritedData,
});
// Method signature:
// jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments)
jqLitePatchJQueryRemove("remove", true, true, false);
jqLitePatchJQueryRemove("empty", false, false, false);
jqLitePatchJQueryRemove("html", false, false, true);
} else {
jqLite = JQLite;
}
angular.element = jqLite;
}
/**
* throw error if the argument is falsy.
*/
function assertArg(arg, name, reason) {
if (!arg) {
throw ngMinErr(
"areq",
"Argument '{0}' is {1}",
name || "?",
reason || "required",
);
}
return arg;
}
function assertArgFn(arg, name, acceptArrayAnnotation) {
if (acceptArrayAnnotation && isArray(arg)) {
arg = arg[arg.length - 1];
}
assertArg(
isFunction(arg),
name,
"not a function, got " +
(arg && typeof arg == "object"
? arg.constructor.name || "Object"
: typeof arg),
);
return arg;
}
/**
* throw error if the name given is hasOwnProperty
* @param {String} name the name to test
* @param {String} context the context in which the name is used, such as module or directive
*/
function assertNotHasOwnProperty(name, context) {
if (name === "hasOwnProperty") {
throw ngMinErr(
"badname",
"hasOwnProperty is not a valid {0} name",
context,
);
}
}
/**
* Return the value accessible from the object by path. Any undefined traversals are ignored
* @param {Object} obj starting object
* @param {string} path path to traverse
* @param {boolean=true} bindFnToScope
* @returns value as accessible by path
*/
//TODO(misko): this function needs to be removed
function getter(obj, path, bindFnToScope) {
if (!path) return obj;
var keys = path.split(".");
var key;
var lastInstance = obj;
var len = keys.length;
for (var i = 0; i < len; i++) {
key = keys[i];
if (obj) {
obj = (lastInstance = obj)[key];
}
}
if (!bindFnToScope && isFunction(obj)) {
return bind(lastInstance, obj);
}
return obj;
}
/**
* Return the DOM siblings between the first and last node in the given array.
* @param {Array} array like object
* @returns jQlite object containing the elements
*/
function getBlockElements(nodes) {
var startNode = nodes[0],
endNode = nodes[nodes.length - 1];
if (startNode === endNode) {
return jqLite(startNode);
}
var element = startNode;
var elements = [element];
do {
element = element.nextSibling;
if (!element) break;
elements.push(element);
} while (element !== endNode);
return jqLite(elements);
}
/**
* @ngdoc interface
* @name angular.Module
* @description
*
* Interface for configuring angular {@link angular.module modules}.
*/
function setupModuleLoader(window) {
var $injectorMinErr = minErr("$injector");
var ngMinErr = minErr("ng");
function ensure(obj, name, factory) {
return obj[name] || (obj[name] = factory());
}
var angular = ensure(window, "angular", Object);
// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
angular.$$minErr = angular.$$minErr || minErr;
return ensure(angular, "module", function () {
/** @type {Object.<string, angular.Module>} */
var modules = {};
/**
* @ngdoc function
* @name angular.module
* @description
*
* The `angular.module` is a global place for creating, registering and retrieving Angular
* modules.
* All modules (angular core or 3rd party) that should be available to an application must be
* registered using this mechanism.
*
* When passed two or more arguments, a new module is created. If passed only one argument, an
* existing module (the name passed as the first argument to `module`) is retrieved.
*
*
* # Module
*
* A module is a collection of services, directives, filters, and configuration information.
* `angular.module` is used to configure the {@link AUTO.$injector $injector}.
*
* <pre>
* // Create a new module
* var myModule = angular.module('myModule', []);
*
* // register a new service
* myModule.value('appName', 'MyCoolApp');
*
* // configure existing services inside initialization blocks.
* myModule.config(function($locationProvider) {
* // Configure existing providers
* $locationProvider.hashPrefix('!');
* });
* </pre>
*
* Then you can create an injector and load your modules like this:
*
* <pre>
* var injector = angular.injector(['ng', 'MyModule'])
* </pre>
*
* However it's more likely that you'll just use
* {@link ng.directive:ngApp ngApp} or
* {@link angular.bootstrap} to simplify this process for you.
*
* @param {!string} name The name of the module to create or retrieve.
* @param {Array.<string>=} requires If specified then new module is being created. If
* unspecified then the the module is being retrieved for further configuration.
* @param {Function} configFn Optional configuration function for the module. Same as
* {@link angular.Module#methods_config Module#config()}.
* @returns {module} new module with the {@link angular.Module} api.
*/
return function module(name, requires, configFn) {
var assertNotHasOwnProperty = function (name, context) {
if (name === "hasOwnProperty") {
throw ngMinErr(
"badname",
"hasOwnProperty is not a valid {0} name",
context,
);
}
};
assertNotHasOwnProperty(name, "module");
if (requires && modules.hasOwnProperty(name)) {
modules[name] = null;
}
return 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,
);
}
/** @type {!Array.<Array.<*>>} */
var invokeQueue = [];
/** @type {!Array.<Function>} */
var runBlocks = [];
var config = invokeLater("$injector", "invoke");
/** @type {angular.Module} */
var moduleInstance = {
// Private state
_invokeQueue: invokeQueue,
_runBlocks: runBlocks,
/**
* @ngdoc property
* @name angular.Module#requires
* @propertyOf angular.Module
* @returns {Array.<string>} List of module names which must be loaded before this module.
* @description
* Holds the list of modules which the injector will load before the current module is
* loaded.
*/
requires: requires,
/**
* @ngdoc property
* @name angular.Module#name
* @propertyOf angular.Module
* @returns {string} Name of the module.
* @description
*/
name: name,
/**
* @ngdoc method
* @name angular.Module#provider
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} providerType Construction function for creating new instance of the
* service.
* @description
* See {@link AUTO.$provide#provider $provide.provider()}.
*/
provider: invokeLater("$provide", "provider"),
/**
* @ngdoc method
* @name angular.Module#factory
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} providerFunction Function for creating new instance of the service.
* @description
* See {@link AUTO.$provide#factory $provide.factory()}.
*/
factory: invokeLater("$provide", "factory"),
/**
* @ngdoc method
* @name angular.Module#service
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} constructor A constructor function that will be instantiated.
* @description
* See {@link AUTO.$provide#service $provide.service()}.
*/
service: invokeLater("$provide", "service"),
/**
* @ngdoc method
* @name angular.Module#value
* @methodOf angular.Module
* @param {string} name service name
* @param {*} object Service instance object.
* @description
* See {@link AUTO.$provide#value $provide.value()}.
*/
value: invokeLater("$provide", "value"),
/**
* @ngdoc method
* @name angular.Module#constant
* @methodOf angular.Module
* @param {string} name constant name
* @param {*} object Constant value.
* @description
* Because the constant are fixed, they get applied before other provide methods.
* See {@link AUTO.$provide#constant $provide.constant()}.
*/
constant: invokeLater("$provide", "constant", "unshift"),
/**
* @ngdoc method
* @name angular.Module#animation
* @methodOf angular.Module
* @param {string} name animation name
* @param {Function} animationFactory Factory function for creating new instance of an
* animation.
* @description
*
* **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
*
*
* Defines an animation hook that can be later used with
* {@link ngAnimate.$animate $animate} service and directives that use this service.
*
* <pre>
* module.animation('.animation-name', function($inject1, $inject2) {
* return {
* eventName : function(element, done) {
* //code to run the animation
* //once complete, then run done()
* return function cancellationFunction(element) {
* //code to cancel the animation
* }
* }
* }
* })
* </pre>
*
* See {@link ngAnimate.$animateProvider#register $animateProvider.register()} and
* {@link ngAnimate ngAnimate module} for more information.
*/
animation: invokeLater("$animateProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#filter
* @methodOf angular.Module
* @param {string} name Filter name.
* @param {Function} filterFactory Factory function for creating new instance of filter.
* @description
* See {@link ng.$filterProvider#register $filterProvider.register()}.
*/
filter: invokeLater("$filterProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#controller
* @methodOf angular.Module
* @param {string|Object} name Controller name, or an object map of controllers where the
* keys are the names and the values are the constructors.
* @param {Function} constructor Controller constructor function.
* @description
* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
*/
controller: invokeLater("$controllerProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#directive
* @methodOf angular.Module
* @param {string|Object} name Directive name, or an object map of directives where the
* keys are the names and the values are the factories.
* @param {Function} directiveFactory Factory function for creating new instance of
* directives.
* @description
* See {@link ng.$compileProvider#methods_directive $compileProvider.directive()}.
*/
directive: invokeLater("$compileProvider", "directive"),
/**
* @ngdoc method
* @name angular.Module#config
* @methodOf angular.Module
* @param {Function} configFn Execute this function on module load. Useful for service
* configuration.
* @description
* Use this method to register work which needs to be performed on module loading.
*/
config: config,
/**
* @ngdoc method
* @name angular.Module#run
* @methodOf angular.Module
* @param {Function} initializationFn Execute this function after injector creation.
* Useful for application initialization.
* @description
* Use this method to register work which should be performed when the injector is done
* loading all modules.
*/
run: function (block) {
runBlocks.push(block);
return this;
},
};
if (configFn) {
config(configFn);
}
return moduleInstance;
/**
* @param {string} provider
* @param {string} method
* @param {String=} insertMethod
* @returns {angular.Module}
*/
function invokeLater(provider, method, insertMethod) {
return function () {
invokeQueue[insertMethod || "push"]([
provider,
method,
arguments,
]);
return moduleInstance;
};
}
});
};
});
}
/* global
angularModule: true,
version: true,
$LocaleProvider,
$CompileProvider,
htmlAnchorDirective,
inputDirective,
inputDirective,
formDirective,
scriptDirective,
selectDirective,
styleDirective,
optionDirective,
ngBindDirective,
ngBindHtmlDirective,
ngBindTemplateDirective,
ngClassDirective,
ngClassEvenDirective,
ngClassOddDirective,
ngCspDirective,
ngCloakDirective,
ngControllerDirective,
ngFormDirective,
ngHideDirective,
ngIfDirective,
ngIncludeDirective,
ngIncludeFillContentDirective,
ngInitDirective,
ngNonBindableDirective,
ngPluralizeDirective,
ngRepeatDirective,
ngShowDirective,
ngStyleDirective,
ngSwitchDirective,
ngSwitchWhenDirective,
ngSwitchDefaultDirective,
ngOptionsDirective,
ngTranscludeDirective,
ngModelDirective,
ngListDirective,
ngChangeDirective,
requiredDirective,
requiredDirective,
ngValueDirective,
ngAttributeAliasDirectives,
ngEventDirectives,
$AnchorScrollProvider,
$AnimateProvider,
$BrowserProvider,
$CacheFactoryProvider,
$ControllerProvider,
$DocumentProvider,
$ExceptionHandlerProvider,
$FilterProvider,
$InterpolateProvider,
$IntervalProvider,
$HttpProvider,
$HttpBackendProvider,
$LocationProvider,
$LogProvider,
$ParseProvider,
$RootScopeProvider,
$QProvider,
$$SanitizeUriProvider,
$SceProvider,
$SceDelegateProvider,
$SnifferProvider,
$TemplateCacheProvider,
$TimeoutProvider,
$WindowProvider
*/
/**
* @ngdoc property
* @name angular.version
* @description
* An object that contains information about the current AngularJS version. This object has the
* following properties:
*
* - `full` – `{string}` – Full version string, such as "0.9.18".
* - `major` – `{number}` – Major version number, such as "0".
* - `minor` – `{number}` – Minor version number, such as "9".
* - `dot` – `{number}` – Dot version number, such as "18".
* - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
*/
var version = {
full: "1.2.5", // all of these placeholder strings will be replaced by grunt's
major: 1, // package task
minor: 2,
dot: 5,
codeName: "singularity-expansion",
};
function publishExternalAPI(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 = setupModuleLoader(window);
try {
angularModule("ngLocale");
} catch (e) {
angularModule("ngLocale", []).provider("$locale", $LocaleProvider);
}
angularModule(
"ng",
["ngLocale"],
[
"$provide",
function ngModule($provide) {
// $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
$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,
});
},
],
);
}
/* global
-JQLitePrototype,
-addEventListenerFn,
-removeEventListenerFn,
-BOOLEAN_ATTR
*/
//////////////////////////////////
//JQLite
//////////////////////////////////
/**
* @ngdoc function
* @name angular.element
* @function
*
* @description
* Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
*
* If jQuery is available, `angular.element` is an alias for the
* [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
* delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."
*
* <div class="alert alert-success">jqLite is a tiny, API-compatible subset of jQuery that allows
* Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most
* commonly needed functionality with the goal of having a very small footprint.</div>
*
* To use jQuery, simply load it before `DOMContentLoaded` event fired.
*
* <div class="alert">**Note:** all element references in Angular are always wrapped with jQuery or
* jqLite; they are never raw DOM references.</div>
*
* ## Angular's jqLite
* jqLite provides only the following jQuery methods:
*
* - [`addClass()`](http://api.jquery.com/addClass/)
* - [`after()`](http://api.jquery.com/after/)
* - [`append()`](http://api.jquery.com/append/)
* - [`attr()`](http://api.jquery.com/attr/)
* - [`bind()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
* - [`children()`](http://api.jquery.com/children/) - Does not support selectors
* - [`clone()`](http://api.jquery.com/clone/)
* - [`contents()`](http://api.jquery.com/contents/)
* - [`css()`](http://api.jquery.com/css/)
* - [`data()`](http://api.jquery.com/data/)
* - [`empty()`](http://api.jquery.com/empty/)
* - [`eq()`](http://api.jquery.com/eq/)
* - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
* - [`hasClass()`](http://api.jquery.com/hasClass/)
* - [`html()`](http://api.jquery.com/html/)
* - [`next()`](http://api.jquery.com/next/) - Does not support selectors
* - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
* - [`off()`](http://api.jquery.com/off/) - Does not support namespaces or selectors
* - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
* - [`prepend()`](http://api.jquery.com/prepend/)
* - [`prop()`](http://api.jquery.com/prop/)
* - [`ready()`](http://api.jquery.com/ready/)
* - [`remove()`](http://api.jquery.com/remove/)
* - [`removeAttr()`](http://api.jquery.com/removeAttr/)
* - [`removeClass()`](http://api.jquery.com/removeClass/)
* - [`removeData()`](http://api.jquery.com/removeData/)
* - [`replaceWith()`](http://api.jquery.com/replaceWith/)
* - [`text()`](http://api.jquery.com/text/)
* - [`toggleClass()`](http://api.jquery.com/toggleClass/)
* - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
* - [`unbind()`](http://api.jquery.com/off/) - Does not support namespaces
* - [`val()`](http://api.jquery.com/val/)
* - [`wrap()`](http://api.jquery.com/wrap/)
*
* ## jQuery/jqLite Extras
* Angular also provides the following additional methods and events to both jQuery and jqLite:
*
* ### Events
* - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
* on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM
* element before it is removed.
*
* ### Methods
* - `controller(name)` - retrieves the controller of the current element or its parent. By default
* retrieves controller associated with the `ngController` directive. If `name` is provided as
* camelCase directive name, then the controller for this directive will be retrieved (e.g.
* `'ngModel'`).
* - `injector()` - retrieves the injector of the current element or its parent.
* - `scope()` - retrieves the {@link api/ng.$rootScope.Scope scope} of the current
* element or its parent.
* - `isolateScope()` - retrieves an isolate {@link api/ng.$rootScope.Scope scope} if one is attached directly to the
* current element. This getter should be used only on elements that contain a directive which starts a new isolate
* scope. Calling `scope()` on this element always returns the original non-isolate scope.
* - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
* parent element is reached.
*
* @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
* @returns {Object} jQuery object.
*/
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, false);
}
: function (element, type, fn) {
element.attachEvent("on" + type, fn);
},
removeEventListenerFn = window.document.removeEventListener
? function (element, type, fn) {
element.removeEventListener(type, fn, false);
}
: function (element, type, fn) {
element.detachEvent("on" + type, fn);
};
function jqNextId() {
return ++jqId;
}
var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
var MOZ_HACK_REGEXP = /^moz([A-Z])/;
var jqLiteMinErr = minErr("jqLite");
/**
* Converts snake_case to camelCase.
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/
function camelCase(name) {
return name
.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
return offset ? letter.toUpperCase() : letter;
})
.replace(MOZ_HACK_REGEXP, "Moz$1");
}
/////////////////////////////////////////////
// jQuery mutation patch
//
// In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a
// $destroy event on all DOM nodes being removed.
//
/////////////////////////////////////////////
function jqLitePatchJQueryRemove(
name,
dispatchThis,
filterElems,
getterIfNoArguments,
) {
var originalJqFn = jQuery.fn[name];
originalJqFn = originalJqFn.$original || originalJqFn;
removePatch.$original = originalJqFn;
jQuery.fn[name] = removePatch;
function removePatch(param) {
// jshint -W040
var list = filterElems && param ? [this.filter(param)] : [this],
fireEvent = dispatchThis,
set,
setIndex,
setLength,
element,
childIndex,
childLength,
children;
if (!getterIfNoArguments || param != null) {
while (list.length) {
set = list.shift();
for (
setIndex = 0, setLength = set.length;
setIndex < setLength;
setIndex++
) {
element = jqLite(set[setIndex]);
if (fireEvent) {
element.triggerHandler("$destroy");
} else {
fireEvent = !fireEvent;
}
for (
childIndex = 0,
childLength = (children = element.children()).length;
childIndex < childLength;
childIndex++
) {
list.push(jQuery(children[childIndex]));
}
}
}
}
return originalJqFn.apply(this, arguments);
}
}
/////////////////////////////////////////////
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");
// Read about the NoScope elements here:
// http://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
div.innerHTML = "<div> </div>" + element; // IE insanity to make NoScope elements work!
div.removeChild(div.firstChild); // remove the superfluous div
jqLiteAddNodes(this, div.childNodes);
var fragment = jqLite(document.createDocumentFragment());
fragment.append(this); // detach the elements from the temporary DOM div.
} else {
jqLiteAddNodes(this, element);
}
}
function jqLiteClone(element) {
return element.cloneNode(true);
}
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"),
handle = jqLiteExpandoStore(element, "handle");
if (!handle) return; //no listeners registered
if (isUndefined(type)) {
forEach(events, function (eventHandler, type) {
removeEventListenerFn(element, type, eventHandler);
delete events[type];
});
} else {
forEach(type.split(" "), function (type) {
if (isUndefined(fn)) {
removeEventListenerFn(element, type, events[type]);
delete events[type];
} else {
arrayRemove(events[type] || [], fn);
}
});
}
}
function jqLiteRemoveData(element, name) {
var expandoId = element[jqName],
expandoStore = jqCache[expandoId];
if (expandoStore) {
if (name) {
delete jqCache[expandoId].data[name];
return;
}
if (expandoStore.handle) {
expandoStore.events.$destroy && expandoStore.handle({}, "$destroy");
jqLiteOff(element);
}
delete jqCache[expandoId];
element[jqName] = undefined; // ie does not allow deletion of attributes on elements.
}
}
function jqLiteExpandoStore(element, key, value) {
var expandoId = element[jqName],
expandoStore = jqCache[expandoId || -1];
if (isDefined(value)) {
if (!expandoStore) {
element[jqName] = expandoId = jqNextId();
expandoStore = jqCache[expandoId] = {};
}
expandoStore[key] = value;
} else {
return expandoStore && expandoStore[key];
}
}
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 = {}));
}
if (isSetter) {
data[key] = value;
} else {
if (keyDefined) {
if (isSimpleGetter) {
// don't create data in this case.
return data && data[key];
} else {
extend(data, key);
}
} else {
return data;
}
}
}
function jqLiteHasClass(element, selector) {
if (!element.getAttribute) return false;
return (
(" " + (element.getAttribute("class") || "") + " ")
.replace(/[\n\t]/g, " ")
.indexOf(" " + selector + " ") > -1
);
}
function jqLiteRemoveClass(element, cssClasses) {
if (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);
if (existingClasses.indexOf(" " + cssClass + " ") === -1) {
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) {
element = jqLite(element);
// if element is the document object work with the html element instead
// this makes $(document).scope() possible
if (element[0].nodeType == 9) {
element = element.find("html");
}
var names = isArray(name) ? name : [name];
while (element.length) {
for (var i = 0, ii = names.length; i < ii; i++) {
if ((value = element.data(names[i])) !== undefined) return value;
}
element = element.parent();
}
}
function jqLiteEmpty(element) {
for (
var i = 0, childNodes = element.childNodes;
i < childNodes.length;
i++
) {
jqLiteDealoc(childNodes[i]);
}
while (element.firstChild) {
element.removeChild(element.firstChild);
}
}
//////////////////////////////////////////
// Functions which are declared directly.
//////////////////////////////////////////
var JQLitePrototype = (JQLite.prototype = {
ready: function (fn) {
var fired = false;
function trigger() {
if (fired) return;
fired = true;
fn();
}
// check if document already is loaded
if (document.readyState === "complete") {
setTimeout(trigger);
} else {
this.on("DOMContentLoaded", trigger); // works for modern browsers and IE9
// we can not use jqLite since we are not done loading and jQuery could be loaded later.
// jshint -W064
JQLite(window).on("load", trigger); // fallback to window.onload for others
// jshint +W064
}
},
toString: function () {
var value = [];
forEach(this, function (e) {
value.push("" + e);
});
return "[" + value.join(", ") + "]";
},
eq: function (index) {
return index >= 0
? jqLite(this[index])
: jqLite(this[this.length + index]);
},
length: 0,
push: push,
sort: [].sort,
splice: [].splice,
});
//////////////////////////////////////////
// Functions iterating getter/setters.
// these functions return self on setter and
// value on get.
//////////////////////////////////////////
var BOOLEAN_ATTR = {};
forEach(
"multiple,selected,checked,disabled,readOnly,required,open".split(","),
function (value) {
BOOLEAN_ATTR[lowercase(value)] = value;
},
);
var BOOLEAN_ELEMENTS = {};
forEach(
"input,select,option,textarea,button,form,details".split(","),
function (value) {
BOOLEAN_ELEMENTS[uppercase(value)] = true;
},
);
function getBooleanAttrName(element, name) {
// check dom last since we will most likely fail on name
var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
// booleanAttr is here twice to minimize DOM access
return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;
}
forEach(
{
data: jqLiteData,
inheritedData: jqLiteInheritedData,
scope: function (element) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
return (
jqLite(element).data("$scope") ||
jqLiteInheritedData(element.parentNode || element, [
"$isolateScope",
"$scope",
])
);
},
isolateScope: function (element) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
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) {
name = camelCase(name);
if (isDefined(value)) {
element.style[name] = value;
} else {
var val;
if (msie <= 8) {
// this is some IE specific weirdness that jQuery 1.6.4 does not sure why
val = element.currentStyle && element.currentStyle[name];
if (val === "") val = "auto";
}
val = val || element.style[name];
if (msie <= 8) {
// jquery weirdness :-/
val = val === "" ? undefined : val;
}
return val;
}
},
attr: function (element, name, value) {
var lowercasedName = lowercase(name);
if (BOOLEAN_ATTR[lowercasedName]) {
if (isDefined(value)) {
if (!!value) {
element[name] = true;
element.setAttribute(name, lowercasedName);
} else {
element[name] = false;
element.removeAttribute(lowercasedName);
}
} else {
return element[name] ||
(element.attributes.getNamedItem(name) || noop).specified
? lowercasedName
: undefined;
}
} else if (isDefined(value)) {
element.setAttribute(name, value);
} else if (element.getAttribute) {
// the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
// some elements (e.g. Document) don't have get attribute, so return undefined
var ret = element.getAttribute(name, 2);
// normalize non-existing attributes to undefined (as jQuery)
return ret === null ? undefined : ret;
}
},
prop: function (element, name, value) {
if (isDefined(value)) {
element[name] = value;
} else {
return element[name];
}
},
text: (function () {
var NODE_TYPE_TEXT_PROPERTY = [];
if (msie < 9) {
NODE_TYPE_TEXT_PROPERTY[1] = "innerText"; /** Element **/
NODE_TYPE_TEXT_PROPERTY[3] = "nodeValue"; /** Text **/
} else {
NODE_TYPE_TEXT_PROPERTY[1] =
/** Element **/
NODE_TYPE_TEXT_PROPERTY[3] = "textContent"; /** Text **/
}
getText.$dv = "";
return 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 (nodeName_(element) === "SELECT" && element.multiple) {
var result = [];
forEach(element.options, function (option) {
if (option.selected) {
result.push(option.value || option.text);
}
});
return result.length === 0 ? 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) {
/**
* Properties: writes return selection, reads return first value
*/
JQLite.prototype[name] = function (arg1, arg2) {
var i, key;
// jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
// in a way that survives minification.
// jqLiteEmpty takes no arguments but is a setter.
if (
fn !== jqLiteEmpty &&
(fn.length == 2 && fn !== jqLiteHasClass && fn !== jqLiteController
? arg1
: arg2) === undefined
) {
if (isObject(arg1)) {
// we are a write, but the object properties are the key/values
for (i = 0; i < this.length; i++) {
if (fn === jqLiteData) {
// data() takes the whole object in jQuery
fn(this[i], arg1);
} else {
for (key in arg1) {
fn(this[i], key, arg1[key]);
}
}
}
// return self for chaining
return this;
} else {
// we are a read, so read the first child.
var value = fn.$dv;
// Only if we have $dv do we iterate over all, otherwise it is just the first element.
var jj =
value === undefined ? Math.min(this.length, 1) : this.length;
for (var j = 0; j < jj; j++) {
var nodeValue = fn(this[j], arg1, arg2);
value = value ? value + nodeValue : nodeValue;
}
return value;
}
} else {
// we are a write, so apply to all children
for (i = 0; i < this.length; i++) {
fn(this[i], arg1, arg2);
}
// return self for chaining
return this;
}
};
},
);
function createEventHandler(element, events) {
var eventHandler = function (event, type) {
if (!event.preventDefault) {
event.preventDefault = function () {
event.returnValue = false; //ie
};
}
if (!event.stopPropagation) {
event.stopPropagation = function () {
event.cancelBubble = true; //ie
};
}
if (!event.target) {
event.target = event.srcElement || document;
}
if (isUndefined(event.defaultPrevented)) {
var prevent = event.preventDefault;
event.preventDefault = function () {
event.defaultPrevented = true;
prevent.call(event);
};
event.defaultPrevented = false;
}
event.isDefaultPrevented = function () {
return event.defaultPrevented || event.returnValue === false;
};
forEach(events[type || event.type], function (fn) {
fn.call(element, event);
});
// Remove monkey-patched methods (IE),
// as they would cause memory leaks in IE8.
if (msie <= 8) {
// IE7/8 does not allow to delete property on native object
event.preventDefault = null;
event.stopPropagation = null;
event.isDefaultPrevented = null;
} else {
// It shouldn't affect normal browsers (native methods are defined on prototype).
delete event.preventDefault;
delete event.stopPropagation;
delete event.isDefaultPrevented;
}
};
eventHandler.elem = element;
return eventHandler;
}
//////////////////////////////////////////
// Functions iterating traversal.
// These functions chain results into a single
// selector.
//////////////////////////////////////////
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");
if (!events) jqLiteExpandoStore(element, "events", (events = {}));
if (!handle)
jqLiteExpandoStore(
element,
"handle",
(handle = createEventHandler(element, events)),
);
forEach(type.split(" "), function (type) {
var eventFns = events[type];
if (!eventFns) {
if (type == "mouseenter" || type == "mouseleave") {
var contains =
document.body.contains || document.body.compareDocumentPosition
? function (a, b) {
// jshint bitwise: false
var adown = a.nodeType === 9 ? a.documentElement : a,
bup = b && b.parentNode;
return (
a === bup ||
!!(
bup &&
bup.nodeType === 1 &&
(adown.contains
? adown.contains(bup)
: a.compareDocumentPosition &&
a.compareDocumentPosition(bup) & 16)
)
);
}
: function (a, b) {
if (b) {
while ((b = b.parentNode)) {
if (b === a) {
return true;
}
}
}
return false;
};
events[type] = [];
// Refer to jQuery's implementation of mouseenter & mouseleave
// Read about mouseenter and mouseleave:
// http://www.quirksmode.org/js/events_mouse.html#link8
var eventmap = {
mouseleave: "mouseout",
mouseenter: "mouseover",
};
onFn(element, eventmap[type], function (event) {
var target = this,
related = event.relatedTarget;
// For mousenter/leave call the handler if related is outside the target.
// NB: No relatedTarget if the mouse left/entered the browser window
if (
!related ||
(related !== target && !contains(target, 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) {
if (index) {
parent.insertBefore(node, index.nextSibling);
} else {
parent.replaceChild(node, element);
}
index = node;
});
},
children: function (element) {
var children = [];
forEach(element.childNodes, function (element) {
if (element.nodeType === 1) children.push(element);
});
return children;
},
contents: function (element) {
return element.childNodes || [];
},
append: function (element, node) {
forEach(new JQLite(node), function (child) {
if (element.nodeType === 1 || element.nodeType === 11) {
element.appendChild(child);
}
});
},
prepend: function (element, node) {
if (element.nodeType === 1) {
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;
if (parent) {
parent.replaceChild(wrapNode, element);
}
wrapNode.appendChild(element);
},
remove: function (element) {
jqLiteDealoc(element);
var parent = element.parentNode;
if (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) {
if (isUndefined(condition)) {
condition = !jqLiteHasClass(element, selector);
}
(condition ? jqLiteAddClass : jqLiteRemoveClass)(element, selector);
},
parent: function (element) {
var parent = element.parentNode;
return parent && parent.nodeType !== 11 ? parent : null;
},
next: function (element) {
if (element.nextElementSibling) {
return element.nextElementSibling;
}
// IE8 doesn't have nextElementSibling
var elm = element.nextSibling;
while (elm != null && elm.nodeType !== 1) {
elm = elm.nextSibling;
}
return elm;
},
find: function (element, selector) {
if (element.getElementsByTagName) {
return element.getElementsByTagName(selector);
} else {
return [];
}
},
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) {
/**
* chaining functions
*/
JQLite.prototype[name] = function (arg1, arg2, arg3) {
var value;
for (var i = 0; i < this.length; i++) {
if (isUndefined(value)) {
value = fn(this[i], arg1, arg2, arg3);
if (isDefined(value)) {
// any function which returns a value needs to be wrapped
value = jqLite(value);
}
} else {
jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
}
}
return isDefined(value) ? value : this;
};
// bind legacy bind/unbind to on/off
JQLite.prototype.bind = JQLite.prototype.on;
JQLite.prototype.unbind = JQLite.prototype.off;
},
);
/**
* Computes a hash of an 'obj'.
* Hash of a:
* string is string
* number is number as string
* object is either result of calling $$hashKey function on the object or uniquely generated id,
* that is also assigned to the $$hashKey property of the object.
*
* @param obj
* @returns {string} hash string such that the same input will have the same hash string.
* The resulting string key is in 'type:hashKey' format.
*/
function hashKey(obj) {
var objType = typeof obj,
key;
if (objType == "object" && obj !== null) {
if (typeof (key = obj.$$hashKey) == "function") {
// must invoke on object to keep the right this
key = obj.$$hashKey();
} else if (key === undefined) {
key = obj.$$hashKey = nextUid();
}
} else {
key = obj;
}
return objType + ":" + key;
}
/**
* HashMap which can use objects as keys
*/
function HashMap(array) {
forEach(array, this.put, this);
}
HashMap.prototype = {
/**
* Store key value pair
* @param key key to store can be any type
* @param value value to store can be any type
*/
put: function (key, value) {
this[hashKey(key)] = value;
},
/**
* @param key
* @returns the value for the key
*/
get: function (key) {
return this[hashKey(key)];
},
/**
* Remove the key/value pair
* @param key
*/
remove: function (key) {
var value = this[(key = hashKey(key))];
delete this[key];
return value;
},
};
/**
* @ngdoc function
* @name angular.injector
* @function
*
* @description
* Creates an injector function that can be used for retrieving services as well as for
* dependency injection (see {@link guide/di dependency injection}).
*
* @param {Array.<string|Function>} modules A list of module functions or their aliases. See
* {@link angular.module}. The `ng` module must be explicitly added.
* @returns {function()} Injector function. See {@link AUTO.$injector $injector}.
*
* @example
* Typical usage
* <pre>
* // create an injector
* var $injector = angular.injector(['ng']);
*
* // use the injector to kick off your application
* // use the type inference to auto inject arguments, or use implicit injection
* $injector.invoke(function($rootScope, $compile, $document){
* $compile($document)($rootScope);
* $rootScope.$digest();
* });
* </pre>
*
* Sometimes you want to get access to the injector of a currently running Angular app
* from outside Angular. Perhaps, you want to inject and compile some markup after the
* application has been bootstrapped. You can do this using extra `injector()` added
* to JQuery/jqLite elements. See {@link angular.element}.
*
* *This is fairly rare but could be the case if a third party library is injecting the
* markup.*
*
* In the following example a new block of HTML containing a `ng-controller`
* directive is added to the end of the document body by JQuery. We then compile and link
* it into the current AngularJS scope.
*
* <pre>
* var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
* $(document.body).append($div);
*
* angular.element(document).injector().invoke(function($compile) {
* var scope = angular.element($div).scope();
* $compile($div)(scope);
* });
* </pre>
*/
/**
* @ngdoc overview
* @name AUTO
* @description
*
* Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
*/
var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
var $injectorMinErr = minErr("$injector");
function annotate(fn) {
var $inject, fnText, argDecl, last;
if (typeof fn == "function") {
if (!($inject = fn.$inject)) {
$inject = [];
if (fn.length) {
fnText = fn.toString().replace(STRIP_COMMENTS, "");
argDecl = fnText.match(FN_ARGS);
forEach(argDecl[1].split(FN_ARG_SPLIT), function (arg) {
arg.replace(FN_ARG, function (all, underscore, name) {
$inject.push(name);
});
});
}
fn.$inject = $inject;
}
} else if (isArray(fn)) {
last = fn.length - 1;
assertArgFn(fn[last], "fn");
$inject = fn.slice(0, last);
} else {
assertArgFn(fn, "fn", true);
}
return $inject;
}
///////////////////////////////////////
/**
* @ngdoc object
* @name AUTO.$injector
* @function
*
* @description
*
* `$injector` is used to retrieve object instances as defined by
* {@link AUTO.$provide provider}, instantiate types, invoke methods,
* and load modules.
*
* The following always holds true:
*
* <pre>
* var $injector = angular.injector();
* expect($injector.get('$injector')).toBe($injector);
* expect($injector.invoke(function($injector){
* return $injector;
* }).toBe($injector);
* </pre>
*
* # Injection Function Annotation
*
* JavaScript does not have annotations, and annotations are needed for dependency injection. The
* following are all valid ways of annotating function with injection arguments and are equivalent.
*
* <pre>
* // inferred (only works if code not minified/obfuscated)
* $injector.invoke(function(serviceA){});
*
* // annotated
* function explicit(serviceA) {};
* explicit.$inject = ['serviceA'];
* $injector.invoke(explicit);
*
* // inline
* $injector.invoke(['serviceA', function(serviceA){}]);
* </pre>
*
* ## Inference
*
* In JavaScript calling `toString()` on a function returns the function definition. The definition
* can then be parsed and the function arguments can be extracted. *NOTE:* This does not work with
* minification, and obfuscation tools since these tools change the argument names.
*
* ## `$inject` Annotation
* By adding a `$inject` property onto a function the injection parameters can be specified.
*
* ## Inline
* As an array of injection names, where the last item in the array is the function to call.
*/
/**
* @ngdoc method
* @name AUTO.$injector#get
* @methodOf AUTO.$injector
*
* @description
* Return an instance of the service.
*
* @param {string} name The name of the instance to retrieve.
* @return {*} The instance.
*/
/**
* @ngdoc method
* @name AUTO.$injector#invoke
* @methodOf AUTO.$injector
*
* @description
* Invoke the method and supply the method arguments from the `$injector`.
*
* @param {!function} fn The function to invoke. Function parameters are injected according to the
* {@link guide/di $inject Annotation} rules.
* @param {Object=} self The `this` for the invoked method.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {*} the value returned by the invoked `fn` function.
*/
/**
* @ngdoc method
* @name AUTO.$injector#has
* @methodOf AUTO.$injector
*
* @description
* Allows the user to query if the particular service exist.
*
* @param {string} Name of the service to query.
* @returns {boolean} returns true if injector has given service.
*/
/**
* @ngdoc method
* @name AUTO.$injector#instantiate
* @methodOf AUTO.$injector
* @description
* Create a new instance of JS type. The method takes a constructor function invokes the new
* operator and supplies all of the arguments to the constructor function as specified by the
* constructor annotation.
*
* @param {function} Type Annotated constructor function.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {Object} new instance of `Type`.
*/
/**
* @ngdoc method
* @name AUTO.$injector#annotate
* @methodOf AUTO.$injector
*
* @description
* Returns an array of service names which the function is requesting for injection. This API is
* used by the injector to determine which services need to be injected into the function when the
* function is invoked. There are three ways in which the function can be annotated with the needed
* dependencies.
*
* # Argument names
*
* The simplest form is to extract the dependencies from the arguments of the function. This is done
* by converting the function into a string using `toString()` method and extracting the argument
* names.
* <pre>
* // Given
* function MyController($scope, $route) {
* // ...
* }
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* This method does not work with code minification / obfuscation. For this reason the following
* annotation strategies are supported.
*
* # The `$inject` property
*
* If a function has an `$inject` property and its value is an array of strings, then the strings
* represent names of services to be injected into the function.
* <pre>
* // Given
* var MyController = function(obfuscatedScope, obfuscatedRoute) {
* // ...
* }
* // Define function dependencies
* MyController['$inject'] = ['$scope', '$route'];
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* # The array notation
*
* It is often desirable to inline Injected functions and that's when setting the `$inject` property
* is very inconvenient. In these situations using the array notation to specify the dependencies in
* a way that survives minification is a better choice:
*
* <pre>
* // We wish to write this (not minification / obfuscation safe)
* injector.invoke(function($compile, $rootScope) {
* // ...
* });
*
* // We are forced to write break inlining
* var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
* // ...
* };
* tmpFn.$inject = ['$compile', '$rootScope'];
* injector.invoke(tmpFn);
*
* // To better support inline function the inline annotation is supported
* injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
* // ...
* }]);
*
* // Therefore
* expect(injector.annotate(
* ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
* ).toEqual(['$compile', '$rootScope']);
* </pre>
*
* @param {function|Array.<string|Function>} fn Function for which dependent service names need to
* be retrieved as described above.
*
* @returns {Array.<string>} The names of the services which the function requires.
*/
/**
* @ngdoc object
* @name AUTO.$provide
*
* @description
*
* The {@link AUTO.$provide $provide} service has a number of methods for registering components
* with the {@link AUTO.$injector $injector}. Many of these functions are also exposed on
* {@link angular.Module}.
*
* An Angular **service** is a singleton object created by a **service factory**. These **service
* factories** are functions which, in turn, are created by a **service provider**.
* The **service providers** are constructor functions. When instantiated they must contain a
* property called `$get`, which holds the **service factory** function.
*
* When you request a service, the {@link AUTO.$injector $injector} is responsible for finding the
* correct **service provider**, instantiating it and then calling its `$get` **service factory**
* function to get the instance of the **service**.
*
* Often services have no configuration options and there is no need to add methods to the service
* provider. The provider will be no more than a constructor function with a `$get` property. For
* these cases the {@link AUTO.$provide $provide} service has additional helper methods to register
* services without specifying a provider.
*
* * {@link AUTO.$provide#methods_provider provider(provider)} - registers a **service provider** with the
* {@link AUTO.$injector $injector}
* * {@link AUTO.$provide#methods_constant constant(obj)} - registers a value/object that can be accessed by
* providers and services.
* * {@link AUTO.$provide#methods_value value(obj)} - registers a value/object that can only be accessed by
* services, not providers.
* * {@link AUTO.$provide#methods_factory factory(fn)} - registers a service **factory function**, `fn`,
* that will be wrapped in a **service provider** object, whose `$get` property will contain the
* given factory function.
* * {@link AUTO.$provide#methods_service service(class)} - registers a **constructor function**, `class` that
* that will be wrapped in a **service provider** object, whose `$get` property will instantiate
* a new object using the given constructor function.
*
* See the individual methods for more information and examples.
*/
/**
* @ngdoc method
* @name AUTO.$provide#provider
* @methodOf AUTO.$provide
* @description
*
* Register a **provider function** with the {@link AUTO.$injector $injector}. Provider functions
* are constructor functions, whose instances are responsible for "providing" a factory for a
* service.
*
* Service provider names start with the name of the service they provide followed by `Provider`.
* For example, the {@link ng.$log $log} service has a provider called
* {@link ng.$logProvider $logProvider}.
*
* Service provider objects can have additional methods which allow configuration of the provider
* and its service. Importantly, you can configure what kind of service is created by the `$get`
* method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
* method {@link ng.$logProvider#debugEnabled debugEnabled}
* which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
* console or not.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name +
'Provider'` key.
* @param {(Object|function())} provider If the provider is:
*
* - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
* {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be
* created.
* - `Constructor`: a new instance of the provider will be created using
* {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as
* `object`.
*
* @returns {Object} registered provider instance
* @example
*
* The following example shows how to create a simple event tracking service and register it using
* {@link AUTO.$provide#methods_provider $provide.provider()}.
*
* <pre>
* // Define the eventTracker provider
* function EventTrackerProvider() {
* var trackingUrl = '/track';
*
* // A provider method for configuring where the tracked events should been saved
* this.setTrackingUrl = function(url) {
* trackingUrl = url;
* };
*
* // The service factory function
* this.$get = ['$http', function($http) {
* var trackedEvents = {};
* return {
* // Call this to track an event
* event: function(event) {
* var count = trackedEvents[event] || 0;
* count += 1;
* trackedEvents[event] = count;
* return count;
* },
* // Call this to save the tracked events to the trackingUrl
* save: function() {
* $http.post(trackingUrl, trackedEvents);
* }
* };
* }];
* }
*
* describe('eventTracker', function() {
* var postSpy;
*
* beforeEach(module(function($provide) {
* // Register the eventTracker provider
* $provide.provider('eventTracker', EventTrackerProvider);
* }));
*
* beforeEach(module(function(eventTrackerProvider) {
* // Configure eventTracker provider
* eventTrackerProvider.setTrackingUrl('/custom-track');
* }));
*
* it('tracks events', inject(function(eventTracker) {
* expect(eventTracker.event('login')).toEqual(1);
* expect(eventTracker.event('login')).toEqual(2);
* }));
*
* it('saves to the tracking url', inject(function(eventTracker, $http) {
* postSpy = spyOn($http, 'post');
* eventTracker.event('login');
* eventTracker.save();
* expect(postSpy).toHaveBeenCalled();
* expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
* expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
* expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
* }));
* });
* </pre>
*/
/**
* @ngdoc method
* @name AUTO.$provide#factory
* @methodOf AUTO.$provide
* @description
*
* Register a **service factory**, which will be called to return the service instance.
* This is short for registering a service where its provider consists of only a `$get` property,
* which is the given service factory function.
* You should use {@link AUTO.$provide#factory $provide.factory(getFn)} if you do not need to
* configure your service in a provider.
*
* @param {string} name The name of the instance.
* @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand
* for `$provide.provider(name, {$get: $getFn})`.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service
* <pre>
* $provide.factory('ping', ['$http', function($http) {
* return function ping() {
* return $http.send('/ping');
* };
* }]);
* </pre>
* You would then inject and use this service like this:
* <pre>
* someModule.controller('Ctrl', ['ping', function(ping) {
* ping();
* }]);
* </pre>
*/
/**
* @ngdoc method
* @name AUTO.$provide#service
* @methodOf AUTO.$provide
* @description
*
* Register a **service constructor**, which will be invoked with `new` to create the service
* instance.
* This is short for registering a service where its provider's `$get` property is the service
* constructor function that will be used to instantiate the service instance.
*
* You should use {@link AUTO.$provide#methods_service $provide.service(class)} if you define your service
* as a type/class. This is common when using {@link http://coffeescript.org CoffeeScript}.
*
* @param {string} name The name of the instance.
* @param {Function} constructor A class (constructor function) that will be instantiated.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service using
* {@link AUTO.$provide#methods_service $provide.service(class)} that is defined as a CoffeeScript class.
* <pre>
* class Ping
* constructor: (@$http)->
* send: ()=>
* @$http.get('/ping')
*
* $provide.service('ping', ['$http', Ping])
* </pre>
* You would then inject and use this service like this:
* <pre>
* someModule.controller 'Ctrl', ['ping', (ping)->
* ping.send()
* ]
* </pre>
*/
/**
* @ngdoc method
* @name AUTO.$provide#value
* @methodOf AUTO.$provide
* @description
*
* Register a **value service** with the {@link AUTO.$injector $injector}, such as a string, a
* number, an array, an object or a function. This is short for registering a service where its
* provider's `$get` property is a factory function that takes no arguments and returns the **value
* service**.
*
* Value services are similar to constant services, except that they cannot be injected into a
* module configuration function (see {@link angular.Module#config}) but they can be overridden by
* an Angular
* {@link AUTO.$provide#decorator decorator}.
*
* @param {string} name The name of the instance.
* @param {*} value The value.
* @returns {Object} registered provider instance
*
* @example
* Here are some examples of creating value services.
* <pre>
* $provide.value('ADMIN_USER', 'admin');
*
* $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
*
* $provide.value('halfOf', function(value) {
* return value / 2;
* });
* </pre>
*/
/**
* @ngdoc method
* @name AUTO.$provide#constant
* @methodOf AUTO.$provide
* @description
*
* Register a **constant service**, such as a string, a number, an array, an object or a function,
* with the {@link AUTO.$injector $injector}. Unlike {@link AUTO.$provide#value value} it can be
* injected into a module configuration function (see {@link angular.Module#config}) and it cannot
* be overridden by an Angular {@link AUTO.$provide#decorator decorator}.
*
* @param {string} name The name of the constant.
* @param {*} value The constant value.
* @returns {Object} registered instance
*
* @example
* Here a some examples of creating constants:
* <pre>
* $provide.constant('SHARD_HEIGHT', 306);
*
* $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
*
* $provide.constant('double', function(value) {
* return value * 2;
* });
* </pre>
*/
/**
* @ngdoc method
* @name AUTO.$provide#decorator
* @methodOf AUTO.$provide
* @description
*
* Register a **service decorator** with the {@link AUTO.$injector $injector}. A service decorator
* intercepts the creation of a service, allowing it to override or modify the behaviour of the
* service. The object returned by the decorator may be the original service, or a new service
* object which replaces or wraps and delegates to the original service.
*
* @param {string} name The name of the service to decorate.
* @param {function()} decorator This function will be invoked when the service needs to be
* instantiated and should return the decorated service instance. The function is called using
* the {@link AUTO.$injector#invoke injector.invoke} method and is therefore fully injectable.
* Local injection arguments:
*
* * `$delegate` - The original service instance, which can be monkey patched, configured,
* decorated or delegated to.
*
* @example
* Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
* calls to {@link ng.$log#error $log.warn()}.
* <pre>
* $provider.decorator('$log', ['$delegate', function($delegate) {
* $delegate.warn = $delegate.error;
* return $delegate;
* }]);
* </pre>
*/
function createInjector(modulesToLoad) {
var INSTANTIATING = {},
providerSuffix = "Provider",
path = [],
loadedModules = new HashMap(),
providerCache = {
$provide: {
provider: supportObject(provider),
factory: supportObject(factory),
service: supportObject(service),
value: supportObject(value),
constant: supportObject(constant),
decorator: decorator,
},
},
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 + providerSuffix);
return instanceInjector.invoke(provider.$get, provider);
},
));
forEach(loadModules(modulesToLoad), function (fn) {
instanceInjector.invoke(fn || noop);
});
return instanceInjector;
////////////////////////////////////
// $provider
////////////////////////////////////
function supportObject(delegate) {
return function (key, value) {
if (isObject(key)) {
forEach(key, reverseParams(delegate));
} else {
return delegate(key, value);
}
};
}
function provider(name, provider_) {
assertNotHasOwnProperty(name, "service");
if (isFunction(provider_) || isArray(provider_)) {
provider_ = providerInjector.instantiate(provider_);
}
if (!provider_.$get) {
throw $injectorMinErr(
"pget",
"Provider '{0}' must define $get factory method.",
name,
);
}
return (providerCache[name + providerSuffix] = provider_);
}
function factory(name, factoryFn) {
return provider(name, { $get: factoryFn });
}
function service(name, constructor) {
return factory(name, [
"$injector",
function ($injector) {
return $injector.instantiate(constructor);
},
]);
}
function value(name, val) {
return factory(name, valueFn(val));
}
function constant(name, value) {
assertNotHasOwnProperty(name, "constant");
providerCache[name] = value;
instanceCache[name] = value;
}
function decorator(serviceName, decorFn) {
var origProvider = providerInjector.get(serviceName + providerSuffix),
orig$get = origProvider.$get;
origProvider.$get = function () {
var origInstance = instanceInjector.invoke(orig$get, origProvider);
return instanceInjector.invoke(decorFn, null, {
$delegate: origInstance,
});
};
}
////////////////////////////////////
// Module Loading
////////////////////////////////////
function loadModules(modulesToLoad) {
var runBlocks = [],
moduleFn,
invokeQueue,
i,
ii;
forEach(modulesToLoad, function (module) {
if (loadedModules.get(module)) return;
loadedModules.put(module, true);
try {
if (isString(module)) {
moduleFn = angularModule(module);
runBlocks = runBlocks
.concat(loadModules(moduleFn.requires))
.concat(moduleFn._runBlocks);
for (
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 if (isFunction(module)) {
runBlocks.push(providerInjector.invoke(module));
} else if (isArray(module)) {
runBlocks.push(providerInjector.invoke(module));
} else {
assertArgFn(module, "module");
}
} catch (e) {
if (isArray(module)) {
module = module[module.length - 1];
}
if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {
// Safari & FF's stack traces don't contain error.message content
// unlike those of Chrome and IE
// So if stack doesn't contain message, we create a new string that contains both.
// Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
/* jshint -W022 */
e = e.message + "\n" + e.stack;
}
throw $injectorMinErr(
"modulerr",
"Failed to instantiate module {0} due to:\n{1}",
module,
e.stack || e.message || e,
);
}
});
return runBlocks;
}
////////////////////////////////////
// internal Injector
////////////////////////////////////
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];
} else {
try {
path.unshift(serviceName);
cache[serviceName] = INSTANTIATING;
return (cache[serviceName] = factory(serviceName));
} finally {
path.shift();
}
}
}
function invoke(fn, self, locals) {
var args = [],
$inject = annotate(fn),
length,
i,
key;
for (i = 0, length = $inject.length; i < length; i++) {
key = $inject[i];
if (typeof key !== "string") {
throw $injectorMinErr(
"itkn",
"Incorrect injection token! Expected service name as string, got {0}",
key,
);
}
args.push(
locals && locals.hasOwnProperty(key)
? locals[key]
: getService(key),
);
}
if (!fn.$inject) {
// this means that we must be an array.
fn = fn[length];
}
// http://jsperf.com/angularjs-invoke-apply-vs-switch
// #5388
return fn.apply(self, args);
}
function instantiate(Type, locals) {
var Constructor = function () {},
instance,
returnedValue;
// Check if Type is annotated and use just the given function at n-1 as parameter
// e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
Constructor.prototype = (
isArray(Type) ? Type[Type.length - 1] : Type
).prototype;
instance = new Constructor();
returnedValue = invoke(Type, instance, locals);
return isObject(returnedValue) || isFunction(returnedValue)
? returnedValue
: instance;
}
return {
invoke: invoke,
instantiate: instantiate,
get: getService,
annotate: annotate,
has: function (name) {
return (
providerCache.hasOwnProperty(name + providerSuffix) ||
cache.hasOwnProperty(name)
);
},
};
}
}
/**
* @ngdoc function
* @name ng.$anchorScroll
* @requires $window
* @requires $location
* @requires $rootScope
*
* @description
* When called, it checks current value of `$location.hash()` and scroll to related element,
* according to rules specified in
* {@link http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document Html5 spec}.
*
* It also watches the `$location.hash()` and scrolls whenever it changes to match any anchor.
* This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
*
* @example
<example>
<file name="index.html">
<div id="scrollArea" ng-controller="ScrollCtrl">
<a ng-click="gotoBottom()">Go to bottom</a>
<a id="bottom"></a> You're at the bottom!
</div>
</file>
<file name="script.js">
function ScrollCtrl($scope, $location, $anchorScroll) {
$scope.gotoBottom = function (){
// set the location.hash to the id of
// the element you wish to scroll to.
$location.hash('bottom');
// call $anchorScroll()
$anchorScroll();
}
}
</file>
<file name="style.css">
#scrollArea {
height: 350px;
overflow: auto;
}
#bottom {
display: block;
margin-top: 2000px;
}
</file>
</example>
*/
function $AnchorScrollProvider() {
var autoScrollingEnabled = true;
this.disableAutoScrolling = function () {
autoScrollingEnabled = false;
};
this.$get = [
"$window",
"$location",
"$rootScope",
function ($window, $location, $rootScope) {
var document = $window.document;
// helper function to get first anchor from a NodeList
// can't use filter.filter, as it accepts only instances of Array
// and IE can't convert NodeList to an array using [].slice
// TODO(vojta): use filter if we change it to accept lists as well
function getFirstAnchor(list) {
var result = null;
forEach(list, function (element) {
if (!result && lowercase(element.nodeName) === "a")
result = element;
});
return result;
}
function scroll() {
var hash = $location.hash(),
elm;
// empty hash, scroll to the top of the page
if (!hash) $window.scrollTo(0, 0);
// element with given id
else if ((elm = document.getElementById(hash))) elm.scrollIntoView();
// first anchor with given name :-D
else if ((elm = getFirstAnchor(document.getElementsByName(hash))))
elm.scrollIntoView();
// no element and hash == 'top', scroll to the top of the page
else if (hash === "top") $window.scrollTo(0, 0);
}
// does not scroll when user clicks on anchor link that is currently on
// (no url change, no $location.hash() change), browser native does scroll
if (autoScrollingEnabled) {
$rootScope.$watch(
function autoScrollWatch() {
return $location.hash();
},
function autoScrollWatchAction() {
$rootScope.$evalAsync(scroll);
},
);
}
return scroll;
},
];
}
var $animateMinErr = minErr("$animate");
/**
* @ngdoc object
* @name ng.$animateProvider
*
* @description
* Default implementation of $animate that doesn't perform any animations, instead just
* synchronously performs DOM
* updates and calls done() callbacks.
*
* In order to enable animations the ngAnimate module has to be loaded.
*
* To see the functional implementation check out src/ngAnimate/animate.js
*/
var $AnimateProvider = [
"$provide",
function ($provide) {
this.$$selectors = {};
/**
* @ngdoc function
* @name ng.$animateProvider#register
* @methodOf ng.$animateProvider
*
* @description
* Registers a new injectable animation factory function. The factory function produces the
* animation object which contains callback functions for each event that is expected to be
* animated.
*
* * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`
* must be called once the element animation is complete. If a function is returned then the
* animation service will use this function to cancel the animation whenever a cancel event is
* triggered.
*
*
*<pre>
* return {
* eventFn : function(element, done) {
* //code to run the animation
* //once complete, then run done()
* return function cancellationFunction() {
* //code to cancel the animation
* }
* }
* }
*</pre>
*
* @param {string} name The name of the animation.
* @param {function} factory The factory function that will be executed to return the animation
* object.
*/
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) {
/**
*
* @ngdoc object
* @name ng.$animate
* @description The $animate service provides rudimentary DOM manipulation functions to
* insert, remove and move elements within the DOM, as well as adding and removing classes.
* This service is the core service used by the ngAnimate $animator service which provides
* high-level animation hooks for CSS and JavaScript.
*
* $animate is available in the AngularJS core, however, the ngAnimate module must be included
* to enable full out animation support. Otherwise, $animate will only perform simple DOM
* manipulation operations.
*
* To learn more about enabling animation support, click here to visit the {@link ngAnimate
* ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service
* page}.
*/
return {
/**
*
* @ngdoc function
* @name ng.$animate#enter
* @methodOf ng.$animate
* @function
* @description Inserts the element into the DOM either after the `after` element or within
* the `parent` element. Once complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will be inserted into the DOM
* @param {jQuery/jqLite element} parent the parent element which will append the element as
* a child (if the after element is not present)
* @param {jQuery/jqLite element} after the sibling element which will append the element
* after itself
* @param {function=} done callback function that will be called after the element has been
* inserted into the DOM
*/
enter: function (element, parent, after, done) {
if (after) {
after.after(element);
} else {
if (!parent || !parent[0]) {
parent = after.parent();
}
parent.append(element);
}
done && $timeout(done, 0, false);
},
/**
*
* @ngdoc function
* @name ng.$animate#leave
* @methodOf ng.$animate
* @function
* @description Removes the element from the DOM. Once complete, the done() callback will be
* fired (if provided).
* @param {jQuery/jqLite element} element the element which will be removed from the DOM
* @param {function=} done callback function that will be called after the element has been
* removed from the DOM
*/
leave: function (element, done) {
element.remove();
done && $timeout(done, 0, false);
},
/**
*
* @ngdoc function
* @name ng.$animate#move
* @methodOf ng.$animate
* @function
* @description Moves the position of the provided element within the DOM to be placed
* either after the `after` element or inside of the `parent` element. Once complete, the
* done() callback will be fired (if provided).
*
* @param {jQuery/jqLite element} element the element which will be moved around within the
* DOM
* @param {jQuery/jqLite element} parent the parent element where the element will be
* inserted into (if the after element is not present)
* @param {jQuery/jqLite element} after the sibling element where the element will be
* positioned next to
* @param {function=} done the callback function (if provided) that will be fired after the
* element has been moved to its new position
*/
move: function (element, parent, after, done) {
// Do not remove element before insert. Removing will cause data associated with the
// element to be dropped. Insert will implicitly do the remove.
this.enter(element, parent, after, done);
},
/**
*
* @ngdoc function
* @name ng.$animate#addClass
* @methodOf ng.$animate
* @function
* @description Adds the provided className CSS class value to the provided element. Once
* complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will have the className value
* added to it
* @param {string} className the CSS class which will be added to the element
* @param {function=} done the callback function (if provided) that will be fired after the
* className value has been added to the element
*/
addClass: function (element, className, done) {
className = isString(className)
? className
: isArray(className)
? className.join(" ")
: "";
forEach(element, function (element) {
jqLiteAddClass(element, className);
});
done && $timeout(done, 0, false);
},
/**
*
* @ngdoc function
* @name ng.$animate#removeClass
* @methodOf ng.$animate
* @function
* @description Removes the provided className CSS class value from the provided element.
* Once complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will have the className value
* removed from it
* @param {string} className the CSS class which will be removed from the element
* @param {function=} done the callback function (if provided) that will be fired after the
* className value has been removed from the element
*/
removeClass: function (element, className, done) {
className = isString(className)
? className
: isArray(className)
? className.join(" ")
: "";
forEach(element, function (element) {
jqLiteRemoveClass(element, className);
});
done && $timeout(done, 0, false);
},
enabled: noop,
};
},
];
},
];
/**
* ! This is a private undocumented service !
*
* @name ng.$browser
* @requires $log
* @description
* This object has two goals:
*
* - hide all the global state in the browser caused by the window object
* - abstract away all the browser specific features and inconsistencies
*
* For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
* service, which can be used for convenient testing of the application without the interaction with
* the real browser apis.
*/
/**
* @param {object} window The global window object.
* @param {object} document jQuery wrapped document.
* @param {function()} XHR XMLHttpRequest constructor.
* @param {object} $log console.log or an object with the same interface.
* @param {object} $sniffer $sniffer service
*/
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 = false;
var outstandingRequestCount = 0;
var outstandingRequestCallbacks = [];
// TODO(vojta): remove this temporary api
self.$$completeOutstandingRequest = completeOutstandingRequest;
self.$$incOutstandingRequestCount = function () {
outstandingRequestCount++;
};
/**
* Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`
* counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.
*/
function completeOutstandingRequest(fn) {
try {
fn.apply(null, sliceArgs(arguments, 1));
} finally {
outstandingRequestCount--;
if (outstandingRequestCount === 0) {
while (outstandingRequestCallbacks.length) {
try {
outstandingRequestCallbacks.pop()();
} catch (e) {
$log.error(e);
}
}
}
}
}
/**
* @private
* Note: this method is used only by scenario runner
* TODO(vojta): prefix this method with $$ ?
* @param {function()} callback Function that will be called when no outstanding request
*/
self.notifyWhenNoOutstandingRequests = function (callback) {
// force browser to execute all pollFns - this is needed so that cookies and other pollers fire
// at some deterministic time in respect to the test runner's actions. Leaving things up to the
// regular poller would result in flaky tests.
forEach(pollFns, function (pollFn) {
pollFn();
});
if (outstandingRequestCount === 0) {
callback();
} else {
outstandingRequestCallbacks.push(callback);
}
};
//////////////////////////////////////////////////////////////
// Poll Watcher API
//////////////////////////////////////////////////////////////
var pollFns = [],
pollTimeout;
/**
* @name ng.$browser#addPollFn
* @methodOf ng.$browser
*
* @param {function()} fn Poll function to add
*
* @description
* Adds a function to the list of functions that poller periodically executes,
* and starts polling if not started yet.
*
* @returns {function()} the added function
*/
self.addPollFn = function (fn) {
if (isUndefined(pollTimeout)) startPoller(100, setTimeout);
pollFns.push(fn);
return fn;
};
/**
* @param {number} interval How often should browser call poll functions (ms)
* @param {function()} setTimeout Reference to a real or fake `setTimeout` function.
*
* @description
* Configures the poller to run in the specified intervals, using the specified
* setTimeout fn and kicks it off.
*/
function startPoller(interval, setTimeout) {
(function check() {
forEach(pollFns, function (pollFn) {
pollFn();
});
pollTimeout = setTimeout(check, interval);
})();
}
//////////////////////////////////////////////////////////////
// URL API
//////////////////////////////////////////////////////////////
var lastBrowserUrl = location.href,
baseElement = document.find("base"),
newLocation = null;
/**
* @name ng.$browser#url
* @methodOf ng.$browser
*
* @description
* GETTER:
* Without any argument, this method just returns current value of location.href.
*
* SETTER:
* With at least one argument, this method sets url to new value.
* If html5 history api supported, pushState/replaceState is used, otherwise
* location.href/location.replace is used.
* Returns its own instance to allow chaining
*
* NOTE: this api is intended for use only by the $location service. Please use the
* {@link ng.$location $location service} to change url.
*
* @param {string} url New url (when used as setter)
* @param {boolean=} replace Should new url replace current history record ?
*/
self.url = function (url, replace) {
// Android Browser BFCache causes location reference to become stale.
if (location !== window.location) location = window.location;
// setter
if (url) {
if (lastBrowserUrl == url) return;
lastBrowserUrl = url;
if ($sniffer.history) {
if (replace) history.replaceState(null, "", url);
else {
history.pushState(null, "", url);
// Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462
baseElement.attr("href", baseElement.attr("href"));
}
} else {
newLocation = url;
if (replace) {
location.replace(url);
} else {
location.href = url;
}
}
return self;
// getter
} else {
// - newLocation is a workaround for an IE7-9 issue with location.replace and location.href
// methods not updating location.href synchronously.
// - the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172
return newLocation || location.href.replace(/%27/g, "'");
}
};
var urlChangeListeners = [],
urlChangeInit = false;
function fireUrlChange() {
newLocation = null;
if (lastBrowserUrl == self.url()) return;
lastBrowserUrl = self.url();
forEach(urlChangeListeners, function (listener) {
listener(self.url());
});
}
/**
* @name ng.$browser#onUrlChange
* @methodOf ng.$browser
* @TODO(vojta): refactor to use node's syntax for events
*
* @description
* Register callback function that will be called, when url changes.
*
* It's only called when the url is changed by outside of angular:
* - user types different url into address bar
* - user clicks on history (forward/back) button
* - user clicks on a link
*
* It's not called when url is changed by $browser.url() method
*
* The listener gets called with new url as parameter.
*
* NOTE: this api is intended for use only by the $location service. Please use the
* {@link ng.$location $location service} to monitor url changes in angular apps.
*
* @param {function(string)} listener Listener function to be called when url changes.
* @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
*/
self.onUrlChange = function (callback) {
if (!urlChangeInit) {
// We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)
// don't fire popstate when user change the address bar and don't fire hashchange when url
// changed by push/replaceState
// html5 history api - popstate event
if ($sniffer.history) jqLite(window).on("popstate", fireUrlChange);
// hashchange event
if ($sniffer.hashchange) jqLite(window).on("hashchange", fireUrlChange);
// polling
else self.addPollFn(fireUrlChange);
urlChangeInit = true;
}
urlChangeListeners.push(callback);
return callback;
};
//////////////////////////////////////////////////////////////
// Misc API
//////////////////////////////////////////////////////////////
/**
* @name ng.$browser#baseHref
* @methodOf ng.$browser
*
* @description
* Returns current <base href>
* (always relative - without domain)
*
* @returns {string=} current <base href>
*/
self.baseHref = function () {
var href = baseElement.attr("href");
return href ? href.replace(/^https?\:\/\/[^\/]*/, "") : "";
};
//////////////////////////////////////////////////////////////
// Cookies API
//////////////////////////////////////////////////////////////
var lastCookies = {};
var lastCookieString = "";
var cookiePath = self.baseHref();
/**
* @name ng.$browser#cookies
* @methodOf ng.$browser
*
* @param {string=} name Cookie name
* @param {string=} value Cookie value
*
* @description
* The cookies method provides a 'private' low level access to browser cookies.
* It is not meant to be used directly, use the $cookie service instead.
*
* The return values vary depending on the arguments that the method was called with as follows:
*
* - cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify
* it
* - cookies(name, value) -> set name to value, if value is undefined delete the cookie
* - cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that
* way)
*
* @returns {Object} Hash of all cookies (if called without any parameter)
*/
self.cookies = function (name, value) {
/* global escape: false, unescape: false */
var cookieLength, cookieArray, cookie, i, index;
if (name) {
if (value === undefined) {
rawDocument.cookie =
escape(name) +
"=;path=" +
cookiePath +
";expires=Thu, 01 Jan 1970 00:00:00 GMT";
} else {
if (isString(value)) {
cookieLength =
(rawDocument.cookie =
escape(name) + "=" + escape(value) + ";path=" + cookiePath)
.length + 1;
// per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
// - 300 cookies
// - 20 cookies per unique domain
// - 4096 bytes per cookie
if (cookieLength > 4096) {
$log.warn(
"Cookie '" +
name +
"' possibly not set or overflowed because it was too large (" +
cookieLength +
" > 4096 bytes)!",
);
}
}
}
} else {
if (rawDocument.cookie !== lastCookieString) {
lastCookieString = rawDocument.cookie;
cookieArray = lastCookieString.split("; ");
lastCookies = {};
for (i = 0; i < cookieArray.length; i++) {
cookie = cookieArray[i];
index = cookie.indexOf("=");
if (index > 0) {
//ignore nameless cookies
name = unescape(cookie.substring(0, index));
// the first value that is seen for a cookie is the most
// specific one. values for the same cookie name that
// follow are for less specific paths.
if (lastCookies[name] === undefined) {
lastCookies[name] = unescape(cookie.substring(index + 1));
}
}
}
}
return lastCookies;
}
};
/**
* @name ng.$browser#defer
* @methodOf ng.$browser
* @param {function()} fn A function, who's execution should be deferred.
* @param {number=} [delay=0] of milliseconds to defer the function execution.
* @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
*
* @description
* Executes a fn asynchronously via `setTimeout(fn, delay)`.
*
* Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
* `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
* via `$browser.defer.flush()`.
*
*/
self.defer = function (fn, delay) {
var timeoutId;
outstandingRequestCount++;
timeoutId = setTimeout(function () {
delete pendingDeferIds[timeoutId];
completeOutstandingRequest(fn);
}, delay || 0);
pendingDeferIds[timeoutId] = true;
return timeoutId;
};
/**
* @name ng.$browser#defer.cancel
* @methodOf ng.$browser.defer
*
* @description
* Cancels a deferred task identified with `deferId`.
*
* @param {*} deferId Token returned by the `$browser.defer` function.
* @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
* canceled.
*/
self.defer.cancel = function (deferId) {
if (pendingDeferIds[deferId]) {
delete pendingDeferIds[deferId];
clearTimeout(deferId);
completeOutstandingRequest(noop);
return true;
}
return false;
};
}
function $BrowserProvider() {
this.$get = [
"$window",
"$log",
"$sniffer",
"$document",
function ($window, $log, $sniffer, $document) {
return new Browser($window, $document, $log, $sniffer);
},
];
}
/**
* @ngdoc object
* @name ng.$cacheFactory
*
* @description
* Factory that constructs cache objects and gives access to them.
*
* <pre>
*
* var cache = $cacheFactory('cacheId');
* expect($cacheFactory.get('cacheId')).toBe(cache);
* expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
*
* cache.put("key", "value");
* cache.put("another key", "another value");
*
* // We've specified no options on creation
* expect(cache.info()).toEqual({id: 'cacheId', size: 2});
*
* </pre>
*
*
* @param {string} cacheId Name or id of the newly created cache.
* @param {object=} options Options object that specifies the cache behavior. Properties:
*
* - `{number=}` `capacity` — turns the cache into LRU cache.
*
* @returns {object} Newly created cache object with the following set of methods:
*
* - `{object}` `info()` — Returns id, size, and options of cache.
* - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns
* it.
* - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
* - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
* - `{void}` `removeAll()` — Removes all cached values.
* - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
*
*/
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) {
var lruEntry = lruHash[key] || (lruHash[key] = { key: key });
refresh(lruEntry);
if (isUndefined(value)) return;
if (!(key in data)) size++;
data[key] = value;
if (size > capacity) {
this.remove(staleEnd.key);
}
return value;
},
get: function (key) {
var lruEntry = lruHash[key];
if (!lruEntry) return;
refresh(lruEntry);
return data[key];
},
remove: function (key) {
var lruEntry = lruHash[key];
if (!lruEntry) return;
if (lruEntry == freshEnd) freshEnd = lruEntry.p;
if (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 });
},
});
/**
* makes the `entry` the freshEnd of the LRU linked list
*/
function refresh(entry) {
if (entry != freshEnd) {
if (!staleEnd) {
staleEnd = entry;
} else if (staleEnd == entry) {
staleEnd = entry.n;
}
link(entry.n, entry.p);
link(entry, freshEnd);
freshEnd = entry;
freshEnd.n = null;
}
}
/**
* bidirectionally links two entries of the LRU linked list
*/
function link(nextEntry, prevEntry) {
if (nextEntry != prevEntry) {
if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify
if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify
}
}
}
/**
* @ngdoc method
* @name ng.$cacheFactory#info
* @methodOf ng.$cacheFactory
*
* @description
* Get information about all the of the caches that have been created
*
* @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info`
*/
cacheFactory.info = function () {
var info = {};
forEach(caches, function (cache, cacheId) {
info[cacheId] = cache.info();
});
return info;
};
/**
* @ngdoc method
* @name ng.$cacheFactory#get
* @methodOf ng.$cacheFactory
*
* @description
* Get access to a cache object by the `cacheId` used when it was created.
*
* @param {string} cacheId Name or id of a cache to access.
* @returns {object} Cache object identified by the cacheId or undefined if no such cache.
*/
cacheFactory.get = function (cacheId) {
return caches[cacheId];
};
return cacheFactory;
};
}
/**
* @ngdoc object
* @name ng.$templateCache
*
* @description
* The first time a template is used, it is loaded in the template cache for quick retrieval. You
* can load templates directly into the cache in a `script` tag, or by consuming the
* `$templateCache` service directly.
*
* Adding via the `script` tag:
* <pre>
* <html ng-app>
* <head>
* <script type="text/ng-template" id="templateId.html">
* This is the content of the template
* </script>
* </head>
* ...
* </html>
* </pre>
*
* **Note:** the `script` tag containing the template does not need to be included in the `head` of
* the document, but it must be below the `ng-app` definition.
*
* Adding via the $templateCache service:
*
* <pre>
* var myApp = angular.module('myApp', []);
* myApp.run(function($templateCache) {
* $templateCache.put('templateId.html', 'This is the content of the template');
* });
* </pre>
*
* To retrieve the template later, simply use it in your HTML:
* <pre>
* <div ng-include=" 'templateId.html' "></div>
* </pre>
*
* or get it via Javascript:
* <pre>
* $templateCache.get('templateId.html')
* </pre>
*
* See {@link ng.$cacheFactory $cacheFactory}.
*
*/
function $TemplateCacheProvider() {
this.$get = [
"$cacheFactory",
function ($cacheFactory) {
return $cacheFactory("templates");
},
];
}
/* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!
*
* DOM-related variables:
*
* - "node" - DOM Node
* - "element" - DOM Element or Node
* - "$node" or "$element" - jqLite-wrapped node or element
*
*
* Compiler related stuff:
*
* - "linkFn" - linking fn of a single directive
* - "nodeLinkFn" - function that aggregates all linking fns for a particular node
* - "childLinkFn" - function that aggregates all linking fns for child nodes of a particular node
* - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList)
*/
/**
* @ngdoc function
* @name ng.$compile
* @function
*
* @description
* Compiles a piece of HTML string or DOM into a template and produces a template function, which
* can then be used to link {@link ng.$rootScope.Scope `scope`} and the template together.
*
* The compilation is a process of walking the DOM tree and matching DOM elements to
* {@link ng.$compileProvider#methods_directive directives}.
*
* <div class="alert alert-warning">
* **Note:** This document is an in-depth reference of all directive options.
* For a gentle introduction to directives with examples of common use cases,
* see the {@link guide/directive directive guide}.
* </div>
*
* ## Comprehensive Directive API
*
* There are many different options for a directive.
*
* The difference resides in the return value of the factory function.
* You can either return a "Directive Definition Object" (see below) that defines the directive properties,
* or just the `postLink` function (all other properties will have the default values).
*
* <div class="alert alert-success">
* **Best Practice:** It's recommended to use the "directive definition object" form.
* </div>
*
* Here's an example directive declared with a Directive Definition Object:
*
* <pre>
* var myModule = angular.module(...);
*
* myModule.directive('directiveName', function factory(injectables) {
* var directiveDefinitionObject = {
* priority: 0,
* template: '<div></div>', // or // function(tElement, tAttrs) { ... },
* // or
* // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... },
* replace: false,
* transclude: false,
* restrict: 'A',
* scope: false,
* controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
* require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],
* compile: function compile(tElement, tAttrs, transclude) {
* return {
* pre: function preLink(scope, iElement, iAttrs, controller) { ... },
* post: function postLink(scope, iElement, iAttrs, controller) { ... }
* }
* // or
* // return function postLink( ... ) { ... }
* },
* // or
* // link: {
* // pre: function preLink(scope, iElement, iAttrs, controller) { ... },
* // post: function postLink(scope, iElement, iAttrs, controller) { ... }
* // }
* // or
* // link: function postLink( ... ) { ... }
* };
* return directiveDefinitionObject;
* });
* </pre>
*
* <div class="alert alert-warning">
* **Note:** Any unspecified options will use the default value. You can see the default values below.
* </div>
*
* Therefore the above can be simplified as:
*
* <pre>
* var myModule = angular.module(...);
*
* myModule.directive('directiveName', function factory(injectables) {
* var directiveDefinitionObject = {
* link: function postLink(scope, iElement, iAttrs) { ... }
* };
* return directiveDefinitionObject;
* // or
* // return function postLink(scope, iElement, iAttrs) { ... }
* });
* </pre>
*
*
*
* ### Directive Definition Object
*
* The directive definition object provides instructions to the {@link api/ng.$compile
* compiler}. The attributes are:
*
* #### `priority`
* When there are multiple directives defined on a single DOM element, sometimes it
* is necessary to specify the order in which the directives are applied. The `priority` is used
* to sort the directives before their `compile` functions get called. Priority is defined as a
* number. Directives with greater numerical `priority` are compiled first. Pre-link functions
* are also run in priority order, but post-link functions are run in reverse order. The order
* of directives with the same priority is undefined. The default priority is `0`.
*
* #### `terminal`
* If set to true then the current `priority` will be the last set of directives
* which will execute (any directives at the current priority will still execute
* as the order of execution on same `priority` is undefined).
*
* #### `scope`
* **If set to `true`,** then a new scope will be created for this directive. If multiple directives on the
* same element request a new scope, only one new scope is created. The new scope rule does not
* apply for the root of the template since the root of the template always gets a new scope.
*
* **If set to `{}` (object hash),** then a new "isolate" scope is created. The 'isolate' scope differs from
* normal scope in that it does not prototypically inherit from the parent scope. This is useful
* when creating reusable components, which should not accidentally read or modify data in the
* parent scope.
*
* The 'isolate' scope takes an object hash which defines a set of local scope properties
* derived from the parent scope. These local properties are useful for aliasing values for
* templates. Locals definition is a hash of local scope property to its source:
*
* * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is
* always a string since DOM attributes are strings. If no `attr` name is specified then the
* attribute name is assumed to be the same as the local name.
* Given `<widget my-attr="hello {{name}}">` and widget definition
* of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect
* the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the
* `localName` property on the widget scope. The `name` is read from the parent scope (not
* component scope).
*
* * `=` or `=attr` - set up bi-directional binding between a local scope property and the
* parent scope property of name defined via the value of the `attr` attribute. If no `attr`
* name is specified then the attribute name is assumed to be the same as the local name.
* Given `<widget my-attr="parentModel">` and widget definition of
* `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the
* value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
* in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent
* scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You
* can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional.
*
* * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.
* If no `attr` name is specified then the attribute name is assumed to be the same as the
* local name. Given `<widget my-attr="count = count + value">` and widget definition of
* `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to
* a function wrapper for the `count = count + value` expression. Often it's desirable to
* pass data from the isolated scope via an expression and to the parent scope, this can be
* done by passing a map of local variable names and values into the expression wrapper fn.
* For example, if the expression is `increment(amount)` then we can specify the amount value
* by calling the `localFn` as `localFn({amount: 22})`.
*
*
*
* #### `controller`
* Controller constructor function. The controller is instantiated before the
* pre-linking phase and it is shared with other directives (see
* `require` attribute). This allows the directives to communicate with each other and augment
* each other's behavior. The controller is injectable (and supports bracket notation) with the following locals:
*
* * `$scope` - Current scope associated with the element
* * `$element` - Current element
* * `$attrs` - Current attributes object for the element
* * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope.
* The scope can be overridden by an optional first argument.
* `function([scope], cloneLinkingFn)`.
*
*
* #### `require`
* Require another directive and inject its controller as the fourth argument to the linking function. The
* `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the
* injected argument will be an array in corresponding order. If no such directive can be
* found, or if the directive does not have a controller, then an error is raised. The name can be prefixed with:
*
* * (no prefix) - Locate the required controller on the current element. Throw an error if not found.
* * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.
* * `^` - Locate the required controller by searching the element's parents. Throw an error if not found.
* * `?^` - Attempt to locate the required controller by searching the element's parents or pass `null` to the
* `link` fn if not found.
*
*
* #### `controllerAs`
* Controller alias at the directive scope. An alias for the controller so it
* can be referenced at the directive template. The directive needs to define a scope for this
* configuration to be used. Useful in the case when directive is used as component.
*
*
* #### `restrict`
* String of subset of `EACM` which restricts the directive to a specific directive
* declaration style. If omitted, the default (attributes only) is used.
*
* * `E` - Element name: `<my-directive></my-directive>`
* * `A` - Attribute (default): `<div my-directive="exp"></div>`
* * `C` - Class: `<div class="my-directive: exp;"></div>`
* * `M` - Comment: `<!-- directive: my-directive exp -->`
*
*
* #### `template`
* replace the current element with the contents of the HTML. The replacement process
* migrates all of the attributes / classes from the old element to the new one. See the
* {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive
* Directives Guide} for an example.
*
* You can specify `template` as a string representing the template or as a function which takes
* two arguments `tElement` and `tAttrs` (described in the `compile` function api below) and
* returns a string value representing the template.
*
*
* #### `templateUrl`
* Same as `template` but the template is loaded from the specified URL. Because
* the template loading is asynchronous the compilation/linking is suspended until the template
* is loaded.
*
* You can specify `templateUrl` as a string representing the URL or as a function which takes two
* arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns
* a string value representing the url. In either case, the template URL is passed through {@link
* api/ng.$sce#methods_getTrustedResourceUrl $sce.getTrustedResourceUrl}.
*
*
* #### `replace`
* specify where the template should be inserted. Defaults to `false`.
*
* * `true` - the template will replace the current element.
* * `false` - the template will replace the contents of the current element.
*
*
* #### `transclude`
* compile the content of the element and make it available to the directive.
* Typically used with {@link api/ng.directive:ngTransclude
* ngTransclude}. The advantage of transclusion is that the linking function receives a
* transclusion function which is pre-bound to the correct scope. In a typical setup the widget
* creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate`
* scope. This makes it possible for the widget to have private state, and the transclusion to
* be bound to the parent (pre-`isolate`) scope.
*
* * `true` - transclude the content of the directive.
* * `'element'` - transclude the whole element including any directives defined at lower priority.
*
*
* #### `compile`
*
* <pre>
* function compile(tElement, tAttrs, transclude) { ... }
* </pre>
*
* The compile function deals with transforming the template DOM. Since most directives do not do
* template transformation, it is not used often. Examples that require compile functions are
* directives that transform template DOM, such as {@link
* api/ng.directive:ngRepeat ngRepeat}, or load the contents
* asynchronously, such as {@link api/ngRoute.directive:ngView ngView}. The
* compile function takes the following arguments.
*
* * `tElement` - template element - The element where the directive has been declared. It is
* safe to do template transformation on the element and child elements only.
*
* * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared
* between all directive compile functions.
*
* * `transclude` - [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)`
*
* <div class="alert alert-warning">
* **Note:** The template instance and the link instance may be different objects if the template has
* been cloned. For this reason it is **not** safe to do anything other than DOM transformations that
* apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration
* should be done in a linking function rather than in a compile function.
* </div>
*
* <div class="alert alert-error">
* **Note:** The `transclude` function that is passed to the compile function is deprecated, as it
* e.g. does not know about the right outer scope. Please use the transclude function that is passed
* to the link function instead.
* </div>
* A compile function can have a return value which can be either a function or an object.
*
* * returning a (post-link) function - is equivalent to registering the linking function via the
* `link` property of the config object when the compile function is empty.
*
* * returning an object with function(s) registered via `pre` and `post` properties - allows you to
* control when a linking function should be called during the linking phase. See info about
* pre-linking and post-linking functions below.
*
*
* #### `link`
* This property is used only if the `compile` property is not defined.
*
* <pre>
* function link(scope, iElement, iAttrs, controller, transcludeFn) { ... }
* </pre>
*
* The link function is responsible for registering DOM listeners as well as updating the DOM. It is
* executed after the template has been cloned. This is where most of the directive logic will be
* put.
*
* * `scope` - {@link api/ng.$rootScope.Scope Scope} - The scope to be used by the
* directive for registering {@link api/ng.$rootScope.Scope#methods_$watch watches}.
*
* * `iElement` - instance element - The element where the directive is to be used. It is safe to
* manipulate the children of the element only in `postLink` function since the children have
* already been linked.
*
* * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared
* between all directive linking functions.
*
* * `controller` - a controller instance - A controller instance if at least one directive on the
* element defines a controller. The controller is shared among all the directives, which allows
* the directives to use the controllers as a communication channel.
*
* * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
* The scope can be overridden by an optional first argument. This is the same as the `$transclude`
* parameter of directive controllers.
* `function([scope], cloneLinkingFn)`.
*
*
* #### Pre-linking function
*
* Executed before the child elements are linked. Not safe to do DOM transformation since the
* compiler linking function will fail to locate the correct elements for linking.
*
* #### Post-linking function
*
* Executed after the child elements are linked. It is safe to do DOM transformation in the post-linking function.
*
* <a name="Attributes"></a>
* ### Attributes
*
* The {@link api/ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the
* `link()` or `compile()` functions. It has a variety of uses.
*
* accessing *Normalized attribute names:*
* Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'.
* the attributes object allows for normalized access to
* the attributes.
*
* * *Directive inter-communication:* All directives share the same instance of the attributes
* object which allows the directives to use the attributes object as inter directive
* communication.
*
* * *Supports interpolation:* Interpolation attributes are assigned to the attribute object
* allowing other directives to read the interpolated value.
*
* * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes
* that contain interpolation (e.g. `src="{{bar}}"`). Not only is this very efficient but it's also
* the only way to easily get the actual value because during the linking phase the interpolation
* hasn't been evaluated yet and so the value is at this time set to `undefined`.
*
* <pre>
* function linkingFn(scope, elm, attrs, ctrl) {
* // get the attribute value
* console.log(attrs.ngModel);
*
* // change the attribute
* attrs.$set('ngModel', 'new value');
*
* // observe changes to interpolated attribute
* attrs.$observe('ngModel', function(value) {
* console.log('ngModel has changed value to ' + value);
* });
* }
* </pre>
*
* Below is an example using `$compileProvider`.
*
* <div class="alert alert-warning">
* **Note**: Typically directives are registered with `module.directive`. The example below is
* to illustrate how `$compile` works.
* </div>
*
<doc:example module="compile">
<doc:source>
<script>
angular.module('compile', [], function($compileProvider) {
// configure new 'compile' directive by passing a directive
// factory function. The factory function injects the '$compile'
$compileProvider.directive('compile', function($compile) {
// directive factory creates a link function
return function(scope, element, attrs) {
scope.$watch(
function(scope) {
// watch the 'compile' expression for changes
return scope.$eval(attrs.compile);
},
function(value) {
// when the 'compile' expression changes
// assign it into the current DOM
element.html(value);
// compile the new DOM and link it to the current
// scope.
// NOTE: we only compile .childNodes so that
// we don't get into infinite loop compiling ourselves
$compile(element.contents())(scope);
}
);
};
})
});
function Ctrl($scope) {
$scope.name = 'Angular';
$scope.html = 'Hello {{name}}';
}
</script>
<div ng-controller="Ctrl">
<input ng-model="name"> <br>
<textarea ng-model="html"></textarea> <br>
<div compile="html"></div>
</div>
</doc:source>
<doc:scenario>
it('should auto compile', function() {
expect(element('div[compile]').text()).toBe('Hello Angular');
input('html').enter('{{name}}!');
expect(element('div[compile]').text()).toBe('Angular!');
});
</doc:scenario>
</doc:example>
*
*
* @param {string|DOMElement} element Element or HTML string to compile into a template function.
* @param {function(angular.Scope[, cloneAttachFn]} transclude function available to directives.
* @param {number} maxPriority only apply directives lower then given priority (Only effects the
* root element(s), not their children)
* @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template
* (a DOM element/tree) to a scope. Where:
*
* * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
* * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
* `template` and call the `cloneAttachFn` function allowing the caller to attach the
* cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
* called as: <br> `cloneAttachFn(clonedElement, scope)` where:
*
* * `clonedElement` - is a clone of the original `element` passed into the compiler.
* * `scope` - is the current scope with which the linking function is working with.
*
* Calling the linking function returns the element of the template. It is either the original
* element passed in, or the clone of the element if the `cloneAttachFn` is provided.
*
* After linking the view is not updated until after a call to $digest which typically is done by
* Angular automatically.
*
* If you need access to the bound view, there are two ways to do it:
*
* - If you are not asking the linking function to clone the template, create the DOM element(s)
* before you send them to the compiler and keep this reference around.
* <pre>
* var element = $compile('<p>{{total}}</p>')(scope);
* </pre>
*
* - if on the other hand, you need the element to be cloned, the view reference from the original
* example would not point to the clone, but rather to the original template that was cloned. In
* this case, you can access the clone via the cloneAttachFn:
* <pre>
* var templateHTML = angular.element('<p>{{total}}</p>'),
* scope = ....;
*
* var clonedElement = $compile(templateHTML)(scope, function(clonedElement, scope) {
* //attach the clone to DOM document at the right place
* });
*
* //now we have reference to the cloned DOM via `clone`
* </pre>
*
*
* For information on how the compiler works, see the
* {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.
*/
var $compileMinErr = minErr("$compile");
/**
* @ngdoc service
* @name ng.$compileProvider
* @function
*
* @description
*/
$CompileProvider.$inject = ["$provide", "$$sanitizeUriProvider"];
function $CompileProvider($provide, $$sanitizeUriProvider) {
var hasDirectives = {},
Suffix = "Directive",
COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/;
// Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes
// The assumption is that future DOM event attribute names will begin with
// 'on' and be composed of only English letters.
var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
/**
* @ngdoc function
* @name ng.$compileProvider#directive
* @methodOf ng.$compileProvider
* @function
*
* @description
* Register a new directive with the compiler.
*
* @param {string|Object} name Name of the directive in camel-case (i.e. <code>ngBind</code> which
* will match as <code>ng-bind</code>), or an object map of directives where the keys are the
* names and the values are the factories.
* @param {function|Array} directiveFactory An injectable directive factory function. See
* {@link guide/directive} for more info.
* @returns {ng.$compileProvider} Self for chaining.
*/
this.directive = function registerDirective(name, directiveFactory) {
assertNotHasOwnProperty(name, "directive");
if (isString(name)) {
assertArg(directiveFactory, "directiveFactory");
if (!hasDirectives.hasOwnProperty(name)) {
hasDirectives[name] = [];
$provide.factory(name + Suffix, [
"$injector",
"$exceptionHandler",
function ($injector, $exceptionHandler) {
var directives = [];
forEach(hasDirectives[name], function (directiveFactory, index) {
try {
var directive = $injector.invoke(directiveFactory);
if (isFunction(directive)) {
directive = { compile: valueFn(directive) };
} else if (!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);
}
});
return directives;
},
]);
}
hasDirectives[name].push(directiveFactory);
} else {
forEach(name, reverseParams(registerDirective));
}
return this;
};
/**
* @ngdoc function
* @name ng.$compileProvider#aHrefSanitizationWhitelist
* @methodOf ng.$compileProvider
* @function
*
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during a[href] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to a[href] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/
this.aHrefSanitizationWhitelist = function (regexp) {
if (isDefined(regexp)) {
$$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp);
return this;
} else {
return $$sanitizeUriProvider.aHrefSanitizationWhitelist();
}
};
/**
* @ngdoc function
* @name ng.$compileProvider#imgSrcSanitizationWhitelist
* @methodOf ng.$compileProvider
* @function
*
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during img[src] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to img[src] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/
this.imgSrcSanitizationWhitelist = function (regexp) {
if (isDefined(regexp)) {
$$sanitizeUriProvider.imgSrcSanitizationWhitelist(regexp);
return this;
} else {
return $$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,
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$addClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Adds the CSS class value specified by the classVal parameter to the element. If animations
* are enabled then an animation will be triggered for the class addition.
*
* @param {string} classVal The className value that will be added to the element
*/
$addClass: function (classVal) {
if (classVal && classVal.length > 0) {
$animate.addClass(this.$$element, classVal);
}
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$removeClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Removes the CSS class value specified by the classVal parameter from the element. If
* animations are enabled then an animation will be triggered for the class removal.
*
* @param {string} classVal The className value that will be removed from the element
*/
$removeClass: function (classVal) {
if (classVal && classVal.length > 0) {
$animate.removeClass(this.$$element, classVal);
}
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$updateClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Adds and removes the appropriate CSS class values to the element based on the difference
* between the new and old CSS class values (specified as newClasses and oldClasses).
*
* @param {string} newClasses The current CSS className value
* @param {string} oldClasses The former CSS className value
*/
$updateClass: function (newClasses, oldClasses) {
this.$removeClass(tokenDifference(oldClasses, newClasses));
this.$addClass(tokenDifference(newClasses, oldClasses));
},
/**
* Set a normalized attribute on the element in a way such that all directives
* can share the attribute. This function properly handles boolean attributes.
* @param {string} key Normalized key. (ie ngAttribute)
* @param {string|boolean} value The value to set. If `null` attribute will be deleted.
* @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
* Defaults to true.
* @param {string=} attrName Optional none normalized name. Defaults to key.
*/
$set: function (key, value, writeAttr, attrName) {
// TODO: decide whether or not to throw an error if "class"
//is set through this function since it may cause $updateClass to
//become unstable.
var booleanKey = getBooleanAttrName(this.$$element[0], key),
normalizedVal,
nodeName;
if (booleanKey) {
this.$$element.prop(key, value);
attrName = booleanKey;
}
this[key] = value;
// translate normalized key to actual key
if (attrName) {
this.$attr[key] = attrName;
} else {
attrName = this.$attr[key];
if (!attrName) {
this.$attr[key] = attrName = snake_case(key, "-");
}
}
nodeName = nodeName_(this.$$element);
// sanitize a[href] and img[src] values
if (
(nodeName === "A" && key === "href") ||
(nodeName === "IMG" && key === "src")
) {
this[key] = value = $$sanitizeUri(value, key === "src");
}
if (writeAttr !== false) {
if (value === null || value === undefined) {
this.$$element.removeAttr(attrName);
} else {
this.$$element.attr(attrName, value);
}
}
// fire observers
var $$observers = this.$$observers;
$$observers &&
forEach($$observers[key], function (fn) {
try {
fn(value);
} catch (e) {
$exceptionHandler(e);
}
});
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$observe
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Observes an interpolated attribute.
*
* The observer function will be invoked once during the next `$digest` following
* compilation. The observer is then invoked whenever the interpolated value
* changes.
*
* @param {string} key Normalized key. (ie ngAttribute) .
* @param {function(interpolatedValue)} fn Function that will be called whenever
the interpolated value of the attribute changes.
* See the {@link guide/directive#Attributes Directives} guide for more info.
* @returns {function()} the `fn` parameter.
*/
$observe: function (key, fn) {
var attrs = this,
$$observers = attrs.$$observers || (attrs.$$observers = {}),
listeners = $$observers[key] || ($$observers[key] = []);
listeners.push(fn);
$rootScope.$evalAsync(function () {
if (!listeners.$$inter) {
// no one registered attribute interpolation function, so lets call it manually
fn(attrs[key]);
}
});
return fn;
},
};
var startSymbol = $interpolate.startSymbol(),
endSymbol = $interpolate.endSymbol(),
denormalizeTemplate =
startSymbol == "{{" || endSymbol == "}}"
? identity
: function denormalizeTemplate(template) {
return template
.replace(/\{\{/g, startSymbol)
.replace(/}}/g, endSymbol);
},
NG_ATTR_BINDING = /^ngAttr[A-Z]/;
return compile;
//================================
function compile(
$compileNodes,
transcludeFn,
maxPriority,
ignoreDirective,
previousCompileContext,
) {
if (!($compileNodes instanceof jqLite)) {
// jquery always rewraps, whereas we need to preserve the original selector so that we can
// modify it.
$compileNodes = jqLite($compileNodes);
}
// We can not compile top level text elements since text nodes can be merged and we will
// not be able to attach scope data to them, so we will wrap them in <span>
forEach($compileNodes, function (node, index) {
if (
node.nodeType == 3 /* text node */ &&
node.nodeValue.match(/\S+/) /* non-empty */
) {
$compileNodes[index] = node = jqLite(node)
.wrap("<span></span>")
.parent()[0];
}
});
var compositeLinkFn = compileNodes(
$compileNodes,
transcludeFn,
$compileNodes,
maxPriority,
ignoreDirective,
previousCompileContext,
);
return function publicLinkFn(
scope,
cloneConnectFn,
transcludeControllers,
) {
assertArg(scope, "scope");
// important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
// and sometimes changes the structure of the DOM.
var $linkNode = cloneConnectFn
? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!
: $compileNodes;
forEach(transcludeControllers, function (instance, name) {
$linkNode.data("$" + name + "Controller", instance);
});
// Attach scope only to non-text nodes.
for (var i = 0, ii = $linkNode.length; i < ii; i++) {
var node = $linkNode[i];
if (
node.nodeType == 1 /* element */ ||
node.nodeType == 9 /* document */
) {
$linkNode.eq(i).data("$scope", scope);
}
}
safeAddClass($linkNode, "ng-scope");
if (cloneConnectFn) cloneConnectFn($linkNode, scope);
if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);
return $linkNode;
};
}
function safeAddClass($element, className) {
try {
$element.addClass(className);
} catch (e) {
// ignore, since it means that we are trying to set class on
// SVG element, where class name is read-only.
}
}
/**
* Compile function matches each node in nodeList against the directives. Once all directives
* for a particular node are collected their compile functions are executed. The compile
* functions return values - the linking functions - are combined into a composite linking
* function, which is the a linking function for the node.
*
* @param {NodeList} nodeList an array of nodes or NodeList to compile
* @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
* scope argument is auto-generated to the new child of the transcluded parent scope.
* @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then
* the rootElement must be set the jqLite collection of the compile root. This is
* needed so that the jqLite collection items can be replaced with widgets.
* @param {number=} max directive priority
* @returns {?function} A composite linking function of all of the matched directives or null.
*/
function compileNodes(
nodeList,
transcludeFn,
$rootElement,
maxPriority,
ignoreDirective,
previousCompileContext,
) {
var linkFns = [],
nodeLinkFn,
childLinkFn,
directives,
attrs,
linkFnFound;
for (var i = 0; i < nodeList.length; i++) {
attrs = new Attributes();
// we must always refer to nodeList[i] since the nodes can be replaced underneath us.
directives = collectDirectives(
nodeList[i],
[],
attrs,
i === 0 ? maxPriority : undefined,
ignoreDirective,
);
nodeLinkFn = directives.length
? applyDirectivesToNode(
directives,
nodeList[i],
attrs,
transcludeFn,
$rootElement,
null,
[],
[],
previousCompileContext,
)
: null;
childLinkFn =
(nodeLinkFn && 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;
//use the previous context only for the first element in the virtual group
previousCompileContext = null;
}
// return a linking function if we have found anything, null otherwise
return linkFnFound ? compositeLinkFn : null;
function compositeLinkFn(
scope,
nodeList,
$rootElement,
boundTranscludeFn,
) {
var nodeLinkFn,
childLinkFn,
node,
$node,
childScope,
childTranscludeFn,
i,
ii,
n;
// copy nodeList so that linking doesn't break due to live list updates.
var 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);
if (nodeLinkFn) {
if (nodeLinkFn.scope) {
childScope = scope.$new();
$node.data("$scope", childScope);
safeAddClass($node, "ng-scope");
} else {
childScope = scope;
}
childTranscludeFn = nodeLinkFn.transclude;
if (childTranscludeFn || (!boundTranscludeFn && transcludeFn)) {
nodeLinkFn(
childLinkFn,
childScope,
node,
$rootElement,
createBoundTranscludeFn(
scope,
childTranscludeFn || transcludeFn,
),
);
} else {
nodeLinkFn(
childLinkFn,
childScope,
node,
$rootElement,
boundTranscludeFn,
);
}
} else if (childLinkFn) {
childLinkFn(
scope,
node.childNodes,
undefined,
boundTranscludeFn,
);
}
}
}
}
function createBoundTranscludeFn(scope, transcludeFn) {
return function boundTranscludeFn(
transcludedScope,
cloneFn,
controllers,
) {
var scopeCreated = false;
if (!transcludedScope) {
transcludedScope = scope.$new();
transcludedScope.$$transcluded = true;
scopeCreated = true;
}
var clone = transcludeFn(transcludedScope, cloneFn, controllers);
if (scopeCreated) {
clone.on(
"$destroy",
bind(transcludedScope, transcludedScope.$destroy),
);
}
return clone;
};
}
/**
* Looks for directives on the given node and adds them to the directive collection which is
* sorted.
*
* @param node Node to search.
* @param directives An array to which the directives are added to. This array is sorted before
* the function returns.
* @param attrs The shared attrs object which is used to populate the normalized attributes.
* @param {number=} maxPriority Max directive priority.
*/
function collectDirectives(
node,
directives,
attrs,
maxPriority,
ignoreDirective,
) {
var nodeType = node.nodeType,
attrsMap = attrs.$attr,
match,
className;
switch (nodeType) {
case 1 /* Element */:
// use the node name: <directive>
addDirective(
directives,
directiveNormalize(nodeName_(node).toLowerCase()),
"E",
maxPriority,
ignoreDirective,
);
// iterate over the attributes
for (
var attr,
name,
nName,
ngAttrName,
value,
nAttrs = node.attributes,
j = 0,
jj = nAttrs && nAttrs.length;
j < jj;
j++
) {
var attrStartName = false;
var attrEndName = false;
attr = nAttrs[j];
if (!msie || msie >= 8 || attr.specified) {
name = attr.name;
// support ngAttr attribute binding
ngAttrName = directiveNormalize(name);
if (NG_ATTR_BINDING.test(ngAttrName)) {
name = snake_case(ngAttrName.substr(6), "-");
}
var directiveNName = ngAttrName.replace(/(Start|End)$/, "");
if (ngAttrName === directiveNName + "Start") {
attrStartName = name;
attrEndName = name.substr(0, name.length - 5) + "end";
name = name.substr(0, name.length - 6);
}
nName = directiveNormalize(name.toLowerCase());
attrsMap[nName] = name;
attrs[nName] = value = trim(
msie && name == "href"
? decodeURIComponent(node.getAttribute(name, 2))
: attr.value,
);
if (getBooleanAttrName(node, nName)) {
attrs[nName] = true; // presence means true
}
addAttrInterpolateDirective(node, directives, value, nName);
addDirective(
directives,
nName,
"A",
maxPriority,
ignoreDirective,
attrStartName,
attrEndName,
);
}
}
// use class as directive
className = node.className;
if (isString(className) && className !== "") {
while ((match = CLASS_DIRECTIVE_REGEXP.exec(className))) {
nName = directiveNormalize(match[2]);
if (
addDirective(
directives,
nName,
"C",
maxPriority,
ignoreDirective,
)
) {
attrs[nName] = trim(match[3]);
}
className = className.substr(match.index + match[0].length);
}
}
break;
case 3 /* Text Node */:
addTextInterpolateDirective(directives, node.nodeValue);
break;
case 8 /* Comment */:
try {
match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);
if (match) {
nName = directiveNormalize(match[1]);
if (
addDirective(
directives,
nName,
"M",
maxPriority,
ignoreDirective,
)
) {
attrs[nName] = trim(match[2]);
}
}
} catch (e) {
// turns out that under some circumstances IE9 throws errors when one attempts to read
// comment's node value.
// Just ignore it and continue. (Can't seem to reproduce in test case.)
}
break;
}
directives.sort(byPriority);
return directives;
}
/**
* Given a node with an directive-start it collects all of the siblings until it finds
* directive-end.
* @param node
* @param attrStart
* @param attrEnd
* @returns {*}
*/
function groupScan(node, attrStart, attrEnd) {
var nodes = [];
var depth = 0;
if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {
var startNode = node;
do {
if (!node) {
throw $compileMinErr(
"uterdir",
"Unterminated attribute, found '{0}' but no matching '{1}' found.",
attrStart,
attrEnd,
);
}
if (node.nodeType == 1 /** Element **/) {
if (node.hasAttribute(attrStart)) depth++;
if (node.hasAttribute(attrEnd)) depth--;
}
nodes.push(node);
node = node.nextSibling;
} while (depth > 0);
} else {
nodes.push(node);
}
return jqLite(nodes);
}
/**
* Wrapper for linking function which converts normal linking function into a grouped
* linking function.
* @param linkFn
* @param attrStart
* @param attrEnd
* @returns {Function}
*/
function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {
return function (scope, element, attrs, controllers, transcludeFn) {
element = groupScan(element[0], attrStart, attrEnd);
return linkFn(scope, element, attrs, controllers, transcludeFn);
};
}
/**
* Once the directives have been collected, their compile functions are executed. This method
* is responsible for inlining directive templates as well as terminating the application
* of the directives if the terminal directive has been reached.
*
* @param {Array} directives Array of collected directives to execute their compile function.
* this needs to be pre-sorted by priority order.
* @param {Node} compileNode The raw DOM node to apply the compile functions to
* @param {Object} templateAttrs The shared attribute function
* @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
* scope argument is auto-generated to the new
* child of the transcluded parent scope.
* @param {JQLite} jqCollection If we are working on the root of the compile tree then this
* argument has the root jqLite array so that we can replace nodes
* on it.
* @param {Object=} originalReplaceDirective An optional directive that will be ignored when
* compiling the transclusion.
* @param {Array.<Function>} preLinkFns
* @param {Array.<Function>} postLinkFns
* @param {Object} previousCompileContext Context used for previous compilation of the current
* node
* @returns linkFn
*/
function applyDirectivesToNode(
directives,
compileNode,
templateAttrs,
transcludeFn,
jqCollection,
originalReplaceDirective,
preLinkFns,
postLinkFns,
previousCompileContext,
) {
previousCompileContext = previousCompileContext || {};
var terminalPriority = -Number.MAX_VALUE,
newScopeDirective,
controllerDirectives = previousCompileContext.controllerDirectives,
newIsolateScopeDirective =
previousCompileContext.newIsolateScopeDirective,
templateDirective = previousCompileContext.templateDirective,
nonTlbTranscludeDirective =
previousCompileContext.nonTlbTranscludeDirective,
hasTranscludeDirective = false,
hasElementTranscludeDirective = false,
$compileNode = (templateAttrs.$$element = jqLite(compileNode)),
directive,
directiveName,
$template,
replaceDirective = originalReplaceDirective,
childTranscludeFn = transcludeFn,
linkFn,
directiveValue;
// executes all directives on the current element
for (var i = 0, ii = directives.length; i < ii; i++) {
directive = directives[i];
var attrStart = directive.$$start;
var attrEnd = directive.$$end;
// collect multiblock sections
if (attrStart) {
$compileNode = groupScan(compileNode, attrStart, attrEnd);
}
$template = undefined;
if (terminalPriority > directive.priority) {
break; // prevent further processing of directives
}
if ((directiveValue = directive.scope)) {
newScopeDirective = newScopeDirective || directive;
// skip the check for directives with async templates, we'll check the derived sync
// directive when the template arrives
if (!directive.templateUrl) {
assertNoDuplicate(
"new/isolated scope",
newIsolateScopeDirective,
directive,
$compileNode,
);
if (isObject(directiveValue)) {
newIsolateScopeDirective = directive;
}
}
}
directiveName = directive.name;
if (!directive.templateUrl && directive.controller) {
directiveValue = directive.controller;
controllerDirectives = controllerDirectives || {};
assertNoDuplicate(
"'" + directiveName + "' controller",
controllerDirectives[directiveName],
directive,
$compileNode,
);
controllerDirectives[directiveName] = directive;
}
if ((directiveValue = directive.transclude)) {
hasTranscludeDirective = true;
// Special case ngIf and ngRepeat so that we don't complain about duplicate transclusion.
// This option should only be used by directives that know how to how to safely handle element transclusion,
// where the transcluded nodes are added or replaced after linking.
if (!directive.$$tlb) {
assertNoDuplicate(
"transclusion",
nonTlbTranscludeDirective,
directive,
$compileNode,
);
nonTlbTranscludeDirective = directive;
}
if (directiveValue == "element") {
hasElementTranscludeDirective = true;
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,
{
// Don't pass in:
// - controllerDirectives - otherwise we'll create duplicates controllers
// - newIsolateScopeDirective or templateDirective - combining templates with
// element transclusion doesn't make sense.
//
// We need only nonTlbTranscludeDirective so that we prevent putting transclusion
// on the same element more than once.
nonTlbTranscludeDirective: nonTlbTranscludeDirective,
},
);
} else {
$template = jqLite(jqLiteClone(compileNode)).contents();
$compileNode.empty(); // clear contents
childTranscludeFn = compile($template, transcludeFn);
}
}
if (directive.template) {
assertNoDuplicate(
"template",
templateDirective,
directive,
$compileNode,
);
templateDirective = directive;
directiveValue = isFunction(directive.template)
? directive.template($compileNode, templateAttrs)
: directive.template;
directiveValue = denormalizeTemplate(directiveValue);
if (directive.replace) {
replaceDirective = directive;
$template = jqLite(
"<div>" + trim(directiveValue) + "</div>",
).contents();
compileNode = $template[0];
if ($template.length != 1 || compileNode.nodeType !== 1) {
throw $compileMinErr(
"tplrt",
"Template for directive '{0}' must have exactly one root element. {1}",
directiveName,
"",
);
}
replaceWith(jqCollection, $compileNode, compileNode);
var newTemplateAttrs = { $attr: {} };
// combine directives from the original node and from the template:
// - take the array of directives for this element
// - split it into two parts, those that already applied (processed) and those that weren't (unprocessed)
// - collect directives from the template and sort them by priority
// - combine directives as: processed + template + unprocessed
var templateDirectives = collectDirectives(
compileNode,
[],
newTemplateAttrs,
);
var unprocessedDirectives = directives.splice(
i + 1,
directives.length - (i + 1),
);
if (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;
if (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 {
linkFn = directive.compile(
$compileNode,
templateAttrs,
childTranscludeFn,
);
if (isFunction(linkFn)) {
addLinkFns(null, linkFn, attrStart, attrEnd);
} else if (linkFn) {
addLinkFns(linkFn.pre, linkFn.post, attrStart, attrEnd);
}
} catch (e) {
$exceptionHandler(e, startingTag($compileNode));
}
}
if (directive.terminal) {
nodeLinkFn.terminal = true;
terminalPriority = Math.max(terminalPriority, directive.priority);
}
}
nodeLinkFn.scope =
newScopeDirective && newScopeDirective.scope === true;
nodeLinkFn.transclude = hasTranscludeDirective && childTranscludeFn;
// might be normal or delayed nodeLinkFn depending on if templateUrl is present
return nodeLinkFn;
////////////////////
function addLinkFns(pre, post, attrStart, attrEnd) {
if (pre) {
if (attrStart)
pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
pre.require = directive.require;
if (
newIsolateScopeDirective === directive ||
directive.$$isolateScope
) {
pre = cloneAndAnnotateFn(pre, { isolateScope: true });
}
preLinkFns.push(pre);
}
if (post) {
if (attrStart)
post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
post.require = directive.require;
if (
newIsolateScopeDirective === directive ||
directive.$$isolateScope
) {
post = cloneAndAnnotateFn(post, { isolateScope: true });
}
postLinkFns.push(post);
}
}
function getControllers(require, $element, elementControllers) {
var value,
retrievalMethod = "data",
optional = false;
if (isString(require)) {
while ((value = require.charAt(0)) == "^" || value == "?") {
require = require.substr(1);
if (value == "^") {
retrievalMethod = "inheritedData";
}
optional = optional || value == "?";
}
value = null;
if (elementControllers && retrievalMethod === "data") {
value = elementControllers[require];
}
value =
value ||
$element[retrievalMethod]("$" + require + "Controller");
if (!value && !optional) {
throw $compileMinErr(
"ctreq",
"Controller '{0}', required by directive '{1}', can't be found!",
require,
directiveName,
);
}
return value;
} else if (isArray(require)) {
value = [];
forEach(require, function (require) {
value.push(
getControllers(require, $element, elementControllers),
);
});
}
return value;
}
function nodeLinkFn(
childLinkFn,
scope,
linkNode,
$rootElement,
boundTranscludeFn,
) {
var attrs,
$element,
i,
ii,
linkFn,
controller,
isolateScope,
elementControllers = {},
transcludeFn;
if (compileNode === linkNode) {
attrs = templateAttrs;
} else {
attrs = shallowCopy(
templateAttrs,
new Attributes(jqLite(linkNode), templateAttrs.$attr),
);
}
$element = attrs.$$element;
if (newIsolateScopeDirective) {
var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/;
var $linkNode = jqLite(linkNode);
isolateScope = scope.$new(true);
if (
templateDirective &&
templateDirective ===
newIsolateScopeDirective.$$originalDirective
) {
$linkNode.data("$isolateScope", isolateScope);
} else {
$linkNode.data("$isolateScopeNoTemplate", isolateScope);
}
safeAddClass($linkNode, "ng-isolate-scope");
forEach(
newIsolateScopeDirective.scope,
function (definition, scopeName) {
var match = definition.match(LOCAL_REGEXP) || [],
attrName = match[3] || scopeName,
optional = match[2] == "?",
mode = match[1], // @, =, or &
lastValue,
parentGet,
parentSet,
compare;
isolateScope.$$isolateBindings[scopeName] = mode + attrName;
switch (mode) {
case "@":
attrs.$observe(attrName, function (value) {
isolateScope[scopeName] = value;
});
attrs.$$observers[attrName].$$scope = scope;
if (attrs[attrName]) {
// If the attribute has been provided then we trigger an interpolation to ensure
// the value is there for use in the link fn
isolateScope[scopeName] = $interpolate(attrs[attrName])(
scope,
);
}
break;
case "=":
if (optional && !attrs[attrName]) {
return;
}
parentGet = $parse(attrs[attrName]);
if (parentGet.literal) {
compare = equals;
} else {
compare = function (a, b) {
return a === b;
};
}
parentSet =
parentGet.assign ||
function () {
// reset the change, or we will throw this exception on every $digest
lastValue = isolateScope[scopeName] =
parentGet(scope);
throw $compileMinErr(
"nonassign",
"Expression '{0}' used with directive '{1}' is non-assignable!",
attrs[attrName],
newIsolateScopeDirective.name,
);
};
lastValue = isolateScope[scopeName] = parentGet(scope);
isolateScope.$watch(
function parentValueWatch() {
var parentValue = parentGet(scope);
if (!compare(parentValue, isolateScope[scopeName])) {
// we are out of sync and need to copy
if (!compare(parentValue, lastValue)) {
// parent changed and it has precedence
isolateScope[scopeName] = parentValue;
} else {
// if the parent can be assigned then do so
parentSet(
scope,
(parentValue = isolateScope[scopeName]),
);
}
}
return (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,
);
}
},
);
}
transcludeFn = boundTranscludeFn && controllersBoundTransclude;
if (controllerDirectives) {
forEach(controllerDirectives, function (directive) {
var locals = {
$scope:
directive === newIsolateScopeDirective ||
directive.$$isolateScope
? isolateScope
: scope,
$element: $element,
$attrs: attrs,
$transclude: transcludeFn,
},
controllerInstance;
controller = directive.controller;
if (controller == "@") {
controller = attrs[directive.name];
}
controllerInstance = $controller(controller, locals);
// For directives with element transclusion the element is a comment,
// but jQuery .data doesn't support attaching data to comment nodes as it's hard to
// clean up (http://bugs.jquery.com/ticket/8335).
// Instead, we save the controllers for the element in a local hash and attach to .data
// later, once we have the actual element.
elementControllers[directive.name] = controllerInstance;
if (!hasElementTranscludeDirective) {
$element.data(
"$" + directive.name + "Controller",
controllerInstance,
);
}
if (directive.controllerAs) {
locals.$scope[directive.controllerAs] = controllerInstance;
}
});
}
// PRELINKING
for (i = 0, ii = preLinkFns.length; i < ii; i++) {
try {
linkFn = preLinkFns[i];
linkFn(
linkFn.isolateScope ? isolateScope : scope,
$element,
attrs,
linkFn.require &&
getControllers(
linkFn.require,
$element,
elementControllers,
),
transcludeFn,
);
} catch (e) {
$exceptionHandler(e, startingTag($element));
}
}
// RECURSION
// We only pass the isolate scope, if the isolate directive has a template,
// otherwise the child elements do not belong to the isolate directive.
var scopeToChild = scope;
if (
newIsolateScopeDirective &&
(newIsolateScopeDirective.template ||
newIsolateScopeDirective.templateUrl === null)
) {
scopeToChild = isolateScope;
}
childLinkFn &&
childLinkFn(
scopeToChild,
linkNode.childNodes,
undefined,
boundTranscludeFn,
);
// POSTLINKING
for (i = postLinkFns.length - 1; i >= 0; i--) {
try {
linkFn = postLinkFns[i];
linkFn(
linkFn.isolateScope ? isolateScope : scope,
$element,
attrs,
linkFn.require &&
getControllers(
linkFn.require,
$element,
elementControllers,
),
transcludeFn,
);
} catch (e) {
$exceptionHandler(e, startingTag($element));
}
}
// This is the function that is injected as `$transclude`.
function controllersBoundTransclude(scope, cloneAttachFn) {
var transcludeControllers;
// no scope passed
if (arguments.length < 2) {
cloneAttachFn = scope;
scope = undefined;
}
if (hasElementTranscludeDirective) {
transcludeControllers = elementControllers;
}
return boundTranscludeFn(
scope,
cloneAttachFn,
transcludeControllers,
);
}
}
}
function markDirectivesAsIsolate(directives) {
// mark all directives as needing isolate scope.
for (var j = 0, jj = directives.length; j < jj; j++) {
directives[j] = inherit(directives[j], { $$isolateScope: true });
}
}
/**
* looks up the directive and decorates it with exception handling and proper parameters. We
* call this the boundDirective.
*
* @param {string} name name of the directive to look up.
* @param {string} location The directive must be found in specific format.
* String containing any of theses characters:
*
* * `E`: element name
* * `A': attribute
* * `C`: class
* * `M`: comment
* @returns true if directive was added.
*/
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 + Suffix),
i = 0,
ii = directives.length;
i < ii;
i++
) {
try {
directive = directives[i];
if (
(maxPriority === undefined ||
maxPriority > directive.priority) &&
directive.restrict.indexOf(location) != -1
) {
if (startAttrName) {
directive = inherit(directive, {
$$start: startAttrName,
$$end: endAttrName,
});
}
tDirectives.push(directive);
match = directive;
}
} catch (e) {
$exceptionHandler(e);
}
}
}
return match;
}
/**
* When the element is replaced with HTML template then the new attributes
* on the template need to be merged with the existing attributes in the DOM.
* The desired effect is to have both of the attributes present.
*
* @param {object} dst destination attributes (original DOM)
* @param {object} src source attributes (from the directive template)
*/
function mergeTemplateAttributes(dst, src) {
var srcAttr = src.$attr,
dstAttr = dst.$attr,
$element = dst.$$element;
// reapply the old attributes to the new element
forEach(dst, function (value, key) {
if (key.charAt(0) != "$") {
if (src[key]) {
value += (key === "style" ? ";" : " ") + src[key];
}
dst.$set(key, value, true, srcAttr[key]);
}
});
// copy the new attributes on the old attrs object
forEach(src, function (value, key) {
if (key == "class") {
safeAddClass($element, value);
dst["class"] = (dst["class"] ? dst["class"] + " " : "") + value;
} else if (key == "style") {
$element.attr("style", $element.attr("style") + ";" + value);
dst["style"] = (dst["style"] ? dst["style"] + ";" : "") + value;
// `dst` will never contain hasOwnProperty as DOM parser won't let it.
// You will get an "InvalidCharacterError: DOM Exception 5" error if you
// have an attribute like "has-own-property" or "data-has-own-property", etc.
} else if (key.charAt(0) != "$" && !dst.hasOwnProperty(key)) {
dst[key] = value;
dstAttr[key] = srcAttr[key];
}
});
}
function compileTemplateUrl(
directives,
$compileNode,
tAttrs,
$rootElement,
childTranscludeFn,
preLinkFns,
postLinkFns,
previousCompileContext,
) {
var linkQueue = [],
afterTemplateNodeLinkFn,
afterTemplateChildLinkFn,
beforeTemplateCompileNode = $compileNode[0],
origAsyncDirective = directives.shift(),
// The fact that we have to copy and patch the directive seems wrong!
derivedSyncDirective = extend({}, origAsyncDirective, {
templateUrl: null,
transclude: null,
replace: null,
$$originalDirective: origAsyncDirective,
}),
templateUrl = isFunction(origAsyncDirective.templateUrl)
? origAsyncDirective.templateUrl($compileNode, tAttrs)
: origAsyncDirective.templateUrl;
$compileNode.empty();
$http
.get($sce.getTrustedResourceUrl(templateUrl), {
cache: $templateCache,
})
.success(function (content) {
var compileNode,
tempTemplateAttrs,
$template,
childBoundTranscludeFn;
content = denormalizeTemplate(content);
if (origAsyncDirective.replace) {
$template = jqLite(
"<div>" + trim(content) + "</div>",
).contents();
compileNode = $template[0];
if ($template.length != 1 || compileNode.nodeType !== 1) {
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,
);
if (isObject(origAsyncDirective.scope)) {
markDirectivesAsIsolate(templateDirectives);
}
directives = templateDirectives.concat(directives);
mergeTemplateAttributes(tAttrs, tempTemplateAttrs);
} else {
compileNode = beforeTemplateCompileNode;
$compileNode.html(content);
}
directives.unshift(derivedSyncDirective);
afterTemplateNodeLinkFn = applyDirectivesToNode(
directives,
compileNode,
tAttrs,
childTranscludeFn,
$compileNode,
origAsyncDirective,
preLinkFns,
postLinkFns,
previousCompileContext,
);
forEach($rootElement, function (node, i) {
if (node == compileNode) {
$rootElement[i] = $compileNode[0];
}
});
afterTemplateChildLinkFn = compileNodes(
$compileNode[0].childNodes,
childTranscludeFn,
);
while (linkQueue.length) {
var scope = linkQueue.shift(),
beforeTemplateLinkNode = linkQueue.shift(),
linkRootElement = linkQueue.shift(),
boundTranscludeFn = linkQueue.shift(),
linkNode = $compileNode[0];
if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
// it was cloned therefore we have to clone as well.
linkNode = jqLiteClone(compileNode);
replaceWith(
linkRootElement,
jqLite(beforeTemplateLinkNode),
linkNode,
);
}
if (afterTemplateNodeLinkFn.transclude) {
childBoundTranscludeFn = createBoundTranscludeFn(
scope,
afterTemplateNodeLinkFn.transclude,
);
} else {
childBoundTranscludeFn = 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,
);
});
return function delayedNodeLinkFn(
ignoreChildLinkFn,
scope,
node,
rootElement,
boundTranscludeFn,
) {
if (linkQueue) {
linkQueue.push(scope);
linkQueue.push(node);
linkQueue.push(rootElement);
linkQueue.push(boundTranscludeFn);
} else {
afterTemplateNodeLinkFn(
afterTemplateChildLinkFn,
scope,
node,
rootElement,
boundTranscludeFn,
);
}
};
}
/**
* Sorting function for bound directives.
*/
function byPriority(a, b) {
var diff = b.priority - a.priority;
if (diff !== 0) return diff;
if (a.name !== b.name) return a.name < b.name ? -1 : 1;
return 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 addTextInterpolateDirective(directives, text) {
var interpolateFn = $interpolate(text, true);
if (interpolateFn) {
directives.push({
priority: 0,
compile: valueFn(function textInterpolateLinkFn(scope, node) {
var parent = node.parent(),
bindings = parent.data("$binding") || [];
bindings.push(interpolateFn);
safeAddClass(parent.data("$binding", bindings), "ng-binding");
scope.$watch(
interpolateFn,
function interpolateFnWatchAction(value) {
node[0].nodeValue = value;
},
);
}),
});
}
}
function getTrustedContext(node, attrNormalizedName) {
if (attrNormalizedName == "srcdoc") {
return $sce.HTML;
}
var tag = nodeName_(node);
// maction[xlink:href] can source SVG. It's not limited to <maction>.
if (
attrNormalizedName == "xlinkHref" ||
(tag == "FORM" && attrNormalizedName == "action") ||
(tag != "IMG" &&
(attrNormalizedName == "src" || attrNormalizedName == "ngSrc"))
) {
return $sce.RESOURCE_URL;
}
}
function addAttrInterpolateDirective(node, directives, value, name) {
var interpolateFn = $interpolate(value, true);
// no interpolation found -> ignore
if (!interpolateFn) return;
if (name === "multiple" && nodeName_(node) === "SELECT") {
throw $compileMinErr(
"selmulti",
"Binding to the 'multiple' attribute is not supported. Element: {0}",
startingTag(node),
);
}
directives.push({
priority: 100,
compile: function () {
return {
pre: function attrInterpolatePreLinkFn(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.",
);
}
// we need to interpolate again, in case the attribute value has been updated
// (e.g. by another directive's compile function)
interpolateFn = $interpolate(
attr[name],
true,
getTrustedContext(node, name),
);
// if attribute was updated so that there is no interpolation going on we don't want to
// register any observers
if (!interpolateFn) return;
// TODO(i): this should likely be attr.$set(name, iterpolateFn(scope) so that we reset the
// actual attr value
attr[name] = interpolateFn(scope);
(
$$observers[name] || ($$observers[name] = [])
).$$inter = true;
(
(attr.$$observers && attr.$$observers[name].$$scope) ||
scope
).$watch(
interpolateFn,
function interpolateFnWatchAction(newValue, oldValue) {
//special case for class attribute addition + removal
//so that class changes can tap into the animation
//hooks provided by the $animate service. Be sure to
//skip animations when the first digest occurs (when
//both the new and the old values are the same) since
//the CSS classes are the non-interpolated values
if (name === "class" && newValue != oldValue) {
attr.$updateClass(newValue, oldValue);
} else {
attr.$set(name, newValue);
}
},
);
},
};
},
});
}
/**
* This is a special jqLite.replaceWith, which can replace items which
* have no parents, provided that the containing jqLite collection is provided.
*
* @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes
* in the root of the tree.
* @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep
* the shell, but replace its DOM node reference.
* @param {Node} newNode The new DOM node.
*/
function replaceWith($rootElement, elementsToRemove, newNode) {
var firstElementToRemove = elementsToRemove[0],
removeCount = elementsToRemove.length,
parent = firstElementToRemove.parentNode,
i,
ii;
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++
) {
if (j2 < jj) {
$rootElement[j] = $rootElement[j2];
} else {
delete $rootElement[j];
}
}
$rootElement.length -= removeCount - 1;
break;
}
}
}
if (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(); // must do this way to clean up expando
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,
);
}
},
];
}
var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;
/**
* Converts all accepted directives format into proper directive name.
* All of these will become 'myDirective':
* my:Directive
* my-directive
* x-my-directive
* data-my:directive
*
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/
function directiveNormalize(name) {
return camelCase(name.replace(PREFIX_REGEXP, ""));
}
/**
* @ngdoc object
* @name ng.$compile.directive.Attributes
*
* @description
* A shared object between directive compile / linking functions which contains normalized DOM
* element attributes. The values reflect current binding state `{{ }}`. The normalization is
* needed since all of these are treated as equivalent in Angular:
*
* <span ng:bind="a" ng-bind="a" data-ng-bind="a" x-ng-bind="a">
*/
/**
* @ngdoc property
* @name ng.$compile.directive.Attributes#$attr
* @propertyOf ng.$compile.directive.Attributes
* @returns {object} A map of DOM element attribute names to the normalized name. This is
* needed to do reverse lookup from normalized name back to actual name.
*/
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$set
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Set DOM element attribute value.
*
*
* @param {string} name Normalized element attribute name of the property to modify. The name is
* revers translated using the {@link ng.$compile.directive.Attributes#$attr $attr}
* property to the original name.
* @param {string} value Value to set the attribute to. The value can be an interpolated string.
*/
/**
* Closure compiler type information
*/
function nodesetLinkingFn(
/* angular.Scope */ scope,
/* NodeList */ nodeList,
/* Element */ rootElement,
/* function(Function) */ boundTranscludeFn,
) {}
function directiveLinkingFn(
/* nodesetLinkingFn */ nodesetLinkingFn,
/* angular.Scope */ scope,
/* Node */ node,
/* Element */ rootElement,
/* function(Function) */ boundTranscludeFn,
) {}
function tokenDifference(str1, str2) {
var values = "",
tokens1 = str1.split(/\s+/),
tokens2 = str2.split(/\s+/);
outer: for (var i = 0; i < tokens1.length; i++) {
var token = tokens1[i];
for (var j = 0; j < tokens2.length; j++) {
if (token == tokens2[j]) continue outer;
}
values += (values.length > 0 ? " " : "") + token;
}
return values;
}
/**
* @ngdoc object
* @name ng.$controllerProvider
* @description
* The {@link ng.$controller $controller service} is used by Angular to create new
* controllers.
*
* This provider allows controller registration via the
* {@link ng.$controllerProvider#methods_register register} method.
*/
function $ControllerProvider() {
var controllers = {},
CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
/**
* @ngdoc function
* @name ng.$controllerProvider#register
* @methodOf ng.$controllerProvider
* @param {string|Object} name Controller name, or an object map of controllers where the keys are
* the names and the values are the constructors.
* @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
* annotations in the array notation).
*/
this.register = function (name, constructor) {
assertNotHasOwnProperty(name, "controller");
if (isObject(name)) {
extend(controllers, name);
} else {
controllers[name] = constructor;
}
};
this.$get = [
"$injector",
"$window",
function ($injector, $window) {
/**
* @ngdoc function
* @name ng.$controller
* @requires $injector
*
* @param {Function|string} constructor If called with a function then it's considered to be the
* controller constructor function. Otherwise it's considered to be a string which is used
* to retrieve the controller constructor using the following steps:
*
* * check if a controller with given name is registered via `$controllerProvider`
* * check if evaluating the string on the current scope returns a constructor
* * check `window[constructor]` on the global `window` object
*
* @param {Object} locals Injection locals for Controller.
* @return {Object} Instance of given controller.
*
* @description
* `$controller` service is responsible for instantiating controllers.
*
* It's just a simple call to {@link AUTO.$injector $injector}, but extracted into
* a service, so that one can override this service with {@link https://gist.github.com/1649788
* BC version}.
*/
return function (expression, locals) {
var instance, match, constructor, identifier;
if (isString(expression)) {
(match = expression.match(CNTRL_REG)),
(constructor = match[1]),
(identifier = match[3]);
expression = controllers.hasOwnProperty(constructor)
? controllers[constructor]
: getter(locals.$scope, constructor, true) ||
getter($window, constructor, true);
assertArgFn(expression, constructor, true);
}
instance = $injector.instantiate(expression, locals);
if (identifier) {
if (!(locals && typeof locals.$scope == "object")) {
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;
};
},
];
}
/**
* @ngdoc object
* @name ng.$document
* @requires $window
*
* @description
* A {@link angular.element jQuery (lite)}-wrapped reference to the browser's `window.document`
* element.
*/
function $DocumentProvider() {
this.$get = [
"$window",
function (window) {
return jqLite(window.document);
},
];
}
/**
* @ngdoc function
* @name ng.$exceptionHandler
* @requires $log
*
* @description
* Any uncaught exception in angular expressions is delegated to this service.
* The default implementation simply delegates to `$log.error` which logs it into
* the browser console.
*
* In unit tests, if `angular-mocks.js` is loaded, this service is overridden by
* {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
*
* ## Example:
*
* <pre>
* angular.module('exceptionOverride', []).factory('$exceptionHandler', function () {
* return function (exception, cause) {
* exception.message += ' (caused by "' + cause + '")';
* throw exception;
* };
* });
* </pre>
*
* This example will override the normal action of `$exceptionHandler`, to make angular
* exceptions fail hard when they happen, instead of just logging to the console.
*
* @param {Error} exception Exception associated with the error.
* @param {string=} cause optional information about the context in which
* the error was thrown.
*
*/
function $ExceptionHandlerProvider() {
this.$get = [
"$log",
function ($log) {
return function (exception, cause) {
$log.error.apply($log, arguments);
};
},
];
}
/**
* Parse headers into key value object
*
* @param {string} headers Raw headers as a string
* @returns {Object} Parsed headers as key value object
*/
function parseHeaders(headers) {
var parsed = {},
key,
val,
i;
if (!headers) return parsed;
forEach(headers.split("\n"), function (line) {
i = line.indexOf(":");
key = lowercase(trim(line.substr(0, i)));
val = trim(line.substr(i + 1));
if (key) {
if (parsed[key]) {
parsed[key] += ", " + val;
} else {
parsed[key] = val;
}
}
});
return parsed;
}
/**
* Returns a function that provides access to parsed headers.
*
* Headers are lazy parsed when first requested.
* @see parseHeaders
*
* @param {(string|Object)} headers Headers to provide access to.
* @returns {function(string=)} Returns a getter function which if called with:
*
* - if called with single an argument returns a single header value or null
* - if called with no arguments returns an object containing all headers.
*/
function headersGetter(headers) {
var headersObj = isObject(headers) ? headers : undefined;
return function (name) {
if (!headersObj) headersObj = parseHeaders(headers);
if (name) {
return headersObj[lowercase(name)] || null;
}
return headersObj;
};
}
/**
* Chain all given functions
*
* This function is used for both request and response transforming
*
* @param {*} data Data to transform.
* @param {function(string=)} headers Http headers getter fn.
* @param {(function|Array.<function>)} fns Function or an array of functions.
* @returns {*} Transformed data.
*/
function transformData(data, headers, fns) {
if (isFunction(fns)) return fns(data, headers);
forEach(fns, function (fn) {
data = fn(data, headers);
});
return 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",
};
var defaults = (this.defaults = {
// transform incoming response data
transformResponse: [
function (data) {
if (isString(data)) {
// strip json vulnerability protection prefix
data = data.replace(PROTECTION_PREFIX, "");
if (JSON_START.test(data) && JSON_END.test(data))
data = fromJson(data);
}
return data;
},
],
// transform outgoing request data
transformRequest: [
function (d) {
return isObject(d) && !isFile(d) ? toJson(d) : d;
},
],
// default headers
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",
});
/**
* Are ordered by request, i.e. they are applied in the same order as the
* array, on request, but reverse order, on response.
*/
var interceptorFactories = (this.interceptors = []);
/**
* For historical reasons, response interceptors are ordered by the order in which
* they are applied to the response. (This is the opposite of interceptorFactories)
*/
var responseInterceptorFactories = (this.responseInterceptors = []);
this.$get = [
"$httpBackend",
"$browser",
"$cacheFactory",
"$rootScope",
"$q",
"$injector",
function (
$httpBackend,
$browser,
$cacheFactory,
$rootScope,
$q,
$injector,
) {
var defaultCache = $cacheFactory("$http");
/**
* Interceptors stored in reverse order. Inner interceptors before outer interceptors.
* The reversal is needed so that we can build up the interception chain around the
* server request.
*/
var reversedInterceptors = [];
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);
/**
* Response interceptors go before "around" interceptors (no real reason, just
* had to pick one.) But they are already reversed, so we can't use unshift, hence
* the splice.
*/
reversedInterceptors.splice(index, 0, {
response: function (response) {
return responseFn($q.when(response));
},
responseError: function (response) {
return responseFn($q.reject(response));
},
});
},
);
/**
* @ngdoc function
* @name ng.$http
* @requires $httpBackend
* @requires $browser
* @requires $cacheFactory
* @requires $rootScope
* @requires $q
* @requires $injector
*
* @description
* The `$http` service is a core Angular service that facilitates communication with the remote
* HTTP servers via the browser's {@link https://developer.mozilla.org/en/xmlhttprequest
* XMLHttpRequest} object or via {@link http://en.wikipedia.org/wiki/JSONP JSONP}.
*
* For unit testing applications that use `$http` service, see
* {@link ngMock.$httpBackend $httpBackend mock}.
*
* For a higher level of abstraction, please check out the {@link ngResource.$resource
* $resource} service.
*
* The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
* the $q service. While for simple usage patterns this doesn't matter much, for advanced usage
* it is important to familiarize yourself with these APIs and the guarantees they provide.
*
*
* # General usage
* The `$http` service is a function which takes a single argument — a configuration object —
* that is used to generate an HTTP request and returns a {@link ng.$q promise}
* with two $http specific methods: `success` and `error`.
*
* <pre>
* $http({method: 'GET', url: '/someUrl'}).
* success(function(data, status, headers, config) {
* // this callback will be called asynchronously
* // when the response is available
* }).
* error(function(data, status, headers, config) {
* // called asynchronously if an error occurs
* // or server returns response with an error status.
* });
* </pre>
*
* Since the returned value of calling the $http function is a `promise`, you can also use
* the `then` method to register callbacks, and these callbacks will receive a single argument –
* an object representing the response. See the API signature and type info below for more
* details.
*
* A response status code between 200 and 299 is considered a success status and
* will result in the success callback being called. Note that if the response is a redirect,
* XMLHttpRequest will transparently follow it, meaning that the error callback will not be
* called for such responses.
*
* # Calling $http from outside AngularJS
* The `$http` service will not actually send the request until the next `$digest()` is
* executed. Normally this is not an issue, since almost all the time your call to `$http` will
* be from within a `$apply()` block.
* If you are calling `$http` from outside Angular, then you should wrap it in a call to
* `$apply` to cause a $digest to occur and also to handle errors in the block correctly.
*
* ```
* $scope.$apply(function() {
* $http(...);
* });
* ```
*
* # Writing Unit Tests that use $http
* When unit testing you are mostly responsible for scheduling the `$digest` cycle. If you do
* not trigger a `$digest` before calling `$httpBackend.flush()` then the request will not have
* been made and `$httpBackend.expect(...)` expectations will fail. The solution is to run the
* code that calls the `$http()` method inside a $apply block as explained in the previous
* section.
*
* ```
* $httpBackend.expectGET(...);
* $scope.$apply(function() {
* $http.get(...);
* });
* $httpBackend.flush();
* ```
*
* # Shortcut methods
*
* Since all invocations of the $http service require passing in an HTTP method and URL, and
* POST/PUT requests require request data to be provided as well, shortcut methods
* were created:
*
* <pre>
* $http.get('/someUrl').success(successCallback);
* $http.post('/someUrl', data).success(successCallback);
* </pre>
*
* Complete list of shortcut methods:
*
* - {@link ng.$http#methods_get $http.get}
* - {@link ng.$http#methods_head $http.head}
* - {@link ng.$http#methods_post $http.post}
* - {@link ng.$http#methods_put $http.put}
* - {@link ng.$http#methods_delete $http.delete}
* - {@link ng.$http#methods_jsonp $http.jsonp}
*
*
* # Setting HTTP Headers
*
* The $http service will automatically add certain HTTP headers to all requests. These defaults
* can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
* object, which currently contains this default configuration:
*
* - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
* - `Accept: application/json, text/plain, * / *`
* - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)
* - `Content-Type: application/json`
* - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)
* - `Content-Type: application/json`
*
* To add or overwrite these defaults, simply add or remove a property from these configuration
* objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
* with the lowercased HTTP method name as the key, e.g.
* `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }.
*
* The defaults can also be set at runtime via the `$http.defaults` object in the same
* fashion. In addition, you can supply a `headers` property in the config object passed when
* calling `$http(config)`, which overrides the defaults without changing them globally.
*
*
* # Transforming Requests and Responses
*
* Both requests and responses can be transformed using transform functions. By default, Angular
* applies these transformations:
*
* Request transformations:
*
* - If the `data` property of the request configuration object contains an object, serialize it
* into JSON format.
*
* Response transformations:
*
* - If XSRF prefix is detected, strip it (see Security Considerations section below).
* - If JSON response is detected, deserialize it using a JSON parser.
*
* To globally augment or override the default transforms, modify the
* `$httpProvider.defaults.transformRequest` and `$httpProvider.defaults.transformResponse`
* properties. These properties are by default an array of transform functions, which allows you
* to `push` or `unshift` a new transformation function into the transformation chain. You can
* also decide to completely override any default transformations by assigning your
* transformation functions to these properties directly without the array wrapper.
*
* Similarly, to locally override the request/response transforms, augment the
* `transformRequest` and/or `transformResponse` properties of the configuration object passed
* into `$http`.
*
*
* # Caching
*
* To enable caching, set the request configuration `cache` property to `true` (to use default
* cache) or to a custom cache object (built with {@link ng.$cacheFactory `$cacheFactory`}).
* When the cache is enabled, `$http` stores the response from the server in the specified
* cache. The next time the same request is made, the response is served from the cache without
* sending a request to the server.
*
* Note that even if the response is served from cache, delivery of the data is asynchronous in
* the same way that real requests are.
*
* If there are multiple GET requests for the same URL that should be cached using the same
* cache, but the cache is not populated yet, only one request to the server will be made and
* the remaining requests will be fulfilled using the response from the first request.
*
* You can change the default cache to a new object (built with
* {@link ng.$cacheFactory `$cacheFactory`}) by updating the
* {@link ng.$http#properties_defaults `$http.defaults.cache`} property. All requests who set
* their `cache` property to `true` will now use this cache object.
*
* If you set the default cache to `false` then only requests that specify their own custom
* cache object will be cached.
*
* # Interceptors
*
* Before you start creating interceptors, be sure to understand the
* {@link ng.$q $q and deferred/promise APIs}.
*
* For purposes of global error handling, authentication, or any kind of synchronous or
* asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
* able to intercept requests before they are handed to the server and
* responses before they are handed over to the application code that
* initiated these requests. The interceptors leverage the {@link ng.$q
* promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.
*
* The interceptors are service factories that are registered with the `$httpProvider` by
* adding them to the `$httpProvider.interceptors` array. The factory is called and
* injected with dependencies (if specified) and returns the interceptor.
*
* There are two kinds of interceptors (and two kinds of rejection interceptors):
*
* * `request`: interceptors get called with http `config` object. The function is free to
* modify the `config` or create a new one. The function needs to return the `config`
* directly or as a promise.
* * `requestError`: interceptor gets called when a previous interceptor threw an error or
* resolved with a rejection.
* * `response`: interceptors get called with http `response` object. The function is free to
* modify the `response` or create a new one. The function needs to return the `response`
* directly or as a promise.
* * `responseError`: interceptor gets called when a previous interceptor threw an error or
* resolved with a rejection.
*
*
* <pre>
* // register the interceptor as a service
* $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
* return {
* // optional method
* 'request': function(config) {
* // do something on success
* return config || $q.when(config);
* },
*
* // optional method
* 'requestError': function(rejection) {
* // do something on error
* if (canRecover(rejection)) {
* return responseOrNewPromise
* }
* return $q.reject(rejection);
* },
*
*
*
* // optional method
* 'response': function(response) {
* // do something on success
* return response || $q.when(response);
* },
*
* // optional method
* 'responseError': function(rejection) {
* // do something on error
* if (canRecover(rejection)) {
* return responseOrNewPromise
* }
* return $q.reject(rejection);
* };
* }
* });
*
* $httpProvider.interceptors.push('myHttpInterceptor');
*
*
* // register the interceptor via an anonymous factory
* $httpProvider.interceptors.push(function($q, dependency1, dependency2) {
* return {
* 'request': function(config) {
* // same as above
* },
* 'response': function(response) {
* // same as above
* }
* };
* });
* </pre>
*
* # Response interceptors (DEPRECATED)
*
* Before you start creating interceptors, be sure to understand the
* {@link ng.$q $q and deferred/promise APIs}.
*
* For purposes of global error handling, authentication or any kind of synchronous or
* asynchronous preprocessing of received responses, it is desirable to be able to intercept
* responses for http requests before they are handed over to the application code that
* initiated these requests. The response interceptors leverage the {@link ng.$q
* promise apis} to fulfil this need for both synchronous and asynchronous preprocessing.
*
* The interceptors are service factories that are registered with the $httpProvider by
* adding them to the `$httpProvider.responseInterceptors` array. The factory is called and
* injected with dependencies (if specified) and returns the interceptor — a function that
* takes a {@link ng.$q promise} and returns the original or a new promise.
*
* <pre>
* // register the interceptor as a service
* $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
* return function(promise) {
* return promise.then(function(response) {
* // do something on success
* return response;
* }, function(response) {
* // do something on error
* if (canRecover(response)) {
* return responseOrNewPromise
* }
* return $q.reject(response);
* });
* }
* });
*
* $httpProvider.responseInterceptors.push('myHttpInterceptor');
*
*
* // register the interceptor via an anonymous factory
* $httpProvider.responseInterceptors.push(function($q, dependency1, dependency2) {
* return function(promise) {
* // same as above
* }
* });
* </pre>
*
*
* # Security Considerations
*
* When designing web applications, consider security threats from:
*
* - {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
* JSON vulnerability}
* - {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF}
*
* Both server and the client must cooperate in order to eliminate these threats. Angular comes
* pre-configured with strategies that address these issues, but for this to work backend server
* cooperation is required.
*
* ## JSON Vulnerability Protection
*
* A {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
* JSON vulnerability} allows third party website to turn your JSON resource URL into
* {@link http://en.wikipedia.org/wiki/JSONP JSONP} request under some conditions. To
* counter this your server can prefix all JSON requests with following string `")]}',\n"`.
* Angular will automatically strip the prefix before processing it as JSON.
*
* For example if your server needs to return:
* <pre>
* ['one','two']
* </pre>
*
* which is vulnerable to attack, your server can return:
* <pre>
* )]}',
* ['one','two']
* </pre>
*
* Angular will strip the prefix, before processing the JSON.
*
*
* ## Cross Site Request Forgery (XSRF) Protection
*
* {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF} is a technique by which
* an unauthorized site can gain your user's private data. Angular provides a mechanism
* to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
* (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only
* JavaScript that runs on your domain could read the cookie, your server can be assured that
* the XHR came from JavaScript running on your domain. The header will not be set for
* cross-domain requests.
*
* To take advantage of this, your server needs to set a token in a JavaScript readable session
* cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
* server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure
* that only JavaScript running on your domain could have sent the request. The token must be
* unique for each user and must be verifiable by the server (to prevent the JavaScript from
* making up its own tokens). We recommend that the token is a digest of your site's
* authentication cookie with a {@link https://en.wikipedia.org/wiki/Salt_(cryptography) salt}
* for added security.
*
* The name of the headers can be specified using the xsrfHeaderName and xsrfCookieName
* properties of either $httpProvider.defaults, or the per-request config object.
*
*
* @param {object} config Object describing the request to be made and how it should be
* processed. The object has following properties:
*
* - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
* - **url** – `{string}` – Absolute or relative URL of the resource that is being requested.
* - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be turned
* to `?key1=value1&key2=value2` after the url. If the value is not a string, it will be
* JSONified.
* - **data** – `{string|Object}` – Data to be sent as the request message data.
* - **headers** – `{Object}` – Map of strings or functions which return strings representing
* HTTP headers to send to the server. If the return value of a function is null, the
* header will not be sent.
* - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.
* - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
* - **transformRequest** –
* `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
* transform function or an array of such functions. The transform function takes the http
* request body and headers and returns its transformed (typically serialized) version.
* - **transformResponse** –
* `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
* transform function or an array of such functions. The transform function takes the http
* response body and headers and returns its transformed (typically deserialized) version.
* - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
* GET request, otherwise if a cache instance built with
* {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
* caching.
* - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
* that should abort the request when resolved.
* - **withCredentials** - `{boolean}` - whether to to set the `withCredentials` flag on the
* XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
* requests with credentials} for more information.
* - **responseType** - `{string}` - see {@link
* https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType requestType}.
*
* @returns {HttpPromise} Returns a {@link ng.$q promise} object with the
* standard `then` method and two http specific methods: `success` and `error`. The `then`
* method takes two arguments a success and an error callback which will be called with a
* response object. The `success` and `error` methods take a single argument - a function that
* will be called when the request succeeds or fails respectively. The arguments passed into
* these functions are destructured representation of the response object passed into the
* `then` method. The response object has these properties:
*
* - **data** – `{string|Object}` – The response body transformed with the transform
* functions.
* - **status** – `{number}` – HTTP status code of the response.
* - **headers** – `{function([headerName])}` – Header getter function.
* - **config** – `{Object}` – The configuration object that was used to generate the request.
*
* @property {Array.<Object>} pendingRequests Array of config objects for currently pending
* requests. This is primarily meant to be used for debugging purposes.
*
*
* @example
<example>
<file name="index.html">
<div ng-controller="FetchCtrl">
<select ng-model="method">
<option>GET</option>
<option>JSONP</option>
</select>
<input type="text" ng-model="url" size="80"/>
<button ng-click="fetch()">fetch</button><br>
<button ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button>
<button
ng-click="updateModel('JSONP',
'http://angularjs.org/greet.php?callback=JSON_CALLBACK&name=Super%20Hero')">
Sample JSONP
</button>
<button
ng-click="updateModel('JSONP', 'http://angularjs.org/doesntexist&callback=JSON_CALLBACK')">
Invalid JSONP
</button>
<pre>http status code: {{status}}</pre>
<pre>http response data: {{data}}</pre>
</div>
</file>
<file name="script.js">
function FetchCtrl($scope, $http, $templateCache) {
$scope.method = 'GET';
$scope.url = 'http-hello.html';
$scope.fetch = function() {
$scope.code = null;
$scope.response = null;
$http({method: $scope.method, url: $scope.url, cache: $templateCache}).
success(function(data, status) {
$scope.status = status;
$scope.data = data;
}).
error(function(data, status) {
$scope.data = data || "Request failed";
$scope.status = status;
});
};
$scope.updateModel = function(method, url) {
$scope.method = method;
$scope.url = url;
};
}
</file>
<file name="http-hello.html">
Hello, $http!
</file>
<file name="scenario.js">
it('should make an xhr GET request', function() {
element(':button:contains("Sample GET")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('200');
expect(binding('data')).toMatch(/Hello, \$http!/);
});
it('should make a JSONP request to angularjs.org', function() {
element(':button:contains("Sample JSONP")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('200');
expect(binding('data')).toMatch(/Super Hero!/);
});
it('should make JSONP request to invalid URL and invoke the error handler',
function() {
element(':button:contains("Invalid JSONP")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('0');
expect(binding('data')).toBe('Request failed');
});
</file>
</example>
*/
function $http(requestConfig) {
var config = {
transformRequest: defaults.transformRequest,
transformResponse: defaults.transformResponse,
};
var headers = mergeHeaders(requestConfig);
extend(config, requestConfig);
config.headers = headers;
config.method = uppercase(config.method);
var xsrfValue = urlIsSameOrigin(config.url)
? $browser.cookies()[
config.xsrfCookieName || defaults.xsrfCookieName
]
: undefined;
if (xsrfValue) {
headers[config.xsrfHeaderName || defaults.xsrfHeaderName] =
xsrfValue;
}
var serverRequest = function (config) {
headers = config.headers;
var reqData = transformData(
config.data,
headersGetter(headers),
config.transformRequest,
);
// strip content-type if data is undefined
if (isUndefined(config.data)) {
forEach(headers, function (value, header) {
if (lowercase(header) === "content-type") {
delete headers[header];
}
});
}
if (
isUndefined(config.withCredentials) &&
!isUndefined(defaults.withCredentials)
) {
config.withCredentials = defaults.withCredentials;
}
// send request
return sendReq(config, reqData, headers).then(
transformResponse,
transformResponse,
);
};
var chain = [serverRequest, undefined];
var promise = $q.when(config);
// apply interceptors
forEach(reversedInterceptors, function (interceptor) {
if (interceptor.request || interceptor.requestError) {
chain.unshift(interceptor.request, interceptor.requestError);
}
if (interceptor.response || interceptor.responseError) {
chain.push(interceptor.response, interceptor.responseError);
}
});
while (chain.length) {
var thenFn = chain.shift();
var rejectFn = chain.shift();
promise = promise.then(thenFn, rejectFn);
}
promise.success = function (fn) {
promise.then(function (response) {
fn(response.data, response.status, response.headers, config);
});
return promise;
};
promise.error = function (fn) {
promise.then(null, function (response) {
fn(response.data, response.status, response.headers, config);
});
return promise;
};
return promise;
function transformResponse(response) {
// make a copy since the response must be cacheable
var resp = extend({}, response, {
data: transformData(
response.data,
response.headers,
config.transformResponse,
),
});
return isSuccess(response.status) ? resp : $q.reject(resp);
}
function mergeHeaders(config) {
var defHeaders = defaults.headers,
reqHeaders = extend({}, config.headers),
defHeaderName,
lowercaseDefHeaderName,
reqHeaderName;
defHeaders = extend(
{},
defHeaders.common,
defHeaders[lowercase(config.method)],
);
// execute if header value is function
execHeaders(defHeaders);
execHeaders(reqHeaders);
// using for-in instead of forEach to avoid unecessary iteration after header has been found
defaultHeadersIteration: for (defHeaderName in defHeaders) {
lowercaseDefHeaderName = lowercase(defHeaderName);
for (reqHeaderName in reqHeaders) {
if (lowercase(reqHeaderName) === lowercaseDefHeaderName) {
continue defaultHeadersIteration;
}
}
reqHeaders[defHeaderName] = defHeaders[defHeaderName];
}
return reqHeaders;
function execHeaders(headers) {
var headerContent;
forEach(headers, function (headerFn, header) {
if (isFunction(headerFn)) {
headerContent = headerFn();
if (headerContent != null) {
headers[header] = headerContent;
} else {
delete headers[header];
}
}
});
}
}
}
$http.pendingRequests = [];
/**
* @ngdoc method
* @name ng.$http#get
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `GET` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
/**
* @ngdoc method
* @name ng.$http#delete
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `DELETE` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
/**
* @ngdoc method
* @name ng.$http#head
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `HEAD` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
/**
* @ngdoc method
* @name ng.$http#jsonp
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `JSONP` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request.
* Should contain `JSON_CALLBACK` string.
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
createShortMethods("get", "delete", "head", "jsonp");
/**
* @ngdoc method
* @name ng.$http#post
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `POST` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {*} data Request content
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
/**
* @ngdoc method
* @name ng.$http#put
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `PUT` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {*} data Request content
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/
createShortMethodsWithData("post", "put");
/**
* @ngdoc property
* @name ng.$http#defaults
* @propertyOf ng.$http
*
* @description
* Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
* default headers, withCredentials as well as request and response transformations.
*
* See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
*/
$http.defaults = defaults;
return $http;
function createShortMethods(names) {
forEach(arguments, function (name) {
$http[name] = function (url, config) {
return $http(
extend(config || {}, {
method: name,
url: url,
}),
);
};
});
}
function createShortMethodsWithData(name) {
forEach(arguments, function (name) {
$http[name] = function (url, data, config) {
return $http(
extend(config || {}, {
method: name,
url: url,
data: data,
}),
);
};
});
}
/**
* Makes the request.
*
* !!! ACCESSES CLOSURE VARS:
* $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
*/
function sendReq(config, reqData, reqHeaders) {
var deferred = $q.defer(),
promise = deferred.promise,
cache,
cachedResp,
url = buildUrl(config.url, config.params);
$http.pendingRequests.push(config);
promise.then(removePendingReq, removePendingReq);
if (
(config.cache || defaults.cache) &&
config.cache !== false &&
config.method == "GET"
) {
cache = isObject(config.cache)
? config.cache
: isObject(defaults.cache)
? defaults.cache
: defaultCache;
}
if (cache) {
cachedResp = cache.get(url);
if (isDefined(cachedResp)) {
if (cachedResp.then) {
// cached request has already been sent, but there is no response yet
cachedResp.then(removePendingReq, removePendingReq);
return cachedResp;
} else {
// serving from cache
if (isArray(cachedResp)) {
resolvePromise(
cachedResp[1],
cachedResp[0],
copy(cachedResp[2]),
);
} else {
resolvePromise(cachedResp, 200, {});
}
}
} else {
// put the promise for the non-transformed response into cache as a placeholder
cache.put(url, promise);
}
}
// if we won't have the response in cache, send the request to the backend
if (isUndefined(cachedResp)) {
$httpBackend(
config.method,
url,
reqData,
done,
reqHeaders,
config.timeout,
config.withCredentials,
config.responseType,
);
}
return promise;
/**
* Callback registered to $httpBackend():
* - caches the response if desired
* - resolves the raw $http promise
* - calls $apply
*/
function done(status, response, headersString) {
if (cache) {
if (isSuccess(status)) {
cache.put(url, [status, response, parseHeaders(headersString)]);
} else {
// remove promise from the cache
cache.remove(url);
}
}
resolvePromise(response, status, headersString);
if (!$rootScope.$$phase) $rootScope.$apply();
}
/**
* Resolves the raw $http promise.
*/
function resolvePromise(response, status, headers) {
// normalize internal statuses to 0
status = Math.max(status, 0);
(isSuccess(status) ? deferred.resolve : deferred.reject)({
data: response,
status: status,
headers: headersGetter(headers),
config: config,
});
}
function removePendingReq() {
var idx = indexOf($http.pendingRequests, config);
if (idx !== -1) $http.pendingRequests.splice(idx, 1);
}
}
function buildUrl(url, params) {
if (!params) return url;
var parts = [];
forEachSorted(params, function (value, key) {
if (value === null || isUndefined(value)) return;
if (!isArray(value)) value = [value];
forEach(value, function (v) {
if (isObject(v)) {
v = toJson(v);
}
parts.push(encodeUriQuery(key) + "=" + encodeUriQuery(v));
});
});
return url + (url.indexOf("?") == -1 ? "?" : "&") + parts.join("&");
}
},
];
}
var XHR =
window.XMLHttpRequest ||
function () {
/* global ActiveXObject */
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.",
);
};
/**
* @ngdoc object
* @name ng.$httpBackend
* @requires $browser
* @requires $window
* @requires $document
*
* @description
* HTTP backend used by the {@link ng.$http service} that delegates to
* XMLHttpRequest object or JSONP and deals with browser incompatibilities.
*
* You should never need to use this service directly, instead use the higher-level abstractions:
* {@link ng.$http $http} or {@link ngResource.$resource $resource}.
*
* During testing this implementation is swapped with {@link ngMock.$httpBackend mock
* $httpBackend} which can be trained with responses.
*/
function $HttpBackendProvider() {
this.$get = [
"$browser",
"$window",
"$document",
function ($browser, $window, $document) {
return createHttpBackend(
$browser,
XHR,
$browser.defer,
$window.angular.callbacks,
$document[0],
);
},
];
}
function createHttpBackend(
$browser,
XHR,
$browserDefer,
callbacks,
rawDocument,
) {
var ABORTED = -1;
// TODO(vojta): fix the signature
return function (
method,
url,
post,
callback,
headers,
timeout,
withCredentials,
responseType,
) {
var status;
$browser.$$incOutstandingRequestCount();
url = url || $browser.url();
if (lowercase(method) == "jsonp") {
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 () {
if (callbacks[callbackId].data) {
completeRequest(callback, 200, callbacks[callbackId].data);
} else {
completeRequest(callback, status || -2);
}
delete callbacks[callbackId];
},
);
} else {
var xhr = new XHR();
xhr.open(method, url, true);
forEach(headers, function (value, key) {
if (isDefined(value)) {
xhr.setRequestHeader(key, value);
}
});
// In IE6 and 7, this might be called synchronously when xhr.send below is called and the
// response is in the cache. the promise api will ensure that to the app code the api is
// always async
xhr.onreadystatechange = function () {
if (xhr.readyState == 4) {
var responseHeaders = null,
response = null;
if (status !== ABORTED) {
responseHeaders = xhr.getAllResponseHeaders();
response = xhr.responseType ? xhr.response : xhr.responseText;
}
// responseText is the old-school way of retrieving response (supported by IE8 & 9)
// response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
completeRequest(
callback,
status || xhr.status,
response,
responseHeaders,
);
}
};
if (withCredentials) {
xhr.withCredentials = true;
}
if (responseType) {
xhr.responseType = responseType;
}
xhr.send(post || null);
}
if (timeout > 0) {
var timeoutId = $browserDefer(timeoutRequest, timeout);
} else if (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;
// cancel timeout and subsequent timeout promise resolution
timeoutId && $browserDefer.cancel(timeoutId);
jsonpDone = xhr = null;
// fix status code for file protocol (it's always 0)
status =
protocol == "file" && status === 0 ? (response ? 200 : 404) : status;
// normalize IE bug (http://bugs.jquery.com/ticket/1450)
status = status == 1223 ? 204 : status;
callback(status, response, headersString);
$browser.$$completeOutstandingRequest(noop);
}
};
function jsonpReq(url, done) {
// we can't use jQuery/jqLite here because jQuery does crazy shit with script elements, e.g.:
// - fetches local scripts via XHR and evals them
// - adds and immediately removes script elements from the document
var script = rawDocument.createElement("script"),
doneWrapper = function () {
script.onreadystatechange = script.onload = script.onerror = null;
rawDocument.body.removeChild(script);
if (done) done();
};
script.type = "text/javascript";
script.src = url;
if (msie && msie <= 8) {
script.onreadystatechange = function () {
if (/loaded|complete/.test(script.readyState)) {
doneWrapper();
}
};
} else {
script.onload = script.onerror = function () {
doneWrapper();
};
}
rawDocument.body.appendChild(script);
return doneWrapper;
}
}
var $interpolateMinErr = minErr("$interpolate");
/**
* @ngdoc object
* @name ng.$interpolateProvider
* @function
*
* @description
*
* Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
*
* @example
<doc:example module="customInterpolationApp">
<doc:source>
<script>
var customInterpolationApp = angular.module('customInterpolationApp', []);
customInterpolationApp.config(function($interpolateProvider) {
$interpolateProvider.startSymbol('//');
$interpolateProvider.endSymbol('//');
});
customInterpolationApp.controller('DemoController', function DemoController() {
this.label = "This binding is brought you by // interpolation symbols.";
});
</script>
<div ng-app="App" ng-controller="DemoController as demo">
//demo.label//
</div>
</doc:source>
<doc:scenario>
it('should interpolate binding with custom symbols', function() {
expect(binding('demo.label')).toBe('This binding is brought you by // interpolation symbols.');
});
</doc:scenario>
</doc:example>
*/
function $InterpolateProvider() {
var startSymbol = "{{";
var endSymbol = "}}";
/**
* @ngdoc method
* @name ng.$interpolateProvider#startSymbol
* @methodOf ng.$interpolateProvider
* @description
* Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
*
* @param {string=} value new value to set the starting symbol to.
* @returns {string|self} Returns the symbol when used as getter and self if used as setter.
*/
this.startSymbol = function (value) {
if (value) {
startSymbol = value;
return this;
} else {
return startSymbol;
}
};
/**
* @ngdoc method
* @name ng.$interpolateProvider#endSymbol
* @methodOf ng.$interpolateProvider
* @description
* Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
*
* @param {string=} value new value to set the ending symbol to.
* @returns {string|self} Returns the symbol when used as getter and self if used as setter.
*/
this.endSymbol = function (value) {
if (value) {
endSymbol = value;
return this;
} else {
return endSymbol;
}
};
this.$get = [
"$parse",
"$exceptionHandler",
"$sce",
function ($parse, $exceptionHandler, $sce) {
var startSymbolLength = startSymbol.length,
endSymbolLength = endSymbol.length;
/**
* @ngdoc function
* @name ng.$interpolate
* @function
*
* @requires $parse
* @requires $sce
*
* @description
*
* Compiles a string with markup into an interpolation function. This service is used by the
* HTML {@link ng.$compile $compile} service for data binding. See
* {@link ng.$interpolateProvider $interpolateProvider} for configuring the
* interpolation markup.
*
*
<pre>
var $interpolate = ...; // injected
var exp = $interpolate('Hello {{name | uppercase}}!');
expect(exp({name:'Angular'}).toEqual('Hello ANGULAR!');
</pre>
*
*
* @param {string} text The text with markup to interpolate.
* @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
* embedded expression in order to return an interpolation function. Strings with no
* embedded expression will return null for the interpolation function.
* @param {string=} trustedContext when provided, the returned function passes the interpolated
* result through {@link ng.$sce#methods_getTrusted $sce.getTrusted(interpolatedResult,
* trustedContext)} before returning it. Refer to the {@link ng.$sce $sce} service that
* provides Strict Contextual Escaping for details.
* @returns {function(context)} an interpolation function which is used to compute the
* interpolated string. The function has these parameters:
*
* * `context`: an object against which any expressions embedded in the strings are evaluated
* against.
*
*/
function $interpolate(text, mustHaveExpression, trustedContext) {
var startIndex,
endIndex,
index = 0,
parts = [],
length = text.length,
hasInterpolation = false,
fn,
exp,
concat = [];
while (index < length) {
if (
(startIndex = text.indexOf(startSymbol, index)) != -1 &&
(endIndex = text.indexOf(
endSymbol,
startIndex + startSymbolLength,
)) != -1
) {
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 = true;
} else {
// we did not find anything, so we have to add the remainder to the parts array
index != length && parts.push(text.substring(index));
index = length;
}
}
if (!(length = parts.length)) {
// we added, nothing, must have been an empty string.
parts.push("");
length = 1;
}
// Concatenating expressions makes it hard to reason about whether some combination of
// concatenated values are unsafe to use and could easily lead to XSS. By requiring that a
// single expression be used for iframe[src], object[src], etc., we ensure that the value
// that's used is assigned or constructed by some JS code somewhere that is more testable or
// make it obvious that you bound the value to some user controlled value. This helps reduce
// the load when auditing for XSS issues.
if (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) {
concat.length = length;
fn = function (context) {
try {
for (var i = 0, ii = length, part; i < ii; i++) {
if (typeof (part = parts[i]) == "function") {
part = part(context);
if (trustedContext) {
part = $sce.getTrusted(trustedContext, part);
} else {
part = $sce.valueOf(part);
}
if (part === null || isUndefined(part)) {
part = "";
} else if (typeof part != "string") {
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);
}
};
fn.exp = text;
fn.parts = parts;
return fn;
}
}
/**
* @ngdoc method
* @name ng.$interpolate#startSymbol
* @methodOf ng.$interpolate
* @description
* Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
*
* Use {@link ng.$interpolateProvider#startSymbol $interpolateProvider#startSymbol} to change
* the symbol.
*
* @returns {string} start symbol.
*/
$interpolate.startSymbol = function () {
return startSymbol;
};
/**
* @ngdoc method
* @name ng.$interpolate#endSymbol
* @methodOf ng.$interpolate
* @description
* Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
*
* Use {@link ng.$interpolateProvider#endSymbol $interpolateProvider#endSymbol} to change
* the symbol.
*
* @returns {string} start symbol.
*/
$interpolate.endSymbol = function () {
return endSymbol;
};
return $interpolate;
},
];
}
function $IntervalProvider() {
this.$get = [
"$rootScope",
"$window",
"$q",
function ($rootScope, $window, $q) {
var intervals = {};
/**
* @ngdoc function
* @name ng.$interval
*
* @description
* Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
* milliseconds.
*
* The return value of registering an interval function is a promise. This promise will be
* notified upon each tick of the interval, and will be resolved after `count` iterations, or
* run indefinitely if `count` is not defined. The value of the notification will be the
* number of iterations that have run.
* To cancel an interval, call `$interval.cancel(promise)`.
*
* In tests you can use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to
* move forward by `millis` milliseconds and trigger any functions scheduled to run in that
* time.
*
* @param {function()} fn A function that should be called repeatedly.
* @param {number} delay Number of milliseconds between each function call.
* @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
* indefinitely.
* @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
* will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
* @returns {promise} A promise which will be notified on each iteration.
*/
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;
(count = isDefined(count) ? count : 0), promise.then(null, null, fn);
promise.$$intervalId = setInterval(function tick() {
deferred.notify(iteration++);
if (count > 0 && iteration >= count) {
deferred.resolve(iteration);
clearInterval(promise.$$intervalId);
delete intervals[promise.$$intervalId];
}
if (!skipApply) $rootScope.$apply();
}, delay);
intervals[promise.$$intervalId] = deferred;
return promise;
}
/**
* @ngdoc function
* @name ng.$interval#cancel
* @methodOf ng.$interval
*
* @description
* Cancels a task associated with the `promise`.
*
* @param {number} promise Promise returned by the `$interval` function.
* @returns {boolean} Returns `true` if the task was successfully canceled.
*/
interval.cancel = function (promise) {
if (promise && promise.$$intervalId in intervals) {
intervals[promise.$$intervalId].reject("canceled");
clearInterval(promise.$$intervalId);
delete intervals[promise.$$intervalId];
return true;
}
return false;
};
return interval;
},
];
}
/**
* @ngdoc object
* @name ng.$locale
*
* @description
* $locale service provides localization rules for various Angular components. As of right now the
* only public api is:
*
* * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`)
*/
function $LocaleProvider() {
this.$get = function () {
return {
id: "en-us",
NUMBER_FORMATS: {
DECIMAL_SEP: ".",
GROUP_SEP: ",",
PATTERNS: [
{
// Decimal Pattern
minInt: 1,
minFrac: 0,
maxFrac: 3,
posPre: "",
posSuf: "",
negPre: "-",
negSuf: "",
gSize: 3,
lgSize: 3,
},
{
//Currency Pattern
minInt: 1,
minFrac: 2,
maxFrac: 2,
posPre: "\u00A4",
posSuf: "",
negPre: "(\u00A4",
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) {
if (num === 1) {
return "one";
}
return "other";
},
};
};
}
var PATH_MATCH = /^([^\?#]*)(\?([^#]*))?(#(.*))?$/,
DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
var $locationMinErr = minErr("$location");
/**
* Encode path using encodeUriSegment, ignoring forward slashes
*
* @param {string} path Path to encode
* @returns {string}
*/
function encodePath(path) {
var segments = path.split("/"),
i = segments.length;
while (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) !== "/";
if (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);
// make sure path starts with '/';
if (locationObj.$$path && locationObj.$$path.charAt(0) != "/") {
locationObj.$$path = "/" + locationObj.$$path;
}
}
/**
*
* @param {string} begin
* @param {string} whole
* @returns {string} returns text from whole after begin or undefined if it does not begin with
* expected string.
*/
function beginsWith(begin, whole) {
if (whole.indexOf(begin) === 0) {
return whole.substr(begin.length);
}
}
function stripHash(url) {
var index = url.indexOf("#");
return index == -1 ? url : url.substr(0, index);
}
function stripFile(url) {
return url.substr(0, stripHash(url).lastIndexOf("/") + 1);
}
/* return the server only (scheme://host:port) */
function serverBase(url) {
return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
}
/**
* LocationHtml5Url represents an url
* This object is exposed as $location service when HTML5 mode is enabled and supported
*
* @constructor
* @param {string} appBase application base URL
* @param {string} basePrefix url path prefix
*/
function LocationHtml5Url(appBase, basePrefix) {
this.$$html5 = true;
basePrefix = basePrefix || "";
var appBaseNoFile = stripFile(appBase);
parseAbsoluteUrl(appBase, this, appBase);
/**
* Parse given html5 (regular) url string into properties
* @param {string} newAbsoluteUrl HTML5 url
* @private
*/
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);
if (!this.$$path) {
this.$$path = "/";
}
this.$$compose();
};
/**
* Compose url and update `absUrl` property
* @private
*/
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); // first char is always '/'
};
this.$$rewrite = function (url) {
var appUrl, prevAppUrl;
if ((appUrl = beginsWith(appBase, url)) !== undefined) {
prevAppUrl = appUrl;
if ((appUrl = beginsWith(basePrefix, appUrl)) !== undefined) {
return appBaseNoFile + (beginsWith("/", appUrl) || appUrl);
} else {
return appBase + prevAppUrl;
}
} else if ((appUrl = beginsWith(appBaseNoFile, url)) !== undefined) {
return appBaseNoFile + appUrl;
} else if (appBaseNoFile == url + "/") {
return appBaseNoFile;
}
};
}
/**
* LocationHashbangUrl represents url
* This object is exposed as $location service when developer doesn't opt into html5 mode.
* It also serves as the base class for html5 mode fallback on legacy browsers.
*
* @constructor
* @param {string} appBase application base URL
* @param {string} hashPrefix hashbang prefix
*/
function LocationHashbangUrl(appBase, hashPrefix) {
var appBaseNoFile = stripFile(appBase);
parseAbsoluteUrl(appBase, this, appBase);
/**
* Parse given hashbang url into properties
* @param {string} url Hashbang url
* @private
*/
this.$$parse = function (url) {
var withoutBaseUrl =
beginsWith(appBase, url) || beginsWith(appBaseNoFile, url);
var 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 = removeWindowsDriveName(
this.$$path,
withoutHashUrl,
appBase,
);
this.$$compose();
/*
* In Windows, on an anchor node on documents loaded from
* the filesystem, the browser will return a pathname
* prefixed with the drive name ('/C:/path') when a
* pathname without a drive is set:
* * a.setAttribute('href', '/foo')
* * a.pathname === '/C:/foo' //true
*
* Inside of Angular, we're always using pathnames that
* do not include drive names for routing.
*/
function removeWindowsDriveName(path, url, base) {
/*
Matches paths for file protocol on windows,
such as /C:/foo/bar, and captures only /foo/bar.
*/
var windowsFilePathExp = /^\/?.*?:(\/.*)/;
var firstPathSegmentMatch;
//Get the relative path from the input URL.
if (url.indexOf(base) === 0) {
url = url.replace(base, "");
}
/*
* The input URL intentionally contains a
* first path segment that ends with a colon.
*/
if (windowsFilePathExp.exec(url)) {
return path;
}
firstPathSegmentMatch = windowsFilePathExp.exec(path);
return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
}
};
/**
* Compose hashbang url and update `absUrl` property
* @private
*/
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;
}
};
}
/**
* LocationHashbangUrl represents url
* This object is exposed as $location service when html5 history api is enabled but the browser
* does not support it.
*
* @constructor
* @param {string} appBase application base URL
* @param {string} hashPrefix hashbang prefix
*/
function LocationHashbangInHtml5Url(appBase, hashPrefix) {
this.$$html5 = true;
LocationHashbangUrl.apply(this, arguments);
var appBaseNoFile = stripFile(appBase);
this.$$rewrite = function (url) {
var appUrl;
if (appBase == stripHash(url)) {
return url;
} else if ((appUrl = beginsWith(appBaseNoFile, url))) {
return appBase + hashPrefix + appUrl;
} else if (appBaseNoFile === url + "/") {
return appBaseNoFile;
}
};
}
LocationHashbangInHtml5Url.prototype =
LocationHashbangUrl.prototype =
LocationHtml5Url.prototype =
{
/**
* Are we in html5 mode?
* @private
*/
$$html5: false,
/**
* Has any change been replacing ?
* @private
*/
$$replace: false,
/**
* @ngdoc method
* @name ng.$location#absUrl
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return full url representation with all segments encoded according to rules specified in
* {@link http://www.ietf.org/rfc/rfc3986.txt RFC 3986}.
*
* @return {string} full url
*/
absUrl: locationGetter("$$absUrl"),
/**
* @ngdoc method
* @name ng.$location#url
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return url (e.g. `/path?a=b#hash`) when called without any parameter.
*
* Change path, search and hash, when called with parameter and return `$location`.
*
* @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
* @param {string=} replace The path that will be changed
* @return {string} url
*/
url: function (url, replace) {
if (isUndefined(url)) return this.$$url;
var match = PATH_MATCH.exec(url);
if (match[1]) this.path(decodeURIComponent(match[1]));
if (match[2] || match[1]) this.search(match[3] || "");
this.hash(match[5] || "", replace);
return this;
},
/**
* @ngdoc method
* @name ng.$location#protocol
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return protocol of current url.
*
* @return {string} protocol of current url
*/
protocol: locationGetter("$$protocol"),
/**
* @ngdoc method
* @name ng.$location#host
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return host of current url.
*
* @return {string} host of current url.
*/
host: locationGetter("$$host"),
/**
* @ngdoc method
* @name ng.$location#port
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return port of current url.
*
* @return {Number} port
*/
port: locationGetter("$$port"),
/**
* @ngdoc method
* @name ng.$location#path
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return path of current url when called without any parameter.
*
* Change path when called with parameter and return `$location`.
*
* Note: Path should always begin with forward slash (/), this method will add the forward slash
* if it is missing.
*
* @param {string=} path New path
* @return {string} path
*/
path: locationGetterSetter("$$path", function (path) {
return path.charAt(0) == "/" ? path : "/" + path;
}),
/**
* @ngdoc method
* @name ng.$location#search
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return search part (as object) of current url when called without any parameter.
*
* Change search part when called with parameter and return `$location`.
*
* @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
* hash object. Hash object may contain an array of values, which will be decoded as duplicates in
* the url.
*
* @param {(string|Array<string>)=} paramValue If `search` is a string, then `paramValue` will override only a
* single search parameter. If `paramValue` is an array, it will set the parameter as a
* comma-separated value. If `paramValue` is `null`, the parameter will be deleted.
*
* @return {string} search
*/
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)) {
this.$$search = search;
} else {
throw $locationMinErr(
"isrcharg",
"The first argument of the `$location#search()` call must be a string or an object.",
);
}
break;
default:
if (isUndefined(paramValue) || paramValue === null) {
delete this.$$search[search];
} else {
this.$$search[search] = paramValue;
}
}
this.$$compose();
return this;
},
/**
* @ngdoc method
* @name ng.$location#hash
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return hash fragment when called without any parameter.
*
* Change hash fragment when called with parameter and return `$location`.
*
* @param {string=} hash New hash fragment
* @return {string} hash
*/
hash: locationGetterSetter("$$hash", identity),
/**
* @ngdoc method
* @name ng.$location#replace
* @methodOf ng.$location
*
* @description
* If called, all changes to $location during current `$digest` will be replacing current history
* record, instead of adding new one.
*/
replace: function () {
this.$$replace = true;
return this;
},
};
function locationGetter(property) {
return function () {
return this[property];
};
}
function locationGetterSetter(property, preprocess) {
return function (value) {
if (isUndefined(value)) return this[property];
this[property] = preprocess(value);
this.$$compose();
return this;
};
}
/**
* @ngdoc object
* @name ng.$location
*
* @requires $browser
* @requires $sniffer
* @requires $rootElement
*
* @description
* The $location service parses the URL in the browser address bar (based on the
* {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL
* available to your application. Changes to the URL in the address bar are reflected into
* $location service and changes to $location are reflected into the browser address bar.
*
* **The $location service:**
*
* - Exposes the current URL in the browser address bar, so you can
* - Watch and observe the URL.
* - Change the URL.
* - Synchronizes the URL with the browser when the user
* - Changes the address bar.
* - Clicks the back or forward button (or clicks a History link).
* - Clicks on a link.
* - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
*
* For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular
* Services: Using $location}
*/
/**
* @ngdoc object
* @name ng.$locationProvider
* @description
* Use the `$locationProvider` to configure how the application deep linking paths are stored.
*/
function $LocationProvider() {
var hashPrefix = "",
html5Mode = false;
/**
* @ngdoc property
* @name ng.$locationProvider#hashPrefix
* @methodOf ng.$locationProvider
* @description
* @param {string=} prefix Prefix for hash part (containing path and search)
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/
this.hashPrefix = function (prefix) {
if (isDefined(prefix)) {
hashPrefix = prefix;
return this;
} else {
return hashPrefix;
}
};
/**
* @ngdoc property
* @name ng.$locationProvider#html5Mode
* @methodOf ng.$locationProvider
* @description
* @param {boolean=} mode Use HTML5 strategy if available.
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/
this.html5Mode = function (mode) {
if (isDefined(mode)) {
html5Mode = mode;
return this;
} else {
return html5Mode;
}
};
/**
* @ngdoc event
* @name ng.$location#$locationChangeStart
* @eventOf ng.$location
* @eventType broadcast on root scope
* @description
* Broadcasted before a URL will change. This change can be prevented by calling
* `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
* details about event object. Upon successful change
* {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
*
* @param {Object} angularEvent Synthetic event object.
* @param {string} newUrl New URL
* @param {string=} oldUrl URL that was before it was changed.
*/
/**
* @ngdoc event
* @name ng.$location#$locationChangeSuccess
* @eventOf ng.$location
* @eventType broadcast on root scope
* @description
* Broadcasted after a URL was changed.
*
* @param {Object} angularEvent Synthetic event object.
* @param {string} newUrl New URL
* @param {string=} oldUrl URL that was before it was changed.
*/
this.$get = [
"$rootScope",
"$browser",
"$sniffer",
"$rootElement",
function ($rootScope, $browser, $sniffer, $rootElement) {
var $location,
LocationMode,
baseHref = $browser.baseHref(), // if base[href] is undefined, it defaults to ''
initialUrl = $browser.url(),
appBase;
if (html5Mode) {
appBase = serverBase(initialUrl) + (baseHref || "/");
LocationMode = $sniffer.history
? LocationHtml5Url
: LocationHashbangInHtml5Url;
} else {
appBase = stripHash(initialUrl);
LocationMode = LocationHashbangUrl;
}
$location = new LocationMode(appBase, "#" + hashPrefix);
$location.$$parse($location.$$rewrite(initialUrl));
$rootElement.on("click", function (event) {
// TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
// currently we open nice url link and redirect then
if (event.ctrlKey || event.metaKey || event.which == 2) return;
var elm = jqLite(event.target);
// traverse the DOM up to find first A tag
while (lowercase(elm[0].nodeName) !== "a") {
// ignore rewriting if no A tag (reached root element, or no parent - removed from document)
if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;
}
var absHref = elm.prop("href");
var rewrittenUrl = $location.$$rewrite(absHref);
if (
absHref &&
!elm.attr("target") &&
rewrittenUrl &&
!event.isDefaultPrevented()
) {
event.preventDefault();
if (rewrittenUrl != $browser.url()) {
// update location manually
$location.$$parse(rewrittenUrl);
$rootScope.$apply();
// hack to work around FF6 bug 684208 when scenario runner clicks on links
window.angular["ff-684208-preventDefault"] = true;
}
}
});
// rewrite hashbang url <> html5 url
if ($location.absUrl() != initialUrl) {
$browser.url($location.absUrl(), true);
}
// update $location when $browser url changes
$browser.onUrlChange(function (newUrl) {
if ($location.absUrl() != newUrl) {
if (
$rootScope.$broadcast(
"$locationChangeStart",
newUrl,
$location.absUrl(),
).defaultPrevented
) {
$browser.url($location.absUrl());
return;
}
$rootScope.$evalAsync(function () {
var oldUrl = $location.absUrl();
$location.$$parse(newUrl);
afterLocationChange(oldUrl);
});
if (!$rootScope.$$phase) $rootScope.$digest();
}
});
// update browser
var changeCounter = 0;
$rootScope.$watch(function $locationWatch() {
var oldUrl = $browser.url();
var currentReplace = $location.$$replace;
if (!changeCounter || oldUrl != $location.absUrl()) {
changeCounter++;
$rootScope.$evalAsync(function () {
if (
$rootScope.$broadcast(
"$locationChangeStart",
$location.absUrl(),
oldUrl,
).defaultPrevented
) {
$location.$$parse(oldUrl);
} else {
$browser.url($location.absUrl(), currentReplace);
afterLocationChange(oldUrl);
}
});
}
$location.$$replace = false;
return changeCounter;
});
return $location;
function afterLocationChange(oldUrl) {
$rootScope.$broadcast(
"$locationChangeSuccess",
$location.absUrl(),
oldUrl,
);
}
},
];
}
/**
* @ngdoc object
* @name ng.$log
* @requires $window
*
* @description
* Simple service for logging. Default implementation safely writes the message
* into the browser's console (if present).
*
* The main purpose of this service is to simplify debugging and troubleshooting.
*
* The default is to log `debug` messages. You can use
* {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this.
*
* @example
<example>
<file name="script.js">
function LogCtrl($scope, $log) {
$scope.$log = $log;
$scope.message = 'Hello World!';
}
</file>
<file name="index.html">
<div ng-controller="LogCtrl">
<p>Reload this page with open console, enter text and hit the log button...</p>
Message:
<input type="text" ng-model="message"/>
<button ng-click="$log.log(message)">log</button>
<button ng-click="$log.warn(message)">warn</button>
<button ng-click="$log.info(message)">info</button>
<button ng-click="$log.error(message)">error</button>
</div>
</file>
</example>
*/
/**
* @ngdoc object
* @name ng.$logProvider
* @description
* Use the `$logProvider` to configure how the application logs messages
*/
function $LogProvider() {
var debug = true,
self = this;
/**
* @ngdoc property
* @name ng.$logProvider#debugEnabled
* @methodOf ng.$logProvider
* @description
* @param {string=} flag enable or disable debug level messages
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/
this.debugEnabled = function (flag) {
if (isDefined(flag)) {
debug = flag;
return this;
} else {
return debug;
}
};
this.$get = [
"$window",
function ($window) {
return {
/**
* @ngdoc method
* @name ng.$log#log
* @methodOf ng.$log
*
* @description
* Write a log message
*/
log: consoleLog("log"),
/**
* @ngdoc method
* @name ng.$log#info
* @methodOf ng.$log
*
* @description
* Write an information message
*/
info: consoleLog("info"),
/**
* @ngdoc method
* @name ng.$log#warn
* @methodOf ng.$log
*
* @description
* Write a warning message
*/
warn: consoleLog("warn"),
/**
* @ngdoc method
* @name ng.$log#error
* @methodOf ng.$log
*
* @description
* Write an error message
*/
error: consoleLog("error"),
/**
* @ngdoc method
* @name ng.$log#debug
* @methodOf ng.$log
*
* @description
* Write a debug message
*/
debug: (function () {
var fn = consoleLog("debug");
return function () {
if (debug) {
fn.apply(self, arguments);
}
};
})(),
};
function formatError(arg) {
if (arg instanceof Error) {
if (arg.stack) {
arg =
arg.message && arg.stack.indexOf(arg.message) === -1
? "Error: " + arg.message + "\n" + arg.stack
: arg.stack;
} else if (arg.sourceURL) {
arg = arg.message + "\n" + arg.sourceURL + ":" + arg.line;
}
}
return arg;
}
function consoleLog(type) {
var console = $window.console || {},
logFn = console[type] || console.log || noop;
if (logFn.apply) {
return function () {
var args = [];
forEach(arguments, function (arg) {
args.push(formatError(arg));
});
return logFn.apply(console, args);
};
}
// we are IE which either doesn't have window.console => this is noop and we do nothing,
// or we are IE where console.log doesn't have apply so we log at least first 2 args
return function (arg1, arg2) {
logFn(arg1, arg2 == null ? "" : arg2);
};
}
},
];
}
var $parseMinErr = minErr("$parse");
var promiseWarningCache = {};
var promiseWarning;
// Sandboxing Angular Expressions
// ------------------------------
// Angular expressions are generally considered safe because these expressions only have direct
// access to $scope and locals. However, one can obtain the ability to execute arbitrary JS code by
// obtaining a reference to native JS functions such as the Function constructor.
//
// As an example, consider the following Angular expression:
//
// {}.toString.constructor(alert("evil JS code"))
//
// We want to prevent this type of access. For the sake of performance, during the lexing phase we
// disallow any "dotted" access to any member named "constructor".
//
// For reflective calls (a[b]) we check that the value of the lookup is not the Function constructor
// while evaluating the expression, which is a stronger but more expensive test. Since reflective
// calls are expensive anyway, this is not such a big deal compared to static dereferencing.
//
// This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits
// against the expression language, but not to prevent exploits that were enabled by exposing
// sensitive JavaScript or browser apis on Scope. Exposing such objects on a Scope is never a good
// practice and therefore we are not even trying to protect against interaction with an object
// explicitly exposed in this way.
//
// A developer could foil the name check by aliasing the Function constructor under a different
// name on the scope.
//
// In general, it is not possible to access a Window object from an angular expression unless a
// window or some DOM object that has a reference to window is published onto a Scope.
function ensureSafeMemberName(name, fullExpression) {
if (name === "constructor") {
throw $parseMinErr(
"isecfld",
'Referencing "constructor" field in Angular expressions is disallowed! Expression: {0}',
fullExpression,
);
}
return name;
}
function ensureSafeObject(obj, fullExpression) {
// nifty check if obj is Function that is fast and works across iframes and other contexts
if (obj) {
if (obj.constructor === obj) {
throw $parseMinErr(
"isecfn",
"Referencing Function in Angular expressions is disallowed! Expression: {0}",
fullExpression,
);
} else if (
// isWindow(obj)
obj.document &&
obj.location &&
obj.alert &&
obj.setInterval
) {
throw $parseMinErr(
"isecwindow",
"Referencing the Window in Angular expressions is disallowed! Expression: {0}",
fullExpression,
);
} else if (
// isElement(obj)
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 = {
/* jshint bitwise : false */
null: function () {
return null;
},
true: function () {
return true;
},
false: function () {
return false;
},
undefined: noop,
"+": function (self, locals, a, b) {
a = a(self, locals);
b = b(self, locals);
if (isDefined(a)) {
if (isDefined(b)) {
return a + b;
}
return a;
}
return isDefined(b) ? b : undefined;
},
"-": function (self, locals, a, b) {
a = a(self, locals);
b = b(self, locals);
return (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 a|b;},
"|": function (self, locals, a, b) {
return b(self, locals)(self, locals, a(self, locals));
},
"!": function (self, locals, a) {
return !a(self, locals);
},
};
/* jshint bitwise: true */
var ESCAPE = {
n: "\n",
f: "\f",
r: "\r",
t: "\t",
v: "\v",
"'": "'",
'"': '"',
};
/////////////////////////////////////////
/**
* @constructor
*/
var Lexer = function (options) {
this.options = options;
};
Lexer.prototype = {
constructor: Lexer,
lex: function (text) {
this.text = text;
this.index = 0;
this.ch = undefined;
this.lastCh = ":"; // can start regexp
this.tokens = [];
var token;
var json = [];
while (this.index < this.text.length) {
this.ch = this.text.charAt(this.index);
if (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();
// identifiers can only be if the preceding char was a { or ,
if (
this.was("{,") &&
json[0] === "{" &&
(token = this.tokens[this.tokens.length - 1])
) {
token.json = token.text.indexOf(".") === -1;
}
} else if (this.is("(){}[].,;:?")) {
this.tokens.push({
index: this.index,
text: this.ch,
json: (this.was(":[,") && this.is("{[")) || this.is("}]:,"),
});
if (this.is("{[")) json.unshift(this.ch);
if (this.is("}]")) json.shift();
this.index++;
} else if (this.isWhitespace(this.ch)) {
this.index++;
continue;
} else {
var ch2 = this.ch + this.peek();
var ch3 = ch2 + this.peek(2);
var fn = OPERATORS[this.ch];
var fn2 = OPERATORS[ch2];
var fn3 = OPERATORS[ch3];
if (fn3) {
this.tokens.push({ index: this.index, text: ch3, fn: fn3 });
this.index += 3;
} else if (fn2) {
this.tokens.push({ index: this.index, text: ch2, fn: fn2 });
this.index += 2;
} else if (fn) {
this.tokens.push({
index: this.index,
text: this.ch,
fn: fn,
json: this.was("[,:") && this.is("+-"),
});
this.index += 1;
} else {
this.throwError(
"Unexpected next character ",
this.index,
this.index + 1,
);
}
}
this.lastCh = this.ch;
}
return this.tokens;
},
is: function (chars) {
return chars.indexOf(this.ch) !== -1;
},
was: function (chars) {
return chars.indexOf(this.lastCh) !== -1;
},
peek: function (i) {
var num = i || 1;
return this.index + num < this.text.length
? this.text.charAt(this.index + num)
: false;
},
isNumber: function (ch) {
return "0" <= ch && ch <= "9";
},
isWhitespace: function (ch) {
// IE treats non-breaking space as \u00A0
return (
ch === " " ||
ch === "\r" ||
ch === "\t" ||
ch === "\n" ||
ch === "\v" ||
ch === "\u00A0"
);
},
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 () {
var number = "";
var start = this.index;
while (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 (ch == "e" && this.isExpOperator(peekCh)) {
number += ch;
} else if (
this.isExpOperator(ch) &&
peekCh &&
this.isNumber(peekCh) &&
number.charAt(number.length - 1) == "e"
) {
number += ch;
} else if (
this.isExpOperator(ch) &&
(!peekCh || !this.isNumber(peekCh)) &&
number.charAt(number.length - 1) == "e"
) {
this.throwError("Invalid exponent");
} else {
break;
}
}
this.index++;
}
number = 1 * number;
this.tokens.push({
index: start,
text: number,
json: true,
fn: function () {
return number;
},
});
},
readIdent: function () {
var parser = this;
var ident = "";
var start = this.index;
var lastDot, peekIndex, methodName, ch;
while (this.index < this.text.length) {
ch = this.text.charAt(this.index);
if (ch === "." || this.isIdent(ch) || this.isNumber(ch)) {
if (ch === ".") lastDot = this.index;
ident += ch;
} else {
break;
}
this.index++;
}
//check if this is not a method invocation and if it is back out to last dot
if (lastDot) {
peekIndex = this.index;
while (peekIndex < this.text.length) {
ch = this.text.charAt(peekIndex);
if (ch === "(") {
methodName = ident.substr(lastDot - start + 1);
ident = ident.substr(0, lastDot - start);
this.index = peekIndex;
break;
}
if (this.isWhitespace(ch)) {
peekIndex++;
} else {
break;
}
}
}
var token = {
index: start,
text: ident,
};
// OPERATORS is our own object so we don't need to use special hasOwnPropertyFn
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);
if (methodName) {
this.tokens.push({
index: lastDot,
text: ".",
json: false,
});
this.tokens.push({
index: lastDot + 1,
text: methodName,
json: false,
});
}
},
readString: function (quote) {
var start = this.index;
this.index++;
var string = "";
var rawString = quote;
var escape = false;
while (this.index < this.text.length) {
var ch = this.text.charAt(this.index);
rawString += ch;
if (escape) {
if (ch === "u") {
var hex = this.text.substring(this.index + 1, this.index + 5);
if (!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];
if (rep) {
string += rep;
} else {
string += ch;
}
}
escape = false;
} else if (ch === "\\") {
escape = true;
} else if (ch === quote) {
this.index++;
this.tokens.push({
index: start,
text: rawString,
string: string,
json: true,
fn: function () {
return string;
},
});
return;
} else {
string += ch;
}
this.index++;
}
this.throwError("Unterminated quote", start);
},
};
/**
* @constructor
*/
var Parser = function (lexer, $filter, options) {
this.lexer = lexer;
this.$filter = $filter;
this.options = options;
};
Parser.ZERO = function () {
return 0;
};
Parser.prototype = {
constructor: Parser,
parse: function (text, json) {
this.text = text;
//TODO(i): strip all the obsolte json stuff from this file
this.json = json;
this.tokens = this.lexer.lex(text);
if (json) {
// The extra level of aliasing is here, just in case the lexer misses something, so that
// we prevent any accidental execution in 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();
if (this.tokens.length !== 0) {
this.throwError("is an unexpected token", this.tokens[0]);
}
value.literal = !!value.literal;
value.constant = !!value.constant;
return value;
},
primary: function () {
var primary;
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;
if (!primary) {
this.throwError("not a primary expression", token);
}
if (token.json) {
primary.constant = true;
primary.literal = true;
}
}
var next, context;
while ((next = this.expect("(", "[", "."))) {
if (next.text === "(") {
primary = this.functionCall(primary, context);
context = null;
} else if (next.text === "[") {
context = primary;
primary = this.objectIndex(primary);
} else if (next.text === ".") {
context = primary;
primary = this.fieldAccess(primary);
} else {
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 (this.tokens.length === 0)
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];
var t = token.text;
if (
t === e1 ||
t === e2 ||
t === e3 ||
t === e4 ||
(!e1 && !e2 && !e3 && !e4)
) {
return token;
}
}
return false;
},
expect: function (e1, e2, e3, e4) {
var token = this.peek(e1, e2, e3, e4);
if (token) {
if (this.json && !token.json) {
this.throwError("is not valid json", token);
}
this.tokens.shift();
return token;
}
return false;
},
consume: function (e1) {
if (!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 () {
var statements = [];
while (true) {
if (this.tokens.length > 0 && !this.peek("}", ")", ";", "]"))
statements.push(this.filterChain());
if (!this.expect(";")) {
// optimize for the common case where there is only one statement.
// TODO(size): maybe we should not support multiple statements?
return statements.length === 1
? statements[0]
: function (self, locals) {
var value;
for (var i = 0; i < statements.length; i++) {
var statement = statements[i];
if (statement) {
value = statement(self, locals);
}
}
return value;
};
}
}
},
filterChain: function () {
var left = this.expression();
var token;
while (true) {
if ((token = this.expect("|"))) {
left = this.binaryFn(left, token.fn, this.filter());
} else {
return left;
}
}
},
filter: function () {
var token = this.expect();
var fn = this.$filter(token.text);
var argsFn = [];
while (true) {
if ((token = this.expect(":"))) {
argsFn.push(this.expression());
} else {
var fnInvoke = function (self, locals, input) {
var args = [input];
for (var i = 0; i < argsFn.length; i++) {
args.push(argsFn[i](self, locals));
}
return fn.apply(self, args);
};
return function () {
return fnInvoke;
};
}
}
},
expression: function () {
return this.assignment();
},
assignment: function () {
var left = this.ternary();
var right;
var token;
if ((token = this.expect("="))) {
if (!left.assign) {
this.throwError(
"implies assignment but [" +
this.text.substring(0, token.index) +
"] can not be assigned to",
token,
);
}
right = this.ternary();
return function (scope, locals) {
return left.assign(scope, right(scope, locals), locals);
};
}
return left;
},
ternary: function () {
var left = this.logicalOR();
var middle;
var token;
if ((token = this.expect("?"))) {
middle = this.ternary();
if ((token = this.expect(":"))) {
return this.ternaryFn(left, middle, this.ternary());
} else {
this.throwError("expected :", token);
}
} else {
return left;
}
},
logicalOR: function () {
var left = this.logicalAND();
var token;
while (true) {
if ((token = this.expect("||"))) {
left = this.binaryFn(left, token.fn, this.logicalAND());
} else {
return left;
}
}
},
logicalAND: function () {
var left = this.equality();
var token;
if ((token = this.expect("&&"))) {
left = this.binaryFn(left, token.fn, this.logicalAND());
}
return left;
},
equality: function () {
var left = this.relational();
var token;
if ((token = this.expect("==", "!=", "===", "!=="))) {
left = this.binaryFn(left, token.fn, this.equality());
}
return left;
},
relational: function () {
var left = this.additive();
var token;
if ((token = this.expect("<", ">", "<=", ">="))) {
left = this.binaryFn(left, token.fn, this.relational());
}
return left;
},
additive: function () {
var left = this.multiplicative();
var token;
while ((token = this.expect("+", "-"))) {
left = this.binaryFn(left, token.fn, this.multiplicative());
}
return left;
},
multiplicative: function () {
var left = this.unary();
var token;
while ((token = this.expect("*", "/", "%"))) {
left = this.binaryFn(left, token.fn, this.unary());
}
return left;
},
unary: function () {
var token;
if (this.expect("+")) {
return this.primary();
} else if ((token = this.expect("-"))) {
return this.binaryFn(Parser.ZERO, token.fn, this.unary());
} else if ((token = this.expect("!"))) {
return this.unaryFn(token.fn, this.unary());
} else {
return this.primary();
}
},
fieldAccess: function (object) {
var parser = this;
var field = this.expect().text;
var 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;
var indexFn = this.expression();
this.consume("]");
return extend(
function (self, locals) {
var o = obj(self, locals),
i = indexFn(self, locals),
v,
p;
if (!o) return undefined;
v = ensureSafeObject(o[i], parser.text);
if (v && v.then && parser.options.unwrapPromises) {
p = v;
if (!("$$v" in v)) {
p.$$v = undefined;
p.then(function (val) {
p.$$v = val;
});
}
v = v.$$v;
}
return v;
},
{
assign: function (self, value, locals) {
var key = indexFn(self, locals);
// prevent overwriting of Function.constructor which would break ensureSafeObject check
var safe = ensureSafeObject(obj(self, locals), parser.text);
return (safe[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) {
var args = [];
var context = contextGetter ? contextGetter(scope, locals) : scope;
for (var i = 0; i < argsFn.length; i++) {
args.push(argsFn[i](scope, locals));
}
var fnPtr = fn(scope, locals, context) || noop;
ensureSafeObject(context, parser.text);
ensureSafeObject(fnPtr, parser.text);
// IE stupidity! (IE doesn't have apply for some native functions)
var v = fnPtr.apply
? fnPtr.apply(context, args)
: fnPtr(args[0], args[1], args[2], args[3], args[4]);
return ensureSafeObject(v, parser.text);
};
},
// This is used with json array declaration
arrayDeclaration: function () {
var elementFns = [];
var allConstant = true;
if (this.peekToken().text !== "]") {
do {
var elementFn = this.expression();
elementFns.push(elementFn);
if (!elementFn.constant) {
allConstant = false;
}
} while (this.expect(","));
}
this.consume("]");
return extend(
function (self, locals) {
var array = [];
for (var i = 0; i < elementFns.length; i++) {
array.push(elementFns[i](self, locals));
}
return array;
},
{
literal: true,
constant: allConstant,
},
);
},
object: function () {
var keyValues = [];
var allConstant = true;
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 });
if (!value.constant) {
allConstant = false;
}
} while (this.expect(","));
}
this.consume("}");
return extend(
function (self, locals) {
var object = {};
for (var i = 0; i < keyValues.length; i++) {
var keyValue = keyValues[i];
object[keyValue.key] = keyValue.value(self, locals);
}
return object;
},
{
literal: true,
constant: allConstant,
},
);
},
};
//////////////////////////////////////////////////
// Parser helper functions
//////////////////////////////////////////////////
function setter(obj, path, setValue, fullExp, options) {
//needed?
options = options || {};
var element = path.split("."),
key;
for (var i = 0; element.length > 1; i++) {
key = ensureSafeMemberName(element.shift(), fullExp);
var propertyObj = obj[key];
if (!propertyObj) {
propertyObj = {};
obj[key] = propertyObj;
}
obj = propertyObj;
if (obj.then && options.unwrapPromises) {
promiseWarning(fullExp);
if (!("$$v" in obj)) {
(function (promise) {
promise.then(function (val) {
promise.$$v = val;
});
})(obj);
}
if (obj.$$v === undefined) {
obj.$$v = {};
}
obj = obj.$$v;
}
}
key = ensureSafeMemberName(element.shift(), fullExp);
obj[key] = setValue;
return setValue;
}
var getterFnCache = {};
/**
* Implementation of the "Black Hole" variant from:
* - http://jsperf.com/angularjs-parse-getter/4
* - http://jsperf.com/path-evaluation-simplified/7
*/
function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp, options) {
ensureSafeMemberName(key0, fullExp);
ensureSafeMemberName(key1, fullExp);
ensureSafeMemberName(key2, fullExp);
ensureSafeMemberName(key3, fullExp);
ensureSafeMemberName(key4, fullExp);
return !options.unwrapPromises
? function cspSafeGetter(scope, locals) {
var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope;
if (pathVal === null || pathVal === undefined) return pathVal;
pathVal = pathVal[key0];
if (!key1 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key1];
if (!key2 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key2];
if (!key3 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key3];
if (!key4 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key4];
return pathVal;
}
: function cspSafePromiseEnabledGetter(scope, locals) {
var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope,
promise;
if (pathVal === null || pathVal === undefined) return pathVal;
pathVal = pathVal[key0];
if (pathVal && pathVal.then) {
promiseWarning(fullExp);
if (!("$$v" in pathVal)) {
promise = pathVal;
promise.$$v = undefined;
promise.then(function (val) {
promise.$$v = val;
});
}
pathVal = pathVal.$$v;
}
if (!key1 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key1];
if (pathVal && pathVal.then) {
promiseWarning(fullExp);
if (!("$$v" in pathVal)) {
promise = pathVal;
promise.$$v = undefined;
promise.then(function (val) {
promise.$$v = val;
});
}
pathVal = pathVal.$$v;
}
if (!key2 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key2];
if (pathVal && pathVal.then) {
promiseWarning(fullExp);
if (!("$$v" in pathVal)) {
promise = pathVal;
promise.$$v = undefined;
promise.then(function (val) {
promise.$$v = val;
});
}
pathVal = pathVal.$$v;
}
if (!key3 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key3];
if (pathVal && pathVal.then) {
promiseWarning(fullExp);
if (!("$$v" in pathVal)) {
promise = pathVal;
promise.$$v = undefined;
promise.then(function (val) {
promise.$$v = val;
});
}
pathVal = pathVal.$$v;
}
if (!key4 || pathVal === null || pathVal === undefined)
return pathVal;
pathVal = pathVal[key4];
if (pathVal && pathVal.then) {
promiseWarning(fullExp);
if (!("$$v" in pathVal)) {
promise = pathVal;
promise.$$v = undefined;
promise.then(function (val) {
promise.$$v = val;
});
}
pathVal = pathVal.$$v;
}
return pathVal;
};
}
function getterFn(path, options, fullExp) {
// Check whether the cache has this getter already.
// We can use hasOwnProperty directly on the cache because we ensure,
// see below, that the cache never stores a path called 'hasOwnProperty'
if (getterFnCache.hasOwnProperty(path)) {
return getterFnCache[path];
}
var pathKeys = path.split("."),
pathKeysLength = pathKeys.length,
fn;
if (options.csp) {
if (pathKeysLength < 6) {
fn = cspSafeGetterFn(
pathKeys[0],
pathKeys[1],
pathKeys[2],
pathKeys[3],
pathKeys[4],
fullExp,
options,
);
} else {
fn = function (scope, locals) {
var i = 0,
val;
do {
val = cspSafeGetterFn(
pathKeys[i++],
pathKeys[i++],
pathKeys[i++],
pathKeys[i++],
pathKeys[i++],
fullExp,
options,
)(scope, locals);
locals = undefined; // clear after first iteration
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;\n" +
"l=s;\n" +
"s=" +
(index
? // we simply dereference 's' on any .dot notation
"s"
: // but if we are first then we check locals first, and if so read it first
'((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;";
/* jshint -W054 */
var evaledFnGetter = new Function("s", "k", "pw", code); // s=scope, k=locals, pw=promiseWarning
/* jshint +W054 */
evaledFnGetter.toString = function () {
return code;
};
fn = function (scope, locals) {
return evaledFnGetter(scope, locals, promiseWarning);
};
}
// Only cache the value if it's not going to mess up the cache object
// This is more performant that using Object.prototype.hasOwnProperty.call
if (path !== "hasOwnProperty") {
getterFnCache[path] = fn;
}
return fn;
}
///////////////////////////////////
/**
* @ngdoc function
* @name ng.$parse
* @function
*
* @description
*
* Converts Angular {@link guide/expression expression} into a function.
*
* <pre>
* var getter = $parse('user.name');
* var setter = getter.assign;
* var context = {user:{name:'angular'}};
* var locals = {user:{name:'local'}};
*
* expect(getter(context)).toEqual('angular');
* setter(context, 'newValue');
* expect(context.user.name).toEqual('newValue');
* expect(getter(context, locals)).toEqual('local');
* </pre>
*
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*
* The returned function also has the following properties:
* * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
* literal.
* * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
* constant literals.
* * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
* set to a function to change its value on the given context.
*
*/
/**
* @ngdoc object
* @name ng.$parseProvider
* @function
*
* @description
* `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
* service.
*/
function $ParseProvider() {
var cache = {};
var $parseOptions = {
csp: false,
unwrapPromises: false,
logPromiseWarnings: true,
};
/**
* @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
*
* @ngdoc method
* @name ng.$parseProvider#unwrapPromises
* @methodOf ng.$parseProvider
* @description
*
* **This feature is deprecated, see deprecation notes below for more info**
*
* If set to true (default is false), $parse will unwrap promises automatically when a promise is
* found at any part of the expression. In other words, if set to true, the expression will always
* result in a non-promise value.
*
* While the promise is unresolved, it's treated as undefined, but once resolved and fulfilled,
* the fulfillment value is used in place of the promise while evaluating the expression.
*
* **Deprecation notice**
*
* This is a feature that didn't prove to be wildly useful or popular, primarily because of the
* dichotomy between data access in templates (accessed as raw values) and controller code
* (accessed as promises).
*
* In most code we ended up resolving promises manually in controllers anyway and thus unifying
* the model access there.
*
* Other downsides of automatic promise unwrapping:
*
* - when building components it's often desirable to receive the raw promises
* - adds complexity and slows down expression evaluation
* - makes expression code pre-generation unattractive due to the amount of code that needs to be
* generated
* - makes IDE auto-completion and tool support hard
*
* **Warning Logs**
*
* If the unwrapping is enabled, Angular will log a warning about each expression that unwraps a
* promise (to reduce the noise, each expression is logged only once). To disable this logging use
* `$parseProvider.logPromiseWarnings(false)` api.
*
*
* @param {boolean=} value New value.
* @returns {boolean|self} Returns the current setting when used as getter and self if used as
* setter.
*/
this.unwrapPromises = function (value) {
if (isDefined(value)) {
$parseOptions.unwrapPromises = !!value;
return this;
} else {
return $parseOptions.unwrapPromises;
}
};
/**
* @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
*
* @ngdoc method
* @name ng.$parseProvider#logPromiseWarnings
* @methodOf ng.$parseProvider
* @description
*
* Controls whether Angular should log a warning on any encounter of a promise in an expression.
*
* The default is set to `true`.
*
* This setting applies only if `$parseProvider.unwrapPromises` setting is set to true as well.
*
* @param {boolean=} value New value.
* @returns {boolean|self} Returns the current setting when used as getter and self if used as
* setter.
*/
this.logPromiseWarnings = function (value) {
if (isDefined(value)) {
$parseOptions.logPromiseWarnings = value;
return this;
} else {
return $parseOptions.logPromiseWarnings;
}
};
this.$get = [
"$filter",
"$sniffer",
"$log",
function ($filter, $sniffer, $log) {
$parseOptions.csp = $sniffer.csp;
promiseWarning = function promiseWarningFn(fullExp) {
if (
!$parseOptions.logPromiseWarnings ||
promiseWarningCache.hasOwnProperty(fullExp)
)
return;
promiseWarningCache[fullExp] = true;
$log.warn(
"[$parse] Promise found in the expression `" +
fullExp +
"`. " +
"Automatic unwrapping of promises in Angular expressions is deprecated.",
);
};
return function (exp) {
var parsedExpression;
switch (typeof exp) {
case "string":
if (cache.hasOwnProperty(exp)) {
return cache[exp];
}
var lexer = new Lexer($parseOptions);
var parser = new Parser(lexer, $filter, $parseOptions);
parsedExpression = parser.parse(exp, false);
if (exp !== "hasOwnProperty") {
// Only cache the value if it's not going to mess up the cache object
// This is more performant that using Object.prototype.hasOwnProperty.call
cache[exp] = parsedExpression;
}
return parsedExpression;
case "function":
return exp;
default:
return noop;
}
};
},
];
}
/**
* @ngdoc service
* @name ng.$q
* @requires $rootScope
*
* @description
* A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
*
* [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an
* interface for interacting with an object that represents the result of an action that is
* performed asynchronously, and may or may not be finished at any given point in time.
*
* From the perspective of dealing with error handling, deferred and promise APIs are to
* asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.
*
* <pre>
* // for the purpose of this example let's assume that variables `$q` and `scope` are
* // available in the current lexical scope (they could have been injected or passed in).
*
* function asyncGreet(name) {
* var deferred = $q.defer();
*
* setTimeout(function() {
* // since this fn executes async in a future turn of the event loop, we need to wrap
* // our code into an $apply call so that the model changes are properly observed.
* scope.$apply(function() {
* deferred.notify('About to greet ' + name + '.');
*
* if (okToGreet(name)) {
* deferred.resolve('Hello, ' + name + '!');
* } else {
* deferred.reject('Greeting ' + name + ' is not allowed.');
* }
* });
* }, 1000);
*
* return deferred.promise;
* }
*
* var promise = asyncGreet('Robin Hood');
* promise.then(function(greeting) {
* alert('Success: ' + greeting);
* }, function(reason) {
* alert('Failed: ' + reason);
* }, function(update) {
* alert('Got notification: ' + update);
* });
* </pre>
*
* At first it might not be obvious why this extra complexity is worth the trouble. The payoff
* comes in the way of guarantees that promise and deferred APIs make, see
* https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md.
*
* Additionally the promise api allows for composition that is very hard to do with the
* traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.
* For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the
* section on serial or parallel joining of promises.
*
*
* # The Deferred API
*
* A new instance of deferred is constructed by calling `$q.defer()`.
*
* The purpose of the deferred object is to expose the associated Promise instance as well as APIs
* that can be used for signaling the successful or unsuccessful completion, as well as the status
* of the task.
*
* **Methods**
*
* - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection
* constructed via `$q.reject`, the promise will be rejected instead.
* - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to
* resolving it with a rejection constructed via `$q.reject`.
* - `notify(value)` - provides updates on the status of the promises execution. This may be called
* multiple times before the promise is either resolved or rejected.
*
* **Properties**
*
* - promise – `{Promise}` – promise object associated with this deferred.
*
*
* # The Promise API
*
* A new promise instance is created when a deferred instance is created and can be retrieved by
* calling `deferred.promise`.
*
* The purpose of the promise object is to allow for interested parties to get access to the result
* of the deferred task when it completes.
*
* **Methods**
*
* - `then(successCallback, errorCallback, notifyCallback)` – regardless of when the promise was or
* will be resolved or rejected, `then` calls one of the success or error callbacks asynchronously
* as soon as the result is available. The callbacks are called with a single argument: the result
* or rejection reason. Additionally, the notify callback may be called zero or more times to
* provide a progress indication, before the promise is resolved or rejected.
*
* This method *returns a new promise* which is resolved or rejected via the return value of the
* `successCallback`, `errorCallback`. It also notifies via the return value of the
* `notifyCallback` method. The promise can not be resolved or rejected from the notifyCallback
* method.
*
* - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)`
*
* - `finally(callback)` – allows you to observe either the fulfillment or rejection of a promise,
* but to do so without modifying the final value. This is useful to release resources or do some
* clean-up that needs to be done whether the promise was rejected or resolved. See the [full
* specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for
* more information.
*
* Because `finally` is a reserved word in JavaScript and reserved keywords are not supported as
* property names by ES3, you'll need to invoke the method like `promise['finally'](callback)` to
* make your code IE8 compatible.
*
* # Chaining promises
*
* Because calling the `then` method of a promise returns a new derived promise, it is easily
* possible to create a chain of promises:
*
* <pre>
* promiseB = promiseA.then(function(result) {
* return result + 1;
* });
*
* // promiseB will be resolved immediately after promiseA is resolved and its value
* // will be the result of promiseA incremented by 1
* </pre>
*
* It is possible to create chains of any length and since a promise can be resolved with another
* promise (which will defer its resolution further), it is possible to pause/defer resolution of
* the promises at any point in the chain. This makes it possible to implement powerful APIs like
* $http's response interceptors.
*
*
* # Differences between Kris Kowal's Q and $q
*
* There are two main differences:
*
* - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation
* mechanism in angular, which means faster propagation of resolution or rejection into your
* models and avoiding unnecessary browser repaints, which would result in flickering UI.
* - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains
* all the important functionality needed for common async tasks.
*
* # Testing
*
* <pre>
* it('should simulate promise', inject(function($q, $rootScope) {
* var deferred = $q.defer();
* var promise = deferred.promise;
* var resolvedValue;
*
* promise.then(function(value) { resolvedValue = value; });
* expect(resolvedValue).toBeUndefined();
*
* // Simulate resolving of promise
* deferred.resolve(123);
* // Note that the 'then' function does not get called synchronously.
* // This is because we want the promise API to always be async, whether or not
* // it got called synchronously or asynchronously.
* expect(resolvedValue).toBeUndefined();
*
* // Propagate promise resolution to 'then' functions using $apply().
* $rootScope.$apply();
* expect(resolvedValue).toEqual(123);
* }));
* </pre>
*/
function $QProvider() {
this.$get = [
"$rootScope",
"$exceptionHandler",
function ($rootScope, $exceptionHandler) {
return qFactory(function (callback) {
$rootScope.$evalAsync(callback);
}, $exceptionHandler);
},
];
}
/**
* Constructs a promise manager.
*
* @param {function(function)} nextTick Function for executing functions in the next turn.
* @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for
* debugging purposes.
* @returns {object} Promise manager.
*/
function qFactory(nextTick, exceptionHandler) {
/**
* @ngdoc
* @name ng.$q#defer
* @methodOf ng.$q
* @description
* Creates a `Deferred` object which represents a task which will finish in the future.
*
* @returns {Deferred} Returns a new instance of deferred.
*/
var defer = function () {
var pending = [],
value,
deferred;
deferred = {
resolve: function (val) {
if (pending) {
var callbacks = pending;
pending = undefined;
value = ref(val);
if (callbacks.length) {
nextTick(function () {
var callback;
for (var 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;
if (pending.length) {
nextTick(function () {
var callback;
for (var i = 0, ii = callbacks.length; i < ii; i++) {
callback = callbacks[i];
callback[2](progress);
}
});
}
}
},
promise: {
then: function (callback, errback, progressback) {
var result = defer();
var wrappedCallback = function (value) {
try {
result.resolve(
(isFunction(callback) ? callback : defaultCallback)(value),
);
} catch (e) {
result.reject(e);
exceptionHandler(e);
}
};
var wrappedErrback = function (reason) {
try {
result.resolve(
(isFunction(errback) ? errback : defaultErrback)(reason),
);
} catch (e) {
result.reject(e);
exceptionHandler(e);
}
};
var wrappedProgressback = function (progress) {
try {
result.notify(
(isFunction(progressback) ? progressback : defaultCallback)(
progress,
),
);
} catch (e) {
exceptionHandler(e);
}
};
if (pending) {
pending.push([
wrappedCallback,
wrappedErrback,
wrappedProgressback,
]);
} else {
value.then(wrappedCallback, wrappedErrback, wrappedProgressback);
}
return result.promise;
},
catch: function (callback) {
return this.then(null, callback);
},
finally: function (callback) {
function makePromise(value, resolved) {
var result = defer();
if (resolved) {
result.resolve(value);
} else {
result.reject(value);
}
return result.promise;
}
function handleCallback(value, isResolved) {
var callbackOutput = null;
try {
callbackOutput = (callback || defaultCallback)();
} catch (e) {
return makePromise(e, false);
}
if (callbackOutput && isFunction(callbackOutput.then)) {
return callbackOutput.then(
function () {
return makePromise(value, isResolved);
},
function (error) {
return makePromise(error, false);
},
);
} else {
return makePromise(value, isResolved);
}
}
return this.then(
function (value) {
return handleCallback(value, true);
},
function (error) {
return handleCallback(error, false);
},
);
},
},
};
return deferred;
};
var ref = function (value) {
if (value && isFunction(value.then)) return value;
return {
then: function (callback) {
var result = defer();
nextTick(function () {
result.resolve(callback(value));
});
return result.promise;
},
};
};
/**
* @ngdoc
* @name ng.$q#reject
* @methodOf ng.$q
* @description
* Creates a promise that is resolved as rejected with the specified `reason`. This api should be
* used to forward rejection in a chain of promises. If you are dealing with the last promise in
* a promise chain, you don't need to worry about it.
*
* When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of
* `reject` as the `throw` keyword in JavaScript. This also means that if you "catch" an error via
* a promise error callback and you want to forward the error to the promise derived from the
* current promise, you have to "rethrow" the error by returning a rejection constructed via
* `reject`.
*
* <pre>
* promiseB = promiseA.then(function(result) {
* // success: do something and resolve promiseB
* // with the old or a new result
* return result;
* }, function(reason) {
* // error: handle the error if possible and
* // resolve promiseB with newPromiseOrValue,
* // otherwise forward the rejection to promiseB
* if (canHandle(reason)) {
* // handle the error and recover
* return newPromiseOrValue;
* }
* return $q.reject(reason);
* });
* </pre>
*
* @param {*} reason Constant, message, exception or an object representing the rejection reason.
* @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`.
*/
var reject = function (reason) {
return {
then: function (callback, errback) {
var result = defer();
nextTick(function () {
try {
result.resolve(
(isFunction(errback) ? errback : defaultErrback)(reason),
);
} catch (e) {
result.reject(e);
exceptionHandler(e);
}
});
return result.promise;
},
};
};
/**
* @ngdoc
* @name ng.$q#when
* @methodOf ng.$q
* @description
* Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise.
* This is useful when you are dealing with an object that might or might not be a promise, or if
* the promise comes from a source that can't be trusted.
*
* @param {*} value Value or a promise
* @returns {Promise} Returns a promise of the passed value or promise
*/
var when = function (value, callback, errback, progressback) {
var result = defer(),
done;
var wrappedCallback = function (value) {
try {
return (isFunction(callback) ? callback : defaultCallback)(value);
} catch (e) {
exceptionHandler(e);
return reject(e);
}
};
var wrappedErrback = function (reason) {
try {
return (isFunction(errback) ? errback : defaultErrback)(reason);
} catch (e) {
exceptionHandler(e);
return reject(e);
}
};
var wrappedProgressback = function (progress) {
try {
return (isFunction(progressback) ? progressback : defaultCallback)(
progress,
);
} catch (e) {
exceptionHandler(e);
}
};
nextTick(function () {
ref(value).then(
function (value) {
if (done) return;
done = true;
result.resolve(
ref(value).then(
wrappedCallback,
wrappedErrback,
wrappedProgressback,
),
);
},
function (reason) {
if (done) return;
done = true;
result.resolve(wrappedErrback(reason));
},
function (progress) {
if (done) return;
result.notify(wrappedProgressback(progress));
},
);
});
return result.promise;
};
function defaultCallback(value) {
return value;
}
function defaultErrback(reason) {
return reject(reason);
}
/**
* @ngdoc
* @name ng.$q#all
* @methodOf ng.$q
* @description
* Combines multiple promises into a single promise that is resolved when all of the input
* promises are resolved.
*
* @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises.
* @returns {Promise} Returns a single promise that will be resolved with an array/hash of values,
* each value corresponding to the promise at the same index/key in the `promises` array/hash.
* If any of the promises is resolved with a rejection, this resulting promise will be rejected
* with the same rejection value.
*/
function all(promises) {
var deferred = defer(),
counter = 0,
results = isArray(promises) ? [] : {};
forEach(promises, function (promise, key) {
counter++;
ref(promise).then(
function (value) {
if (results.hasOwnProperty(key)) return;
results[key] = value;
if (!--counter) deferred.resolve(results);
},
function (reason) {
if (results.hasOwnProperty(key)) return;
deferred.reject(reason);
},
);
});
if (counter === 0) {
deferred.resolve(results);
}
return deferred.promise;
}
return {
defer: defer,
reject: reject,
when: when,
all: all,
};
}
/**
* DESIGN NOTES
*
* The design decisions behind the scope are heavily favored for speed and memory consumption.
*
* The typical use of scope is to watch the expressions, which most of the time return the same
* value as last time so we optimize the operation.
*
* Closures construction is expensive in terms of speed as well as memory:
* - No closures, instead use prototypical inheritance for API
* - Internal state needs to be stored on scope directly, which means that private state is
* exposed as $$____ properties
*
* Loop operations are optimized by using while(count--) { ... }
* - this means that in order to keep the same order of execution as addition we have to add
* items to the array at the beginning (shift) instead of at the end (push)
*
* Child scopes are created and removed often
* - Using an array would be slow since inserts in middle are expensive so we use linked list
*
* There are few watches then a lot of observers. This is why you don't want the observer to be
* implemented in the same way as watch. Watch requires return of initialization function which
* are expensive to construct.
*/
/**
* @ngdoc object
* @name ng.$rootScopeProvider
* @description
*
* Provider for the $rootScope service.
*/
/**
* @ngdoc function
* @name ng.$rootScopeProvider#digestTtl
* @methodOf ng.$rootScopeProvider
* @description
*
* Sets the number of `$digest` iterations the scope should attempt to execute before giving up and
* assuming that the model is unstable.
*
* The current default is 10 iterations.
*
* In complex applications it's possible that the dependencies between `$watch`s will result in
* several digest iterations. However if an application needs more than the default 10 digest
* iterations for its model to stabilize then you should investigate what is causing the model to
* continuously change during the digest.
*
* Increasing the TTL could have performance implications, so you should not change it without
* proper justification.
*
* @param {number} limit The number of digest iterations.
*/
/**
* @ngdoc object
* @name ng.$rootScope
* @description
*
* Every application has a single root {@link ng.$rootScope.Scope scope}.
* All other scopes are descendant scopes of the root scope. Scopes provide separation
* between the model and the view, via a mechanism for watching the model for changes.
* They also provide an event emission/broadcast and subscription facility. See the
* {@link guide/scope developer guide on scopes}.
*/
function $RootScopeProvider() {
var TTL = 10;
var $rootScopeMinErr = minErr("$rootScope");
var lastDirtyWatch = null;
this.digestTtl = function (value) {
if (arguments.length) {
TTL = value;
}
return TTL;
};
this.$get = [
"$injector",
"$exceptionHandler",
"$parse",
"$browser",
function ($injector, $exceptionHandler, $parse, $browser) {
/**
* @ngdoc function
* @name ng.$rootScope.Scope
*
* @description
* A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the
* {@link AUTO.$injector $injector}. Child scopes are created using the
* {@link ng.$rootScope.Scope#methods_$new $new()} method. (Most scopes are created automatically when
* compiled HTML template is executed.)
*
* Here is a simple scope snippet to show how you can interact with the scope.
* <pre>
* <file src="./test/ng/rootScopeSpec.js" tag="docs1" />
* </pre>
*
* # Inheritance
* A scope can inherit from a parent scope, as in this example:
* <pre>
var parent = $rootScope;
var child = parent.$new();
parent.salutation = "Hello";
child.name = "World";
expect(child.salutation).toEqual('Hello');
child.salutation = "Welcome";
expect(child.salutation).toEqual('Welcome');
expect(parent.salutation).toEqual('Hello');
* </pre>
*
*
* @param {Object.<string, function()>=} providers Map of service factory which need to be
* provided for the current scope. Defaults to {@link ng}.
* @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
* append/override services provided by `providers`. This is handy
* when unit-testing and having the need to override a default
* service.
* @returns {Object} Newly created scope.
*
*/
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 = false;
this.$$asyncQueue = [];
this.$$postDigestQueue = [];
this.$$listeners = {};
this.$$isolateBindings = {};
}
/**
* @ngdoc property
* @name ng.$rootScope.Scope#$id
* @propertyOf ng.$rootScope.Scope
* @returns {number} Unique scope ID (monotonically increasing alphanumeric sequence) useful for
* debugging.
*/
Scope.prototype = {
constructor: Scope,
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$new
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Creates a new child {@link ng.$rootScope.Scope scope}.
*
* The parent scope will propagate the {@link ng.$rootScope.Scope#methods_$digest $digest()} and
* {@link ng.$rootScope.Scope#methods_$digest $digest()} events. The scope can be removed from the
* scope hierarchy using {@link ng.$rootScope.Scope#methods_$destroy $destroy()}.
*
* {@link ng.$rootScope.Scope#methods_$destroy $destroy()} must be called on a scope when it is
* desired for the scope and its child scopes to be permanently detached from the parent and
* thus stop participating in model change detection and listener notification by invoking.
*
* @param {boolean} isolate If true, then the scope does not prototypically inherit from the
* parent scope. The scope is isolated, as it can not see parent scope properties.
* When creating widgets, it is useful for the widget to not accidentally read parent
* state.
*
* @returns {Object} The newly created child scope.
*
*/
$new: function (isolate) {
var ChildScope, child;
if (isolate) {
child = new Scope();
child.$root = this.$root;
// ensure that there is just one async queue per $rootScope and its children
child.$$asyncQueue = this.$$asyncQueue;
child.$$postDigestQueue = this.$$postDigestQueue;
} else {
ChildScope = function () {}; // should be anonymous; This is so that when the minifier munges
// the name it does not become random set of chars. This will then show up as class
// name in the debugger.
ChildScope.prototype = this;
child = new ChildScope();
child.$id = nextUid();
}
child["this"] = child;
child.$$listeners = {};
child.$parent = this;
child.$$watchers =
child.$$nextSibling =
child.$$childHead =
child.$$childTail =
null;
child.$$prevSibling = this.$$childTail;
if (this.$$childHead) {
this.$$childTail.$$nextSibling = child;
this.$$childTail = child;
} else {
this.$$childHead = this.$$childTail = child;
}
return child;
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$watch
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Registers a `listener` callback to be executed whenever the `watchExpression` changes.
*
* - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#methods_$digest
* $digest()} and should return the value that will be watched. (Since
* {@link ng.$rootScope.Scope#methods_$digest $digest()} reruns when it detects changes the
* `watchExpression` can execute multiple times per
* {@link ng.$rootScope.Scope#methods_$digest $digest()} and should be idempotent.)
* - The `listener` is called only when the value from the current `watchExpression` and the
* previous call to `watchExpression` are not equal (with the exception of the initial run,
* see below). The inequality is determined according to
* {@link angular.equals} function. To save the value of the object for later comparison,
* the {@link angular.copy} function is used. It also means that watching complex options
* will have adverse memory and performance implications.
* - The watch `listener` may change the model, which may trigger other `listener`s to fire.
* This is achieved by rerunning the watchers until no changes are detected. The rerun
* iteration limit is 10 to prevent an infinite loop deadlock.
*
*
* If you want to be notified whenever {@link ng.$rootScope.Scope#methods_$digest $digest} is called,
* you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
* can execute multiple times per {@link ng.$rootScope.Scope#methods_$digest $digest} cycle when a
* change is detected, be prepared for multiple calls to your listener.)
*
* After a watcher is registered with the scope, the `listener` fn is called asynchronously
* (via {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync}) to initialize the
* watcher. In rare cases, this is undesirable because the listener is called when the result
* of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
* can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
* listener was called due to initialization.
*
* The example below contains an illustration of using a function as your $watch listener
*
*
* # Example
* <pre>
// let's assume that scope was dependency injected as the $rootScope
var scope = $rootScope;
scope.name = 'misko';
scope.counter = 0;
expect(scope.counter).toEqual(0);
scope.$watch('name', function(newValue, oldValue) {
scope.counter = scope.counter + 1;
});
expect(scope.counter).toEqual(0);
scope.$digest();
// no variable change
expect(scope.counter).toEqual(0);
scope.name = 'adam';
scope.$digest();
expect(scope.counter).toEqual(1);
// Using a listener function
var food;
scope.foodCounter = 0;
expect(scope.foodCounter).toEqual(0);
scope.$watch(
// This is the listener function
function() { return food; },
// This is the change handler
function(newValue, oldValue) {
if ( newValue !== oldValue ) {
// Only increment the counter if the value changed
scope.foodCounter = scope.foodCounter + 1;
}
}
);
// No digest has been run so the counter will be zero
expect(scope.foodCounter).toEqual(0);
// Run the digest but since food has not changed cout will still be zero
scope.$digest();
expect(scope.foodCounter).toEqual(0);
// Update food and run digest. Now the counter will increment
food = 'cheeseburger';
scope.$digest();
expect(scope.foodCounter).toEqual(1);
* </pre>
*
*
*
* @param {(function()|string)} watchExpression Expression that is evaluated on each
* {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. A change in the return value triggers
* a call to the `listener`.
*
* - `string`: Evaluated as {@link guide/expression expression}
* - `function(scope)`: called with current `scope` as a parameter.
* @param {(function()|string)=} listener Callback called whenever the return value of
* the `watchExpression` changes.
*
* - `string`: Evaluated as {@link guide/expression expression}
* - `function(newValue, oldValue, scope)`: called with current and previous values as
* parameters.
*
* @param {boolean=} objectEquality Compare object for equality rather than for reference.
* @returns {function()} Returns a deregistration function for this listener.
*/
$watch: function (watchExp, listener, objectEquality) {
var scope = this,
get = compileToFn(watchExp, "watch"),
array = scope.$$watchers,
watcher = {
fn: listener,
last: initWatchVal,
get: get,
exp: watchExp,
eq: !!objectEquality,
};
lastDirtyWatch = null;
// in the case user pass string, we need to compile it, do we really need this ?
if (!isFunction(listener)) {
var listenFn = compileToFn(listener || noop, "listener");
watcher.fn = function (newVal, oldVal, scope) {
listenFn(scope);
};
}
if (typeof watchExp == "string" && get.constant) {
var originalFn = watcher.fn;
watcher.fn = function (newVal, oldVal, scope) {
originalFn.call(this, newVal, oldVal, scope);
arrayRemove(array, watcher);
};
}
if (!array) {
array = scope.$$watchers = [];
}
// we use unshift since we use a while loop in $digest for speed.
// the while loop reads in reverse order.
array.unshift(watcher);
return function () {
arrayRemove(array, watcher);
};
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$watchCollection
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Shallow watches the properties of an object and fires whenever any of the properties change
* (for arrays, this implies watching the array items; for object maps, this implies watching
* the properties). If a change is detected, the `listener` callback is fired.
*
* - The `obj` collection is observed via standard $watch operation and is examined on every
* call to $digest() to see if any items have been added, removed, or moved.
* - The `listener` is called whenever anything within the `obj` has changed. Examples include
* adding, removing, and moving items belonging to an object or array.
*
*
* # Example
* <pre>
$scope.names = ['igor', 'matias', 'misko', 'james'];
$scope.dataCount = 4;
$scope.$watchCollection('names', function(newNames, oldNames) {
$scope.dataCount = newNames.length;
});
expect($scope.dataCount).toEqual(4);
$scope.$digest();
//still at 4 ... no changes
expect($scope.dataCount).toEqual(4);
$scope.names.pop();
$scope.$digest();
//now there's been a change
expect($scope.dataCount).toEqual(3);
* </pre>
*
*
* @param {string|Function(scope)} obj Evaluated as {@link guide/expression expression}. The
* expression value should evaluate to an object or an array which is observed on each
* {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. Any shallow change within the
* collection will trigger a call to the `listener`.
*
* @param {function(newCollection, oldCollection, scope)} listener a callback function that is
* fired with both the `newCollection` and `oldCollection` as parameters.
* The `newCollection` object is the newly modified data obtained from the `obj` expression
* and the `oldCollection` object is a copy of the former collection data.
* The `scope` refers to the current scope.
*
* @returns {function()} Returns a de-registration function for this listener. When the
* de-registration function is executed, the internal watch operation is terminated.
*/
$watchCollection: function (obj, listener) {
var self = this;
var oldValue;
var newValue;
var changeDetected = 0;
var objGetter = $parse(obj);
var internalArray = [];
var internalObject = {};
var oldLength = 0;
function $watchCollectionWatch() {
newValue = objGetter(self);
var newLength, key;
if (!isObject(newValue)) {
if (oldValue !== newValue) {
oldValue = newValue;
changeDetected++;
}
} else if (isArrayLike(newValue)) {
if (oldValue !== internalArray) {
// we are transitioning from something which was not an array into array.
oldValue = internalArray;
oldLength = oldValue.length = 0;
changeDetected++;
}
newLength = newValue.length;
if (oldLength !== newLength) {
// if lengths do not match we need to trigger change notification
changeDetected++;
oldValue.length = oldLength = newLength;
}
// copy the items to oldValue and look for changes.
for (var i = 0; i < newLength; i++) {
if (oldValue[i] !== newValue[i]) {
changeDetected++;
oldValue[i] = newValue[i];
}
}
} else {
if (oldValue !== internalObject) {
// we are transitioning from something which was not an object into object.
oldValue = internalObject = {};
oldLength = 0;
changeDetected++;
}
// copy the items to oldValue and look for changes.
newLength = 0;
for (key in newValue) {
if (newValue.hasOwnProperty(key)) {
newLength++;
if (oldValue.hasOwnProperty(key)) {
if (oldValue[key] !== newValue[key]) {
changeDetected++;
oldValue[key] = newValue[key];
}
} else {
oldLength++;
oldValue[key] = newValue[key];
changeDetected++;
}
}
}
if (oldLength > newLength) {
// we used to have more keys, need to find them and destroy them.
changeDetected++;
for (key in oldValue) {
if (
oldValue.hasOwnProperty(key) &&
!newValue.hasOwnProperty(key)
) {
oldLength--;
delete oldValue[key];
}
}
}
}
return changeDetected;
}
function $watchCollectionAction() {
listener(newValue, oldValue, self);
}
return this.$watch($watchCollectionWatch, $watchCollectionAction);
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$digest
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and
* its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change
* the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
* until no more listeners are firing. This means that it is possible to get into an infinite
* loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
* iterations exceeds 10.
*
* Usually, you don't call `$digest()` directly in
* {@link ng.directive:ngController controllers} or in
* {@link ng.$compileProvider#methods_directive directives}.
* Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within
* a {@link ng.$compileProvider#methods_directive directives}), which will force a `$digest()`.
*
* If you want to be notified whenever `$digest()` is called,
* you can register a `watchExpression` function with
* {@link ng.$rootScope.Scope#methods_$watch $watch()} with no `listener`.
*
* In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
*
* # Example
* <pre>
var scope = ...;
scope.name = 'misko';
scope.counter = 0;
expect(scope.counter).toEqual(0);
scope.$watch('name', function(newValue, oldValue) {
scope.counter = scope.counter + 1;
});
expect(scope.counter).toEqual(0);
scope.$digest();
// no variable change
expect(scope.counter).toEqual(0);
scope.name = 'adam';
scope.$digest();
expect(scope.counter).toEqual(1);
* </pre>
*
*/
$digest: function () {
var watch,
value,
last,
watchers,
asyncQueue = this.$$asyncQueue,
postDigestQueue = this.$$postDigestQueue,
length,
dirty,
ttl = TTL,
next,
current,
target = this,
watchLog = [],
logIdx,
logMsg,
asyncTask;
beginPhase("$digest");
lastDirtyWatch = null;
do {
// "while dirty" loop
dirty = false;
current = target;
while (asyncQueue.length) {
try {
asyncTask = asyncQueue.shift();
asyncTask.scope.$eval(asyncTask.expression);
} catch (e) {
clearPhase();
$exceptionHandler(e);
}
lastDirtyWatch = null;
}
traverseScopesLoop: do {
// "traverse the scopes" loop
if ((watchers = current.$$watchers)) {
// process our watches
length = watchers.length;
while (length--) {
try {
watch = watchers[length];
// Most common watches are on primitives, in which case we can short
// circuit it with === operator, only when === fails do we use .equals
if (watch) {
if (
(value = watch.get(current)) !==
(last = watch.last) &&
!(watch.eq
? equals(value, last)
: typeof value == "number" &&
typeof last == "number" &&
isNaN(value) &&
isNaN(last))
) {
dirty = true;
lastDirtyWatch = watch;
watch.last = watch.eq ? copy(value) : value;
watch.fn(
value,
last === initWatchVal ? value : last,
current,
);
if (ttl < 5) {
logIdx = 4 - ttl;
if (!watchLog[logIdx]) 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);
}
} else if (watch === lastDirtyWatch) {
// If the most recently dirty watcher is now clean, short circuit since the remaining watchers
// have already been tested.
dirty = false;
break traverseScopesLoop;
}
}
} catch (e) {
clearPhase();
$exceptionHandler(e);
}
}
}
// Insanity Warning: scope depth-first traversal
// yes, this code is a bit crazy, but it works and we have tests to prove it!
// this piece should be kept in sync with the traversal in $broadcast
if (
!(next =
current.$$childHead ||
(current !== target && current.$$nextSibling))
) {
while (
current !== target &&
!(next = current.$$nextSibling)
) {
current = current.$parent;
}
}
} while ((current = next));
// `break traverseScopesLoop;` takes us to here
if (dirty && !ttl--) {
clearPhase();
throw $rootScopeMinErr(
"infdig",
"{0} $digest() iterations reached. Aborting!\n" +
"Watchers fired in the last 5 iterations: {1}",
TTL,
toJson(watchLog),
);
}
} while (dirty || asyncQueue.length);
clearPhase();
while (postDigestQueue.length) {
try {
postDigestQueue.shift()();
} catch (e) {
$exceptionHandler(e);
}
}
},
/**
* @ngdoc event
* @name ng.$rootScope.Scope#$destroy
* @eventOf ng.$rootScope.Scope
* @eventType broadcast on scope being destroyed
*
* @description
* Broadcasted when a scope and its children are being destroyed.
*
* Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
* clean up DOM bindings before an element is removed from the DOM.
*/
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$destroy
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Removes the current scope (and all of its children) from the parent scope. Removal implies
* that calls to {@link ng.$rootScope.Scope#methods_$digest $digest()} will no longer
* propagate to the current scope and its children. Removal also implies that the current
* scope is eligible for garbage collection.
*
* The `$destroy()` is usually used by directives such as
* {@link ng.directive:ngRepeat ngRepeat} for managing the
* unrolling of the loop.
*
* Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope.
* Application code can register a `$destroy` event handler that will give it a chance to
* perform any necessary cleanup.
*
* Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
* clean up DOM bindings before an element is removed from the DOM.
*/
$destroy: function () {
// we can't destroy the root scope or a scope that has been already destroyed
if (this.$$destroyed) return;
var parent = this.$parent;
this.$broadcast("$destroy");
this.$$destroyed = true;
if (this === $rootScope) return;
if (parent.$$childHead == this)
parent.$$childHead = this.$$nextSibling;
if (parent.$$childTail == this)
parent.$$childTail = this.$$prevSibling;
if (this.$$prevSibling)
this.$$prevSibling.$$nextSibling = this.$$nextSibling;
if (this.$$nextSibling)
this.$$nextSibling.$$prevSibling = this.$$prevSibling;
// This is bogus code that works around Chrome's GC leak
// see: https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
this.$parent =
this.$$nextSibling =
this.$$prevSibling =
this.$$childHead =
this.$$childTail =
null;
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$eval
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Executes the `expression` on the current scope and returns the result. Any exceptions in
* the expression are propagated (uncaught). This is useful when evaluating Angular
* expressions.
*
* # Example
* <pre>
var scope = ng.$rootScope.Scope();
scope.a = 1;
scope.b = 2;
expect(scope.$eval('a+b')).toEqual(3);
expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
* </pre>
*
* @param {(string|function())=} expression An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with the current `scope` parameter.
*
* @param {(object)=} locals Local variables object, useful for overriding values in scope.
* @returns {*} The result of evaluating the expression.
*/
$eval: function (expr, locals) {
return $parse(expr)(this, locals);
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$evalAsync
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Executes the expression on the current scope at a later point in time.
*
* The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only
* that:
*
* - it will execute after the function that scheduled the evaluation (preferably before DOM
* rendering).
* - at least one {@link ng.$rootScope.Scope#methods_$digest $digest cycle} will be performed after
* `expression` execution.
*
* Any exceptions from the execution of the expression are forwarded to the
* {@link ng.$exceptionHandler $exceptionHandler} service.
*
* __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle
* will be scheduled. However, it is encouraged to always call code that changes the model
* from within an `$apply` call. That includes code evaluated via `$evalAsync`.
*
* @param {(string|function())=} expression An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with the current `scope` parameter.
*
*/
$evalAsync: function (expr) {
// if we are outside of an $digest loop and this is the first time we are scheduling async
// task also schedule async auto-flush
if (!$rootScope.$$phase && !$rootScope.$$asyncQueue.length) {
$browser.defer(function () {
if ($rootScope.$$asyncQueue.length) {
$rootScope.$digest();
}
});
}
this.$$asyncQueue.push({ scope: this, expression: expr });
},
$$postDigest: function (fn) {
this.$$postDigestQueue.push(fn);
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$apply
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* `$apply()` is used to execute an expression in angular from outside of the angular
* framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
* Because we are calling into the angular framework we need to perform proper scope life
* cycle of {@link ng.$exceptionHandler exception handling},
* {@link ng.$rootScope.Scope#methods_$digest executing watches}.
*
* ## Life cycle
*
* # Pseudo-Code of `$apply()`
* <pre>
function $apply(expr) {
try {
return $eval(expr);
} catch (e) {
$exceptionHandler(e);
} finally {
$root.$digest();
}
}
* </pre>
*
*
* Scope's `$apply()` method transitions through the following stages:
*
* 1. The {@link guide/expression expression} is executed using the
* {@link ng.$rootScope.Scope#methods_$eval $eval()} method.
* 2. Any exceptions from the execution of the expression are forwarded to the
* {@link ng.$exceptionHandler $exceptionHandler} service.
* 3. The {@link ng.$rootScope.Scope#methods_$watch watch} listeners are fired immediately after the
* expression was executed using the {@link ng.$rootScope.Scope#methods_$digest $digest()} method.
*
*
* @param {(string|function())=} exp An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with current `scope` parameter.
*
* @returns {*} The result of evaluating the expression.
*/
$apply: function (expr) {
try {
beginPhase("$apply");
return this.$eval(expr);
} catch (e) {
$exceptionHandler(e);
} finally {
clearPhase();
try {
$rootScope.$digest();
} catch (e) {
$exceptionHandler(e);
throw e;
}
}
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$on
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Listens on events of a given type. See {@link ng.$rootScope.Scope#methods_$emit $emit} for
* discussion of event life cycle.
*
* The event listener function format is: `function(event, args...)`. The `event` object
* passed into the listener has the following attributes:
*
* - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or
* `$broadcast`-ed.
* - `currentScope` - `{Scope}`: the current scope which is handling the event.
* - `name` - `{string}`: name of the event.
* - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel
* further event propagation (available only for events that were `$emit`-ed).
* - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag
* to true.
* - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
*
* @param {string} name Event name to listen on.
* @param {function(event, args...)} listener Function to call when the event is emitted.
* @returns {function()} Returns a deregistration function for this listener.
*/
$on: function (name, listener) {
var namedListeners = this.$$listeners[name];
if (!namedListeners) {
this.$$listeners[name] = namedListeners = [];
}
namedListeners.push(listener);
return function () {
namedListeners[indexOf(namedListeners, listener)] = null;
};
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$emit
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Dispatches an event `name` upwards through the scope hierarchy notifying the
* registered {@link ng.$rootScope.Scope#methods_$on} listeners.
*
* The event life cycle starts at the scope on which `$emit` was called. All
* {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
* notified. Afterwards, the event traverses upwards toward the root scope and calls all
* registered listeners along the way. The event will stop propagating if one of the listeners
* cancels it.
*
* Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
* onto the {@link ng.$exceptionHandler $exceptionHandler} service.
*
* @param {string} name Event name to emit.
* @param {...*} args Optional set of arguments which will be passed onto the event listeners.
* @return {Object} Event object (see {@link ng.$rootScope.Scope#methods_$on}).
*/
$emit: function (name, args) {
var empty = [],
namedListeners,
scope = this,
stopPropagation = false,
event = {
name: name,
targetScope: scope,
stopPropagation: function () {
stopPropagation = true;
},
preventDefault: function () {
event.defaultPrevented = true;
},
defaultPrevented: false,
},
listenerArgs = concat([event], arguments, 1),
i,
length;
do {
namedListeners = scope.$$listeners[name] || empty;
event.currentScope = scope;
for (i = 0, length = namedListeners.length; i < length; i++) {
// if listeners were deregistered, defragment the array
if (!namedListeners[i]) {
namedListeners.splice(i, 1);
i--;
length--;
continue;
}
try {
//allow all listeners attached to the current scope to run
namedListeners[i].apply(null, listenerArgs);
} catch (e) {
$exceptionHandler(e);
}
}
//if any listener on the current scope stops propagation, prevent bubbling
if (stopPropagation) return event;
//traverse upwards
scope = scope.$parent;
} while (scope);
return event;
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$broadcast
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Dispatches an event `name` downwards to all child scopes (and their children) notifying the
* registered {@link ng.$rootScope.Scope#methods_$on} listeners.
*
* The event life cycle starts at the scope on which `$broadcast` was called. All
* {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
* notified. Afterwards, the event propagates to all direct and indirect scopes of the current
* scope and calls all registered listeners along the way. The event cannot be canceled.
*
* Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
* onto the {@link ng.$exceptionHandler $exceptionHandler} service.
*
* @param {string} name Event name to broadcast.
* @param {...*} args Optional set of arguments which will be passed onto the event listeners.
* @return {Object} Event object, see {@link ng.$rootScope.Scope#methods_$on}
*/
$broadcast: function (name, args) {
var target = this,
current = target,
next = target,
event = {
name: name,
targetScope: target,
preventDefault: function () {
event.defaultPrevented = true;
},
defaultPrevented: false,
},
listenerArgs = concat([event], arguments, 1),
listeners,
i,
length;
//down while you can, then up and next sibling or up and next sibling until back at root
do {
current = next;
event.currentScope = current;
listeners = current.$$listeners[name] || [];
for (i = 0, length = listeners.length; i < length; i++) {
// if listeners were deregistered, defragment the array
if (!listeners[i]) {
listeners.splice(i, 1);
i--;
length--;
continue;
}
try {
listeners[i].apply(null, listenerArgs);
} catch (e) {
$exceptionHandler(e);
}
}
// Insanity Warning: scope depth-first traversal
// yes, this code is a bit crazy, but it works and we have tests to prove it!
// this piece should be kept in sync with the traversal in $digest
if (
!(next =
current.$$childHead ||
(current !== target && current.$$nextSibling))
) {
while (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);
assertArgFn(fn, name);
return fn;
}
/**
* function used as an initial value for watchers.
* because it's unique we can easily tell it apart from other values
*/
function initWatchVal() {}
},
];
}
/**
* @description
* Private service to sanitize uris for links and images. Used by $compile and $sanitize.
*/
function $$SanitizeUriProvider() {
var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/,
imgSrcSanitizationWhitelist = /^\s*(https?|ftp|file):|data:image\//;
/**
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during a[href] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to a[href] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/
this.aHrefSanitizationWhitelist = function (regexp) {
if (isDefined(regexp)) {
aHrefSanitizationWhitelist = regexp;
return this;
}
return aHrefSanitizationWhitelist;
};
/**
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during img[src] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to img[src] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/
this.imgSrcSanitizationWhitelist = function (regexp) {
if (isDefined(regexp)) {
imgSrcSanitizationWhitelist = regexp;
return this;
}
return imgSrcSanitizationWhitelist;
};
this.$get = function () {
return function sanitizeUri(uri, isImage) {
var regex = isImage
? imgSrcSanitizationWhitelist
: aHrefSanitizationWhitelist;
var normalizedVal;
// NOTE: urlResolve() doesn't support IE < 8 so we don't sanitize for that case.
if (!msie || msie >= 8) {
normalizedVal = urlResolve(uri).href;
if (normalizedVal !== "" && !normalizedVal.match(regex)) {
return "unsafe:" + normalizedVal;
}
}
return uri;
};
};
}
var $sceMinErr = minErr("$sce");
var SCE_CONTEXTS = {
HTML: "html",
CSS: "css",
URL: "url",
// RESOURCE_URL is a subtype of URL used in contexts where a privileged resource is sourced from a
// url. (e.g. ng-include, script src, templateUrl)
RESOURCE_URL: "resourceUrl",
JS: "js",
};
// Helper functions follow.
// Copied from:
// http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962
// Prereq: s is a string.
function escapeForRegexp(s) {
return s
.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1")
.replace(/\x08/g, "\\x08");
}
function adjustMatcher(matcher) {
if (matcher === "self") {
return matcher;
} else if (isString(matcher)) {
// Strings match exactly except for 2 wildcards - '*' and '**'.
// '*' matches any character except those from the set ':/.?&'.
// '**' matches any character (like .* in a RegExp).
// More than 2 *'s raises an error as it's ill defined.
if (matcher.indexOf("***") > -1) {
throw $sceMinErr(
"iwcard",
"Illegal sequence *** in string matcher. String: {0}",
matcher,
);
}
matcher = escapeForRegexp(matcher)
.replace("\\*\\*", ".*")
.replace("\\*", "[^:/.?&;]*");
return new RegExp("^" + matcher + "$");
} else if (isRegExp(matcher)) {
// The only other type of matcher allowed is a Regexp.
// Match entire URL / disallow partial matches.
// Flags are reset (i.e. no global, ignoreCase or multiline)
return new RegExp("^" + matcher.source + "$");
} else {
throw $sceMinErr(
"imatcher",
'Matchers may only be "self", string patterns or RegExp objects',
);
}
}
function adjustMatchers(matchers) {
var adjustedMatchers = [];
if (isDefined(matchers)) {
forEach(matchers, function (matcher) {
adjustedMatchers.push(adjustMatcher(matcher));
});
}
return adjustedMatchers;
}
/**
* @ngdoc service
* @name ng.$sceDelegate
* @function
*
* @description
*
* `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
* Contextual Escaping (SCE)} services to AngularJS.
*
* Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
* the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS. This is
* because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
* override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
* work because `$sce` delegates to `$sceDelegate` for these operations.
*
* Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
*
* The default instance of `$sceDelegate` should work out of the box with little pain. While you
* can override it completely to change the behavior of `$sce`, the common case would
* involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
* your own whitelists and blacklists for trusting URLs used for loading AngularJS resources such as
* templates. Refer {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist
* $sceDelegateProvider.resourceUrlWhitelist} and {@link
* ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
*/
/**
* @ngdoc object
* @name ng.$sceDelegateProvider
* @description
*
* The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
* $sceDelegate} service. This allows one to get/set the whitelists and blacklists used to ensure
* that the URLs used for sourcing Angular templates are safe. Refer {@link
* ng.$sceDelegateProvider#methods_resourceUrlWhitelist $sceDelegateProvider.resourceUrlWhitelist} and
* {@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
*
* For the general details about this service in Angular, read the main page for {@link ng.$sce
* Strict Contextual Escaping (SCE)}.
*
* **Example**: Consider the following case. <a name="example"></a>
*
* - your app is hosted at url `http://myapp.example.com/`
* - but some of your templates are hosted on other domains you control such as
* `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc.
* - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
*
* Here is what a secure configuration for this scenario might look like:
*
* <pre class="prettyprint">
* angular.module('myApp', []).config(function($sceDelegateProvider) {
* $sceDelegateProvider.resourceUrlWhitelist([
* // Allow same origin resource loads.
* 'self',
* // Allow loading from our assets domain. Notice the difference between * and **.
* 'http://srv*.assets.example.com/**']);
*
* // The blacklist overrides the whitelist so the open redirect here is blocked.
* $sceDelegateProvider.resourceUrlBlacklist([
* 'http://myapp.example.com/clickThru**']);
* });
* </pre>
*/
function $SceDelegateProvider() {
this.SCE_CONTEXTS = SCE_CONTEXTS;
// Resource URLs can also be trusted by policy.
var resourceUrlWhitelist = ["self"],
resourceUrlBlacklist = [];
/**
* @ngdoc function
* @name ng.sceDelegateProvider#resourceUrlWhitelist
* @methodOf ng.$sceDelegateProvider
* @function
*
* @param {Array=} whitelist When provided, replaces the resourceUrlWhitelist with the value
* provided. This must be an array or null. A snapshot of this array is used so further
* changes to the array are ignored.
*
* Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
* allowed in this array.
*
* Note: **an empty whitelist array will block all URLs**!
*
* @return {Array} the currently set whitelist array.
*
* The **default value** when no whitelist has been explicitly set is `['self']` allowing only
* same origin resource requests.
*
* @description
* Sets/Gets the whitelist of trusted resource URLs.
*/
this.resourceUrlWhitelist = function (value) {
if (arguments.length) {
resourceUrlWhitelist = adjustMatchers(value);
}
return resourceUrlWhitelist;
};
/**
* @ngdoc function
* @name ng.sceDelegateProvider#resourceUrlBlacklist
* @methodOf ng.$sceDelegateProvider
* @function
*
* @param {Array=} blacklist When provided, replaces the resourceUrlBlacklist with the value
* provided. This must be an array or null. A snapshot of this array is used so further
* changes to the array are ignored.
*
* Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
* allowed in this array.
*
* The typical usage for the blacklist is to **block
* [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
* these would otherwise be trusted but actually return content from the redirected domain.
*
* Finally, **the blacklist overrides the whitelist** and has the final say.
*
* @return {Array} the currently set blacklist array.
*
* The **default value** when no whitelist has been explicitly set is the empty array (i.e. there
* is no blacklist.)
*
* @description
* Sets/Gets the blacklist of trusted resource URLs.
*/
this.resourceUrlBlacklist = function (value) {
if (arguments.length) {
resourceUrlBlacklist = adjustMatchers(value);
}
return resourceUrlBlacklist;
};
this.$get = [
"$injector",
function ($injector) {
var htmlSanitizer = function htmlSanitizer(html) {
throw $sceMinErr(
"unsafe",
"Attempting to use an unsafe value in a safe context.",
);
};
if ($injector.has("$sanitize")) {
htmlSanitizer = $injector.get("$sanitize");
}
function matchUrl(matcher, parsedUrl) {
if (matcher === "self") {
return urlIsSameOrigin(parsedUrl);
} else {
// definitely a regex. See adjustMatchers()
return !!matcher.exec(parsedUrl.href);
}
}
function isResourceUrlAllowedByPolicy(url) {
var parsedUrl = urlResolve(url.toString());
var i,
n,
allowed = false;
// Ensure that at least one item from the whitelist allows this url.
for (i = 0, n = resourceUrlWhitelist.length; i < n; i++) {
if (matchUrl(resourceUrlWhitelist[i], parsedUrl)) {
allowed = true;
break;
}
}
if (allowed) {
// Ensure that no item from the blacklist blocked this url.
for (i = 0, n = resourceUrlBlacklist.length; i < n; i++) {
if (matchUrl(resourceUrlBlacklist[i], parsedUrl)) {
allowed = false;
break;
}
}
}
return allowed;
}
function generateHolderType(Base) {
var holderType = function TrustedValueHolderType(trustedValue) {
this.$$unwrapTrustedValue = function () {
return trustedValue;
};
};
if (Base) {
holderType.prototype = new Base();
}
holderType.prototype.valueOf = function sceValueOf() {
return this.$$unwrapTrustedValue();
};
holderType.prototype.toString = function sceToString() {
return this.$$unwrapTrustedValue().toString();
};
return holderType;
}
var trustedValueHolderBase = generateHolderType(),
byType = {};
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],
);
/**
* @ngdoc method
* @name ng.$sceDelegate#trustAs
* @methodOf ng.$sceDelegate
*
* @description
* Returns an object that is trusted by angular for use in specified strict
* contextual escaping contexts (such as ng-html-bind-unsafe, ng-include, any src
* attribute interpolation, any dom event binding attribute interpolation
* such as for onclick, etc.) that uses the provided value.
* See {@link ng.$sce $sce} for enabling strict contextual escaping.
*
* @param {string} type The kind of context in which this value is safe for use. e.g. url,
* resourceUrl, html, js and css.
* @param {*} value The value that that should be considered trusted/safe.
* @returns {*} A value that can be used to stand in for the provided `value` in places
* where Angular expects a $sce.trustAs() return value.
*/
function trustAs(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 (
trustedValue === null ||
trustedValue === undefined ||
trustedValue === ""
) {
return trustedValue;
}
// All the current contexts in SCE_CONTEXTS happen to be strings. In order to avoid trusting
// mutable objects, we ensure here that the value passed in is actually a string.
if (typeof trustedValue !== "string") {
throw $sceMinErr(
"itype",
"Attempted to trust a non-string value in a content requiring a string: Context: {0}",
type,
);
}
return new Constructor(trustedValue);
}
/**
* @ngdoc method
* @name ng.$sceDelegate#valueOf
* @methodOf ng.$sceDelegate
*
* @description
* If the passed parameter had been returned by a prior call to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`}, returns the value that had been passed to {@link
* ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}.
*
* If the passed parameter is not a value that had been returned by {@link
* ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}, returns it as-is.
*
* @param {*} value The result of a prior {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}
* call or anything else.
* @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} if `value` is the result of such a call. Otherwise, returns
* `value` unchanged.
*/
function valueOf(maybeTrusted) {
if (maybeTrusted instanceof trustedValueHolderBase) {
return maybeTrusted.$$unwrapTrustedValue();
} else {
return maybeTrusted;
}
}
/**
* @ngdoc method
* @name ng.$sceDelegate#getTrusted
* @methodOf ng.$sceDelegate
*
* @description
* Takes the result of a {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`} call and
* returns the originally supplied value if the queried context type is a supertype of the
* created type. If this condition isn't satisfied, throws an exception.
*
* @param {string} type The kind of context in which this value is to be used.
* @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} call.
* @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} if valid in this context. Otherwise, throws an exception.
*/
function getTrusted(type, maybeTrusted) {
if (
maybeTrusted === null ||
maybeTrusted === undefined ||
maybeTrusted === ""
) {
return maybeTrusted;
}
var constructor = byType.hasOwnProperty(type) ? byType[type] : null;
if (constructor && maybeTrusted instanceof constructor) {
return maybeTrusted.$$unwrapTrustedValue();
}
// If we get here, then we may only take one of two actions.
// 1. sanitize the value for the requested type, or
// 2. throw an exception.
if (type === SCE_CONTEXTS.RESOURCE_URL) {
if (isResourceUrlAllowedByPolicy(maybeTrusted)) {
return maybeTrusted;
} else {
throw $sceMinErr(
"insecurl",
"Blocked loading resource from url not allowed by $sceDelegate policy. URL: {0}",
maybeTrusted.toString(),
);
}
} else if (type === SCE_CONTEXTS.HTML) {
return htmlSanitizer(maybeTrusted);
}
throw $sceMinErr(
"unsafe",
"Attempting to use an unsafe value in a safe context.",
);
}
return { trustAs: trustAs, getTrusted: getTrusted, valueOf: valueOf };
},
];
}
/**
* @ngdoc object
* @name ng.$sceProvider
* @description
*
* The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service.
* - enable/disable Strict Contextual Escaping (SCE) in a module
* - override the default implementation with a custom delegate
*
* Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}.
*/
/* jshint maxlen: false*/
/**
* @ngdoc service
* @name ng.$sce
* @function
*
* @description
*
* `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
*
* # Strict Contextual Escaping
*
* Strict Contextual Escaping (SCE) is a mode in which AngularJS requires bindings in certain
* contexts to result in a value that is marked as safe to use for that context. One example of
* such a context is binding arbitrary html controlled by the user via `ng-bind-html`. We refer
* to these contexts as privileged or SCE contexts.
*
* As of version 1.2, Angular ships with SCE enabled by default.
*
* Note: When enabled (the default), IE8 in quirks mode is not supported. In this mode, IE8 allows
* one to execute arbitrary javascript by the use of the expression() syntax. Refer
* <http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx> to learn more about them.
* You can ensure your document is in standards mode and not quirks mode by adding `<!doctype html>`
* to the top of your HTML document.
*
* SCE assists in writing code in way that (a) is secure by default and (b) makes auditing for
* security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
*
* Here's an example of a binding in a privileged context:
*
* <pre class="prettyprint">
* <input ng-model="userHtml">
* <div ng-bind-html="userHtml">
* </pre>
*
* Notice that `ng-bind-html` is bound to `userHtml` controlled by the user. With SCE
* disabled, this application allows the user to render arbitrary HTML into the DIV.
* In a more realistic example, one may be rendering user comments, blog articles, etc. via
* bindings. (HTML is just one example of a context where rendering user controlled input creates
* security vulnerabilities.)
*
* For the case of HTML, you might use a library, either on the client side, or on the server side,
* to sanitize unsafe HTML before binding to the value and rendering it in the document.
*
* How would you ensure that every place that used these types of bindings was bound to a value that
* was sanitized by your library (or returned as safe for rendering by your server?) How can you
* ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
* properties/fields and forgot to update the binding to the sanitized value?
*
* To be secure by default, you want to ensure that any such bindings are disallowed unless you can
* determine that something explicitly says it's safe to use a value for binding in that
* context. You can then audit your code (a simple grep would do) to ensure that this is only done
* for those values that you can easily tell are safe - because they were received from your server,
* sanitized by your library, etc. You can organize your codebase to help with this - perhaps
* allowing only the files in a specific directory to do this. Ensuring that the internal API
* exposed by that code doesn't markup arbitrary values as safe then becomes a more manageable task.
*
* In the case of AngularJS' SCE service, one uses {@link ng.$sce#methods_trustAs $sce.trustAs}
* (and shorthand methods such as {@link ng.$sce#methods_trustAsHtml $sce.trustAsHtml}, etc.) to
* obtain values that will be accepted by SCE / privileged contexts.
*
*
* ## How does it work?
*
* In privileged contexts, directives and code will bind to the result of {@link ng.$sce#methods_getTrusted
* $sce.getTrusted(context, value)} rather than to the value directly. Directives use {@link
* ng.$sce#methods_parse $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the
* {@link ng.$sce#methods_getTrusted $sce.getTrusted} behind the scenes on non-constant literals.
*
* As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
* ng.$sce#methods_parseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly
* simplified):
*
* <pre class="prettyprint">
* var ngBindHtmlDirective = ['$sce', function($sce) {
* return function(scope, element, attr) {
* scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) {
* element.html(value || '');
* });
* };
* }];
* </pre>
*
* ## Impact on loading templates
*
* This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
* `templateUrl`'s specified by {@link guide/directive directives}.
*
* By default, Angular only loads templates from the same domain and protocol as the application
* document. This is done by calling {@link ng.$sce#methods_getTrustedResourceUrl
* $sce.getTrustedResourceUrl} on the template URL. To load templates from other domains and/or
* protocols, you may either either {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist
* them} or {@link ng.$sce#methods_trustAsResourceUrl wrap it} into a trusted value.
*
* *Please note*:
* The browser's
* {@link https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest
* Same Origin Policy} and {@link http://www.w3.org/TR/cors/ Cross-Origin Resource Sharing (CORS)}
* policy apply in addition to this and may further restrict whether the template is successfully
* loaded. This means that without the right CORS policy, loading templates from a different domain
* won't work on all browsers. Also, loading templates from `file://` URL does not work on some
* browsers.
*
* ## This feels like too much overhead for the developer?
*
* It's important to remember that SCE only applies to interpolation expressions.
*
* If your expressions are constant literals, they're automatically trusted and you don't need to
* call `$sce.trustAs` on them. (e.g.
* `<div ng-html-bind-unsafe="'<b>implicitly trusted</b>'"></div>`) just works.
*
* Additionally, `a[href]` and `img[src]` automatically sanitize their URLs and do not pass them
* through {@link ng.$sce#methods_getTrusted $sce.getTrusted}. SCE doesn't play a role here.
*
* The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load
* templates in `ng-include` from your application's domain without having to even know about SCE.
* It blocks loading templates from other domains or loading templates over http from an https
* served document. You can change these by setting your own custom {@link
* ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelists} and {@link
* ng.$sceDelegateProvider#methods_resourceUrlBlacklist blacklists} for matching such URLs.
*
* This significantly reduces the overhead. It is far easier to pay the small overhead and have an
* application that's secure and can be audited to verify that with much more ease than bolting
* security onto an application later.
*
* <a name="contexts"></a>
* ## What trusted context types are supported?
*
* | Context | Notes |
* |---------------------|----------------|
* | `$sce.HTML` | For HTML that's safe to source into the application. The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. |
* | `$sce.CSS` | For CSS that's safe to source into the application. Currently unused. Feel free to use it in your own directives. |
* | `$sce.URL` | For URLs that are safe to follow as links. Currently unused (`<a href=` and `<img src=` sanitize their urls and don't consititute an SCE context. |
* | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contens are also safe to include in your application. Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.) <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` does and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` are required. |
* | `$sce.JS` | For JavaScript that is safe to execute in your application's context. Currently unused. Feel free to use it in your own directives. |
*
* ## Format of items in {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist resourceUrlWhitelist}/{@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist Blacklist} <a name="resourceUrlPatternItem"></a>
*
* Each element in these arrays must be one of the following:
*
* - **'self'**
* - The special **string**, `'self'`, can be used to match against all URLs of the **same
* domain** as the application document using the **same protocol**.
* - **String** (except the special value `'self'`)
* - The string is matched against the full *normalized / absolute URL* of the resource
* being tested (substring matches are not good enough.)
* - There are exactly **two wildcard sequences** - `*` and `**`. All other characters
* match themselves.
* - `*`: matches zero or more occurances of any character other than one of the following 6
* characters: '`:`', '`/`', '`.`', '`?`', '`&`' and ';'. It's a useful wildcard for use
* in a whitelist.
* - `**`: matches zero or more occurances of *any* character. As such, it's not
* not appropriate to use in for a scheme, domain, etc. as it would match too much. (e.g.
* http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might
* not have been the intention.) It's usage at the very end of the path is ok. (e.g.
* http://foo.example.com/templates/**).
* - **RegExp** (*see caveat below*)
* - *Caveat*: While regular expressions are powerful and offer great flexibility, their syntax
* (and all the inevitable escaping) makes them *harder to maintain*. It's easy to
* accidentally introduce a bug when one updates a complex expression (imho, all regexes should
* have good test coverage.). For instance, the use of `.` in the regex is correct only in a
* small number of cases. A `.` character in the regex used when matching the scheme or a
* subdomain could be matched against a `:` or literal `.` that was likely not intended. It
* is highly recommended to use the string patterns and only fall back to regular expressions
* if they as a last resort.
* - The regular expression must be an instance of RegExp (i.e. not a string.) It is
* matched against the **entire** *normalized / absolute URL* of the resource being tested
* (even when the RegExp did not have the `^` and `$` codes.) In addition, any flags
* present on the RegExp (such as multiline, global, ignoreCase) are ignored.
* - If you are generating your Javascript from some other templating engine (not
* recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),
* remember to escape your regular expression (and be aware that you might need more than
* one level of escaping depending on your templating engine and the way you interpolated
* the value.) Do make use of your platform's escaping mechanism as it might be good
* enough before coding your own. e.g. Ruby has
* [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)
* and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).
* Javascript lacks a similar built in function for escaping. Take a look at Google
* Closure library's [goog.string.regExpEscape(s)](
* http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).
*
* Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.
*
* ## Show me an example using SCE.
*
* @example
<example module="mySceApp">
<file name="index.html">
<div ng-controller="myAppController as myCtrl">
<i ng-bind-html="myCtrl.explicitlyTrustedHtml" id="explicitlyTrustedHtml"></i><br><br>
<b>User comments</b><br>
By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when
$sanitize is available. If $sanitize isn't available, this results in an error instead of an
exploit.
<div class="well">
<div ng-repeat="userComment in myCtrl.userComments">
<b>{{userComment.name}}</b>:
<span ng-bind-html="userComment.htmlComment" class="htmlComment"></span>
<br>
</div>
</div>
</div>
</file>
<file name="script.js">
var mySceApp = angular.module('mySceApp', ['ngSanitize']);
mySceApp.controller("myAppController", function myAppController($http, $templateCache, $sce) {
var self = this;
$http.get("test_data.json", {cache: $templateCache}).success(function(userComments) {
self.userComments = userComments;
});
self.explicitlyTrustedHtml = $sce.trustAsHtml(
'<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
'sanitization."">Hover over this text.</span>');
});
</file>
<file name="test_data.json">
[
{ "name": "Alice",
"htmlComment":
"<span onmouseover='this.textContent=\"PWN3D!\"'>Is <i>anyone</i> reading this?</span>"
},
{ "name": "Bob",
"htmlComment": "<i>Yes!</i> Am I the only other one?"
}
]
</file>
<file name="scenario.js">
describe('SCE doc demo', function() {
it('should sanitize untrusted values', function() {
expect(element('.htmlComment').html()).toBe('<span>Is <i>anyone</i> reading this?</span>');
});
it('should NOT sanitize explicitly trusted values', function() {
expect(element('#explicitlyTrustedHtml').html()).toBe(
'<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
'sanitization."">Hover over this text.</span>');
});
});
</file>
</example>
*
*
*
* ## Can I disable SCE completely?
*
* Yes, you can. However, this is strongly discouraged. SCE gives you a lot of security benefits
* for little coding overhead. It will be much harder to take an SCE disabled application and
* either secure it on your own or enable SCE at a later stage. It might make sense to disable SCE
* for cases where you have a lot of existing code that was written before SCE was introduced and
* you're migrating them a module at a time.
*
* That said, here's how you can completely disable SCE:
*
* <pre class="prettyprint">
* angular.module('myAppWithSceDisabledmyApp', []).config(function($sceProvider) {
* // Completely disable SCE. For demonstration purposes only!
* // Do not use in new projects.
* $sceProvider.enabled(false);
* });
* </pre>
*
*/
/* jshint maxlen: 100 */
function $SceProvider() {
var enabled = true;
/**
* @ngdoc function
* @name ng.sceProvider#enabled
* @methodOf ng.$sceProvider
* @function
*
* @param {boolean=} value If provided, then enables/disables SCE.
* @return {boolean} true if SCE is enabled, false otherwise.
*
* @description
* Enables/disables SCE and returns the current value.
*/
this.enabled = function (value) {
if (arguments.length) {
enabled = !!value;
}
return enabled;
};
/* Design notes on the default implementation for SCE.
*
* The API contract for the SCE delegate
* -------------------------------------
* The SCE delegate object must provide the following 3 methods:
*
* - trustAs(contextEnum, value)
* This method is used to tell the SCE service that the provided value is OK to use in the
* contexts specified by contextEnum. It must return an object that will be accepted by
* getTrusted() for a compatible contextEnum and return this value.
*
* - valueOf(value)
* For values that were not produced by trustAs(), return them as is. For values that were
* produced by trustAs(), return the corresponding input value to trustAs. Basically, if
* trustAs is wrapping the given values into some type, this operation unwraps it when given
* such a value.
*
* - getTrusted(contextEnum, value)
* This function should return the a value that is safe to use in the context specified by
* contextEnum or throw and exception otherwise.
*
* NOTE: This contract deliberately does NOT state that values returned by trustAs() must be
* opaque or wrapped in some holder object. That happens to be an implementation detail. For
* instance, an implementation could maintain a registry of all trusted objects by context. In
* such a case, trustAs() would return the same object that was passed in. getTrusted() would
* return the same object passed in if it was found in the registry under a compatible context or
* throw an exception otherwise. An implementation might only wrap values some of the time based
* on some criteria. getTrusted() might return a value and not throw an exception for special
* constants or objects even if not wrapped. All such implementations fulfill this contract.
*
*
* A note on the inheritance model for SCE contexts
* ------------------------------------------------
* I've used inheritance and made RESOURCE_URL wrapped types a subtype of URL wrapped types. This
* is purely an implementation details.
*
* The contract is simply this:
*
* getTrusted($sce.RESOURCE_URL, value) succeeding implies that getTrusted($sce.URL, value)
* will also succeed.
*
* Inheritance happens to capture this in a natural way. In some future, we
* may not use inheritance anymore. That is OK because no code outside of
* sce.js and sceSpecs.js would need to be aware of this detail.
*/
this.$get = [
"$parse",
"$sniffer",
"$sceDelegate",
function ($parse, $sniffer, $sceDelegate) {
// Prereq: Ensure that we're not running in IE8 quirks mode. In that mode, IE allows
// the "expression(javascript expression)" syntax which is insecure.
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);
/**
* @ngdoc function
* @name ng.sce#isEnabled
* @methodOf ng.$sce
* @function
*
* @return {Boolean} true if SCE is enabled, false otherwise. If you want to set the value, you
* have to do it at module config time on {@link ng.$sceProvider $sceProvider}.
*
* @description
* Returns a boolean indicating if SCE is enabled.
*/
sce.isEnabled = function () {
return enabled;
};
sce.trustAs = $sceDelegate.trustAs;
sce.getTrusted = $sceDelegate.getTrusted;
sce.valueOf = $sceDelegate.valueOf;
if (!enabled) {
sce.trustAs = sce.getTrusted = function (type, value) {
return value;
};
sce.valueOf = identity;
}
/**
* @ngdoc method
* @name ng.$sce#parse
* @methodOf ng.$sce
*
* @description
* Converts Angular {@link guide/expression expression} into a function. This is like {@link
* ng.$parse $parse} and is identical when the expression is a literal constant. Otherwise, it
* wraps the expression in a call to {@link ng.$sce#methods_getTrusted $sce.getTrusted(*type*,
* *result*)}
*
* @param {string} type The kind of SCE context in which this result will be used.
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
sce.parseAs = function sceParseAs(type, expr) {
var parsed = $parse(expr);
if (parsed.literal && parsed.constant) {
return parsed;
} else {
return function sceParseAsTrusted(self, locals) {
return sce.getTrusted(type, parsed(self, locals));
};
}
};
/**
* @ngdoc method
* @name ng.$sce#trustAs
* @methodOf ng.$sce
*
* @description
* Delegates to {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}. As such,
* returns an objectthat is trusted by angular for use in specified strict contextual
* escaping contexts (such as ng-html-bind-unsafe, ng-include, any src attribute
* interpolation, any dom event binding attribute interpolation such as for onclick, etc.)
* that uses the provided value. See * {@link ng.$sce $sce} for enabling strict contextual
* escaping.
*
* @param {string} type The kind of context in which this value is safe for use. e.g. url,
* resource_url, html, js and css.
* @param {*} value The value that that should be considered trusted/safe.
* @returns {*} A value that can be used to stand in for the provided `value` in places
* where Angular expects a $sce.trustAs() return value.
*/
/**
* @ngdoc method
* @name ng.$sce#trustAsHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsHtml(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.HTML, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedHtml
* $sce.getTrustedHtml(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/
/**
* @ngdoc method
* @name ng.$sce#trustAsUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsUrl(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.URL, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedUrl
* $sce.getTrustedUrl(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/
/**
* @ngdoc method
* @name ng.$sce#trustAsResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsResourceUrl(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.RESOURCE_URL, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedResourceUrl
* $sce.getTrustedResourceUrl(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the return
* value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/
/**
* @ngdoc method
* @name ng.$sce#trustAsJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsJs(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.JS, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedJs
* $sce.getTrustedJs(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/
/**
* @ngdoc method
* @name ng.$sce#getTrusted
* @methodOf ng.$sce
*
* @description
* Delegates to {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted`}. As such,
* takes the result of a {@link ng.$sce#methods_trustAs `$sce.trustAs`}() call and returns the
* originally supplied value if the queried context type is a supertype of the created type.
* If this condition isn't satisfied, throws an exception.
*
* @param {string} type The kind of context in which this value is to be used.
* @param {*} maybeTrusted The result of a prior {@link ng.$sce#methods_trustAs `$sce.trustAs`}
* call.
* @returns {*} The value the was originally provided to
* {@link ng.$sce#methods_trustAs `$sce.trustAs`} if valid in this context.
* Otherwise, throws an exception.
*/
/**
* @ngdoc method
* @name ng.$sce#getTrustedHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedHtml(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.HTML, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.HTML, value)`
*/
/**
* @ngdoc method
* @name ng.$sce#getTrustedCss
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedCss(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.CSS, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.CSS, value)`
*/
/**
* @ngdoc method
* @name ng.$sce#getTrustedUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedUrl(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.URL, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.URL, value)`
*/
/**
* @ngdoc method
* @name ng.$sce#getTrustedResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedResourceUrl(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.RESOURCE_URL, value)`}
*
* @param {*} value The value to pass to `$sceDelegate.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.RESOURCE_URL, value)`
*/
/**
* @ngdoc method
* @name ng.$sce#getTrustedJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedJs(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.JS, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.JS, value)`
*/
/**
* @ngdoc method
* @name ng.$sce#parseAsHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsHtml(expression string)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.HTML, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
/**
* @ngdoc method
* @name ng.$sce#parseAsCss
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsCss(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.CSS, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
/**
* @ngdoc method
* @name ng.$sce#parseAsUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsUrl(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.URL, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
/**
* @ngdoc method
* @name ng.$sce#parseAsResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsResourceUrl(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.RESOURCE_URL, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
/**
* @ngdoc method
* @name ng.$sce#parseAsJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsJs(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.JS, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/
// Shorthand delegations.
var parse = sce.parseAs,
getTrusted = sce.getTrusted,
trustAs = sce.trustAs;
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);
};
});
return sce;
},
];
}
/**
* !!! This is an undocumented "private" service !!!
*
* @name ng.$sniffer
* @requires $window
* @requires $document
*
* @property {boolean} history Does the browser support html5 history api ?
* @property {boolean} hashchange Does the browser support hashchange event ?
* @property {boolean} transitions Does the browser support CSS transition events ?
* @property {boolean} animations Does the browser support CSS animation events ?
*
* @description
* This is very simple implementation of testing browser's features.
*/
function $SnifferProvider() {
this.$get = [
"$window",
"$document",
function ($window, $document) {
var eventSupport = {},
android = int(
(/android (\d+)/.exec(
lowercase(($window.navigator || {}).userAgent),
) || [])[1],
),
boxee = /Boxee/i.test(($window.navigator || {}).userAgent),
document = $document[0] || {},
documentMode = document.documentMode,
vendorPrefix,
vendorRegex = /^(Moz|webkit|O|ms)(?=[A-Z])/,
bodyStyle = document.body && document.body.style,
transitions = false,
animations = false,
match;
if (bodyStyle) {
for (var prop in bodyStyle) {
if ((match = vendorRegex.exec(prop))) {
vendorPrefix = match[0];
vendorPrefix =
vendorPrefix.substr(0, 1).toUpperCase() +
vendorPrefix.substr(1);
break;
}
}
if (!vendorPrefix) {
vendorPrefix = "WebkitOpacity" in bodyStyle && "webkit";
}
transitions = !!(
"transition" in bodyStyle ||
vendorPrefix + "Transition" in bodyStyle
);
animations = !!(
"animation" in bodyStyle || vendorPrefix + "Animation" in bodyStyle
);
if (android && (!transitions || !animations)) {
transitions = isString(document.body.style.webkitTransition);
animations = isString(document.body.style.webkitAnimation);
}
}
return {
// Android has history.pushState, but it does not update location correctly
// so let's not use the history API at all.
// http://code.google.com/p/android/issues/detail?id=17471
// https://github.com/angular/angular.js/issues/904
// older webit browser (533.9) on Boxee box has exactly the same problem as Android has
// so let's not use the history API also
// We are purposefully using `!(android < 4)` to cover the case when `android` is undefined
// jshint -W018
history: !!(
$window.history &&
$window.history.pushState &&
!(android < 4) &&
!boxee
),
// jshint +W018
hashchange:
"onhashchange" in $window &&
// IE8 compatible mode lies
(!documentMode || documentMode > 7),
hasEvent: function (event) {
// IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
// it. In particular the event is not fired when backspace or delete key are pressed or
// when cut operation is performed.
if (event == "input" && msie == 9) return false;
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 = {};
/**
* @ngdoc function
* @name ng.$timeout
* @requires $browser
*
* @description
* Angular's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
* block and delegates any exceptions to
* {@link ng.$exceptionHandler $exceptionHandler} service.
*
* The return value of registering a timeout function is a promise, which will be resolved when
* the timeout is reached and the timeout function is executed.
*
* To cancel a timeout request, call `$timeout.cancel(promise)`.
*
* In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
* synchronously flush the queue of deferred functions.
*
* @param {function()} fn A function, whose execution should be delayed.
* @param {number=} [delay=0] Delay in milliseconds.
* @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
* will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
* @returns {Promise} Promise that will be resolved when the timeout is reached. The value this
* promise will be resolved with is the return value of the `fn` function.
*
* @example
<doc:example module="time">
<doc:source>
<script>
function Ctrl2($scope,$timeout) {
$scope.format = 'M/d/yy h:mm:ss a';
$scope.blood_1 = 100;
$scope.blood_2 = 120;
var stop;
$scope.fight = function() {
stop = $timeout(function() {
if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
$scope.blood_1 = $scope.blood_1 - 3;
$scope.blood_2 = $scope.blood_2 - 4;
$scope.fight();
} else {
$timeout.cancel(stop);
}
}, 100);
};
$scope.stopFight = function() {
$timeout.cancel(stop);
};
$scope.resetFight = function() {
$scope.blood_1 = 100;
$scope.blood_2 = 120;
}
}
angular.module('time', [])
// Register the 'myCurrentTime' directive factory method.
// We inject $timeout and dateFilter service since the factory method is DI.
.directive('myCurrentTime', function($timeout, dateFilter) {
// return the directive link function. (compile function not needed)
return function(scope, element, attrs) {
var format, // date format
timeoutId; // timeoutId, so that we can cancel the time updates
// used to update the UI
function updateTime() {
element.text(dateFilter(new Date(), format));
}
// watch the expression, and update the UI on change.
scope.$watch(attrs.myCurrentTime, function(value) {
format = value;
updateTime();
});
// schedule update in one second
function updateLater() {
// save the timeoutId for canceling
timeoutId = $timeout(function() {
updateTime(); // update DOM
updateLater(); // schedule another update
}, 1000);
}
// listen on DOM destroy (removal) event, and cancel the next UI update
// to prevent updating time ofter the DOM element was removed.
element.bind('$destroy', function() {
$timeout.cancel(timeoutId);
});
updateLater(); // kick off the UI update process.
}
});
</script>
<div>
<div ng-controller="Ctrl2">
Date format: <input ng-model="format"> <hr/>
Current time is: <span my-current-time="format"></span>
<hr/>
Blood 1 : <font color='red'>{{blood_1}}</font>
Blood 2 : <font color='red'>{{blood_2}}</font>
<button type="button" data-ng-click="fight()">Fight</button>
<button type="button" data-ng-click="stopFight()">StopFight</button>
<button type="button" data-ng-click="resetFight()">resetFight</button>
</div>
</div>
</doc:source>
</doc:example>
*/
function timeout(fn, delay, invokeApply) {
var deferred = $q.defer(),
promise = deferred.promise,
skipApply = isDefined(invokeApply) && !invokeApply,
timeoutId;
timeoutId = $browser.defer(function () {
try {
deferred.resolve(fn());
} catch (e) {
deferred.reject(e);
$exceptionHandler(e);
} finally {
delete deferreds[promise.$$timeoutId];
}
if (!skipApply) $rootScope.$apply();
}, delay);
promise.$$timeoutId = timeoutId;
deferreds[timeoutId] = deferred;
return promise;
}
/**
* @ngdoc function
* @name ng.$timeout#cancel
* @methodOf ng.$timeout
*
* @description
* Cancels a task associated with the `promise`. As a result of this, the promise will be
* resolved with a rejection.
*
* @param {Promise=} promise Promise returned by the `$timeout` function.
* @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
* canceled.
*/
timeout.cancel = function (promise) {
if (promise && promise.$$timeoutId in deferreds) {
deferreds[promise.$$timeoutId].reject("canceled");
delete deferreds[promise.$$timeoutId];
return $browser.defer.cancel(promise.$$timeoutId);
}
return false;
};
return timeout;
},
];
}
// NOTE: The usage of window and document instead of $window and $document here is
// deliberate. This service depends on the specific behavior of anchor nodes created by the
// browser (resolving and parsing URLs) that is unlikely to be provided by mock objects and
// cause us to break tests. In addition, when the browser resolves a URL for XHR, it
// doesn't know about mocked locations and resolves URLs to the real document - which is
// exactly the behavior needed here. There is little value is mocking these out for this
// service.
var urlParsingNode = document.createElement("a");
var originUrl = urlResolve(window.location.href, true);
/**
*
* Implementation Notes for non-IE browsers
* ----------------------------------------
* Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
* results both in the normalizing and parsing of the URL. Normalizing means that a relative
* URL will be resolved into an absolute URL in the context of the application document.
* Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
* properties are all populated to reflect the normalized URL. This approach has wide
* compatibility - Safari 1+, Mozilla 1+, Opera 7+,e etc. See
* http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
*
* Implementation Notes for IE
* ---------------------------
* IE >= 8 and <= 10 normalizes the URL when assigned to the anchor node similar to the other
* browsers. However, the parsed components will not be set if the URL assigned did not specify
* them. (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.) We
* work around that by performing the parsing in a 2nd step by taking a previously normalized
* URL (e.g. by assigning to a.href) and assigning it a.href again. This correctly populates the
* properties such as protocol, hostname, port, etc.
*
* IE7 does not normalize the URL when assigned to an anchor node. (Apparently, it does, if one
* uses the inner HTML approach to assign the URL as part of an HTML snippet -
* http://stackoverflow.com/a/472729) However, setting img[src] does normalize the URL.
* Unfortunately, setting img[src] to something like "javascript:foo" on IE throws an exception.
* Since the primary usage for normalizing URLs is to sanitize such URLs, we can't use that
* method and IE < 8 is unsupported.
*
* References:
* http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
* http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
* http://url.spec.whatwg.org/#urlutils
* https://github.com/angular/angular.js/pull/2902
* http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
*
* @function
* @param {string} url The URL to be parsed.
* @description Normalizes and parses a URL.
* @returns {object} Returns the normalized URL as a dictionary.
*
* | member name | Description |
* |---------------|----------------|
* | href | A normalized version of the provided URL if it was not an absolute URL |
* | protocol | The protocol including the trailing colon |
* | host | The host and port (if the port is non-default) of the normalizedUrl |
* | search | The search params, minus the question mark |
* | hash | The hash string, minus the hash symbol
* | hostname | The hostname
* | port | The port, without ":"
* | pathname | The pathname, beginning with "/"
*
*/
function urlResolve(url, base) {
var href = url;
if (msie) {
// Normalize before parse. Refer Implementation Notes on why this is
// done in two steps on IE.
urlParsingNode.setAttribute("href", href);
href = urlParsingNode.href;
}
urlParsingNode.setAttribute("href", href);
// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
return {
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,
};
}
/**
* Parse a request URL and determine whether this is a same-origin request as the application document.
*
* @param {string|object} requestUrl The url of the request as a string that will be resolved
* or a parsed URL object.
* @returns {boolean} Whether the request is for the same origin as the application document.
*/
function urlIsSameOrigin(requestUrl) {
var parsed = isString(requestUrl) ? urlResolve(requestUrl) : requestUrl;
return (
parsed.protocol === originUrl.protocol && parsed.host === originUrl.host
);
}
/**
* @ngdoc object
* @name ng.$window
*
* @description
* A reference to the browser's `window` object. While `window`
* is globally available in JavaScript, it causes testability problems, because
* it is a global variable. In angular we always refer to it through the
* `$window` service, so it may be overridden, removed or mocked for testing.
*
* Expressions, like the one defined for the `ngClick` directive in the example
* below, are evaluated with respect to the current scope. Therefore, there is
* no risk of inadvertently coding in a dependency on a global value in such an
* expression.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope, $window) {
$scope.greeting = 'Hello, World!';
$scope.doGreeting = function(greeting) {
$window.alert(greeting);
};
}
</script>
<div ng-controller="Ctrl">
<input type="text" ng-model="greeting" />
<button ng-click="doGreeting(greeting)">ALERT</button>
</div>
</doc:source>
<doc:scenario>
it('should display the greeting in the input box', function() {
input('greeting').enter('Hello, E2E Tests');
// If we click the button it will block the test runner
// element(':button').click();
});
</doc:scenario>
</doc:example>
*/
function $WindowProvider() {
this.$get = valueFn(window);
}
/**
* @ngdoc object
* @name ng.$filterProvider
* @description
*
* Filters are just functions which transform input to an output. However filters need to be
* Dependency Injected. To achieve this a filter definition consists of a factory function which is
* annotated with dependencies and is responsible for creating a filter function.
*
* <pre>
* // Filter registration
* function MyModule($provide, $filterProvider) {
* // create a service to demonstrate injection (not always needed)
* $provide.value('greet', function(name){
* return 'Hello ' + name + '!';
* });
*
* // register a filter factory which uses the
* // greet service to demonstrate DI.
* $filterProvider.register('greet', function(greet){
* // return the filter function which uses the greet service
* // to generate salutation
* return function(text) {
* // filters need to be forgiving so check input validity
* return text && greet(text) || text;
* };
* });
* }
* </pre>
*
* The filter function is registered with the `$injector` under the filter name suffix with
* `Filter`.
*
* <pre>
* it('should be the same instance', inject(
* function($filterProvider) {
* $filterProvider.register('reverse', function(){
* return ...;
* });
* },
* function($filter, reverseFilter) {
* expect($filter('reverse')).toBe(reverseFilter);
* });
* </pre>
*
*
* For more information about how angular filters work, and how to create your own filters, see
* {@link guide/filter Filters} in the Angular Developer Guide.
*/
/**
* @ngdoc method
* @name ng.$filterProvider#register
* @methodOf ng.$filterProvider
* @description
* Register filter factory function.
*
* @param {String} name Name of the filter.
* @param {function} fn The filter factory function which is injectable.
*/
/**
* @ngdoc function
* @name ng.$filter
* @function
* @description
* Filters are used for formatting data displayed to the user.
*
* The general syntax in templates is as follows:
*
* {{ expression [| filter_name[:parameter_value] ... ] }}
*
* @param {String} name Name of the filter function to retrieve
* @return {Function} the filter function
*/
$FilterProvider.$inject = ["$provide"];
function $FilterProvider($provide) {
var suffix = "Filter";
/**
* @ngdoc function
* @name ng.$controllerProvider#register
* @methodOf ng.$controllerProvider
* @param {string|Object} name Name of the filter function, or an object map of filters where
* the keys are the filter names and the values are the filter factories.
* @returns {Object} Registered filter instance, or if a map of filters was provided then a map
* of the registered filter instances.
*/
function register(name, factory) {
if (isObject(name)) {
var filters = {};
forEach(name, function (filter, key) {
filters[key] = register(key, filter);
});
return filters;
} else {
return $provide.factory(name + suffix, factory);
}
}
this.register = register;
this.$get = [
"$injector",
function ($injector) {
return function (name) {
return $injector.get(name + suffix);
};
},
];
////////////////////////////////////////
/* global
currencyFilter: false,
dateFilter: false,
filterFilter: false,
jsonFilter: false,
limitToFilter: false,
lowercaseFilter: false,
numberFilter: false,
orderByFilter: false,
uppercaseFilter: false,
*/
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);
}
/**
* @ngdoc filter
* @name ng.filter:filter
* @function
*
* @description
* Selects a subset of items from `array` and returns it as a new array.
*
* @param {Array} array The source array.
* @param {string|Object|function()} expression The predicate to be used for selecting items from
* `array`.
*
* Can be one of:
*
* - `string`: Predicate that results in a substring match using the value of `expression`
* string. All strings or objects with string properties in `array` that contain this string
* will be returned. The predicate can be negated by prefixing the string with `!`.
*
* - `Object`: A pattern object can be used to filter specific properties on objects contained
* by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
* which have property `name` containing "M" and property `phone` containing "1". A special
* property name `$` can be used (as in `{$:"text"}`) to accept a match against any
* property of the object. That's equivalent to the simple substring match with a `string`
* as described above.
*
* - `function`: A predicate function can be used to write arbitrary filters. The function is
* called for each element of `array`. The final result is an array of those elements that
* the predicate returned true for.
*
* @param {function(expected, actual)|true|undefined} comparator Comparator which is used in
* determining if the expected value (from the filter expression) and actual value (from
* the object in the array) should be considered a match.
*
* Can be one of:
*
* - `function(expected, actual)`:
* The function will be given the object value and the predicate value to compare and
* should return true if the item should be included in filtered result.
*
* - `true`: A shorthand for `function(expected, actual) { return angular.equals(expected, actual)}`.
* this is essentially strict comparison of expected and actual.
*
* - `false|undefined`: A short hand for a function which will look for a substring match in case
* insensitive way.
*
* @example
<doc:example>
<doc:source>
<div ng-init="friends = [{name:'John', phone:'555-1276'},
{name:'Mary', phone:'800-BIG-MARY'},
{name:'Mike', phone:'555-4321'},
{name:'Adam', phone:'555-5678'},
{name:'Julie', phone:'555-8765'},
{name:'Juliette', phone:'555-5678'}]"></div>
Search: <input ng-model="searchText">
<table id="searchTextResults">
<tr><th>Name</th><th>Phone</th></tr>
<tr ng-repeat="friend in friends | filter:searchText">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
</tr>
</table>
<hr>
Any: <input ng-model="search.$"> <br>
Name only <input ng-model="search.name"><br>
Phone only <input ng-model="search.phone"><br>
Equality <input type="checkbox" ng-model="strict"><br>
<table id="searchObjResults">
<tr><th>Name</th><th>Phone</th></tr>
<tr ng-repeat="friend in friends | filter:search:strict">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
</tr>
</table>
</doc:source>
<doc:scenario>
it('should search across all fields when filtering with a string', function() {
input('searchText').enter('m');
expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Mike', 'Adam']);
input('searchText').enter('76');
expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
toEqual(['John', 'Julie']);
});
it('should search in specific fields when filtering with a predicate object', function() {
input('search.$').enter('i');
expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Mike', 'Julie', 'Juliette']);
});
it('should use a equal comparison when comparator is true', function() {
input('search.name').enter('Julie');
input('strict').check();
expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
toEqual(['Julie']);
});
</doc:scenario>
</doc:example>
*/
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 false;
}
}
return true;
};
if (comparatorType !== "function") {
if (comparatorType === "boolean" && comparator) {
comparator = function (obj, text) {
return angular.equals(obj, text);
};
} else {
comparator = function (obj, text) {
text = ("" + text).toLowerCase();
return ("" + obj).toLowerCase().indexOf(text) > -1;
};
}
}
var search = function (obj, text) {
if (typeof text == "string" && 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 true;
}
}
break;
}
return false;
case "array":
for (var i = 0; i < obj.length; i++) {
if (search(obj[i], text)) {
return true;
}
}
return false;
default:
return false;
}
};
switch (typeof expression) {
case "boolean":
case "number":
case "string":
// Set up expression object and fall through
expression = { $: expression };
// jshint -W086
case "object":
// jshint +W086
for (var key in expression) {
if (key == "$") {
(function () {
if (!expression[key]) return;
var path = key;
predicates.push(function (value) {
return search(value, expression[path]);
});
})();
} else {
(function () {
if (typeof expression[key] == "undefined") {
return;
}
var path = key;
predicates.push(function (value) {
return search(getter(value, path), expression[path]);
});
})();
}
}
break;
case "function":
predicates.push(expression);
break;
default:
return array;
}
var filtered = [];
for (var j = 0; j < array.length; j++) {
var value = array[j];
if (predicates.check(value)) {
filtered.push(value);
}
}
return filtered;
};
}
/**
* @ngdoc filter
* @name ng.filter:currency
* @function
*
* @description
* Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default
* symbol for current locale is used.
*
* @param {number} amount Input to filter.
* @param {string=} symbol Currency symbol or identifier to be displayed.
* @returns {string} Formatted number.
*
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.amount = 1234.56;
}
</script>
<div ng-controller="Ctrl">
<input type="number" ng-model="amount"> <br>
default currency symbol ($): {{amount | currency}}<br>
custom currency identifier (USD$): {{amount | currency:"USD$"}}
</div>
</doc:source>
<doc:scenario>
it('should init with 1234.56', function() {
expect(binding('amount | currency')).toBe('$1,234.56');
expect(binding('amount | currency:"USD$"')).toBe('USD$1,234.56');
});
it('should update', function() {
input('amount').enter('-1234');
expect(binding('amount | currency')).toBe('($1,234.00)');
expect(binding('amount | currency:"USD$"')).toBe('(USD$1,234.00)');
});
</doc:scenario>
</doc:example>
*/
currencyFilter.$inject = ["$locale"];
function currencyFilter($locale) {
var formats = $locale.NUMBER_FORMATS;
return function (amount, currencySymbol) {
if (isUndefined(currencySymbol)) currencySymbol = formats.CURRENCY_SYM;
return formatNumber(
amount,
formats.PATTERNS[1],
formats.GROUP_SEP,
formats.DECIMAL_SEP,
2,
).replace(/\u00A4/g, currencySymbol);
};
}
/**
* @ngdoc filter
* @name ng.filter:number
* @function
*
* @description
* Formats a number as text.
*
* If the input is not a number an empty string is returned.
*
* @param {number|string} number Number to format.
* @param {(number|string)=} fractionSize Number of decimal places to round the number to.
* If this is not provided then the fraction size is computed from the current locale's number
* formatting pattern. In the case of the default locale, it will be 3.
* @returns {string} Number rounded to decimalPlaces and places a “,” after each third digit.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.val = 1234.56789;
}
</script>
<div ng-controller="Ctrl">
Enter number: <input ng-model='val'><br>
Default formatting: {{val | number}}<br>
No fractions: {{val | number:0}}<br>
Negative number: {{-val | number:4}}
</div>
</doc:source>
<doc:scenario>
it('should format numbers', function() {
expect(binding('val | number')).toBe('1,234.568');
expect(binding('val | number:0')).toBe('1,235');
expect(binding('-val | number:4')).toBe('-1,234.5679');
});
it('should update', function() {
input('val').enter('3374.333');
expect(binding('val | number')).toBe('3,374.333');
expect(binding('val | number:0')).toBe('3,374');
expect(binding('-val | number:4')).toBe('-3,374.3330');
});
</doc:scenario>
</doc:example>
*/
numberFilter.$inject = ["$locale"];
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,
);
};
}
var DECIMAL_SEP = ".";
function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {
if (isNaN(number) || !isFinite(number)) return "";
var isNegative = number < 0;
number = Math.abs(number);
var numStr = number + "",
formatedText = "",
parts = [];
var hasExponent = false;
if (numStr.indexOf("e") !== -1) {
var match = numStr.match(/([\d\.]+)e(-?)(\d+)/);
if (match && match[2] == "-" && match[3] > fractionSize + 1) {
numStr = "0";
} else {
formatedText = numStr;
hasExponent = true;
}
}
if (!hasExponent) {
var fractionLen = (numStr.split(DECIMAL_SEP)[1] || "").length;
// determine fractionSize if it is not specified
if (isUndefined(fractionSize)) {
fractionSize = Math.min(
Math.max(pattern.minFrac, fractionLen),
pattern.maxFrac,
);
}
var pow = Math.pow(10, fractionSize);
number = Math.round(number * pow) / pow;
var fraction = ("" + number).split(DECIMAL_SEP);
var whole = fraction[0];
fraction = fraction[1] || "";
var i,
pos = 0,
lgroup = pattern.lgSize,
group = pattern.gSize;
if (whole.length >= lgroup + group) {
pos = whole.length - lgroup;
for (i = 0; i < pos; i++) {
if ((pos - i) % group === 0 && i !== 0) {
formatedText += groupSep;
}
formatedText += whole.charAt(i);
}
}
for (i = pos; i < whole.length; i++) {
if ((whole.length - i) % lgroup === 0 && i !== 0) {
formatedText += groupSep;
}
formatedText += whole.charAt(i);
}
// format fraction part.
while (fraction.length < fractionSize) {
fraction += "0";
}
if (fractionSize && fractionSize !== "0")
formatedText += decimalSep + fraction.substr(0, fractionSize);
} else {
if (fractionSize > 0 && number > -1 && number < 1) {
formatedText = number.toFixed(fractionSize);
}
}
parts.push(isNegative ? pattern.negPre : pattern.posPre);
parts.push(formatedText);
parts.push(isNegative ? pattern.negSuf : pattern.posSuf);
return parts.join("");
}
function padNumber(num, digits, trim) {
var neg = "";
if (num < 0) {
neg = "-";
num = -num;
}
num = "" + num;
while (num.length < digits) num = "0" + num;
if (trim) num = num.substr(num.length - digits);
return neg + num;
}
function dateGetter(name, size, offset, trim) {
offset = offset || 0;
return function (date) {
var value = date["get" + name]();
if (offset > 0 || value > -offset) value += offset;
if (value === 0 && offset == -12) value = 12;
return padNumber(value, size, trim);
};
}
function dateStrGetter(name, shortForm) {
return function (date, formats) {
var value = date["get" + name]();
var get = uppercase(shortForm ? "SHORT" + name : name);
return formats[get][value];
};
}
function timeZoneGetter(date) {
var zone = -1 * date.getTimezoneOffset();
var paddedZone = zone >= 0 ? "+" : "";
paddedZone +=
padNumber(Math[zone > 0 ? "floor" : "ceil"](zone / 60), 2) +
padNumber(Math.abs(zone % 60), 2);
return paddedZone;
}
function ampmGetter(date, formats) {
return date.getHours() < 12 ? formats.AMPMS[0] : formats.AMPMS[1];
}
var DATE_FORMATS = {
yyyy: dateGetter("FullYear", 4),
yy: dateGetter("FullYear", 2, 0, true),
y: dateGetter("FullYear", 1),
MMMM: dateStrGetter("Month"),
MMM: dateStrGetter("Month", true),
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),
// while ISO 8601 requires fractions to be prefixed with `.` or `,`
// we can be just safely rely on using `sss` since we currently don't support single or two digit fractions
sss: dateGetter("Milliseconds", 3),
EEEE: dateStrGetter("Day"),
EEE: dateStrGetter("Day", true),
a: ampmGetter,
Z: timeZoneGetter,
};
var DATE_FORMATS_SPLIT =
/((?:[^yMdHhmsaZE']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|d+|H+|h+|m+|s+|a|Z))(.*)/,
NUMBER_STRING = /^\-?\d+$/;
/**
* @ngdoc filter
* @name ng.filter:date
* @function
*
* @description
* Formats `date` to a string based on the requested `format`.
*
* `format` string can be composed of the following elements:
*
* * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010)
* * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)
* * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199)
* * `'MMMM'`: Month in year (January-December)
* * `'MMM'`: Month in year (Jan-Dec)
* * `'MM'`: Month in year, padded (01-12)
* * `'M'`: Month in year (1-12)
* * `'dd'`: Day in month, padded (01-31)
* * `'d'`: Day in month (1-31)
* * `'EEEE'`: Day in Week,(Sunday-Saturday)
* * `'EEE'`: Day in Week, (Sun-Sat)
* * `'HH'`: Hour in day, padded (00-23)
* * `'H'`: Hour in day (0-23)
* * `'hh'`: Hour in am/pm, padded (01-12)
* * `'h'`: Hour in am/pm, (1-12)
* * `'mm'`: Minute in hour, padded (00-59)
* * `'m'`: Minute in hour (0-59)
* * `'ss'`: Second in minute, padded (00-59)
* * `'s'`: Second in minute (0-59)
* * `'.sss' or ',sss'`: Millisecond in second, padded (000-999)
* * `'a'`: am/pm marker
* * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200)
*
* `format` string can also be one of the following predefined
* {@link guide/i18n localizable formats}:
*
* * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale
* (e.g. Sep 3, 2010 12:05:08 pm)
* * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US locale (e.g. 9/3/10 12:05 pm)
* * `'fullDate'`: equivalent to `'EEEE, MMMM d,y'` for en_US locale
* (e.g. Friday, September 3, 2010)
* * `'longDate'`: equivalent to `'MMMM d, y'` for en_US locale (e.g. September 3, 2010)
* * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US locale (e.g. Sep 3, 2010)
* * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10)
* * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 pm)
* * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 pm)
*
* `format` string can contain literal values. These need to be quoted with single quotes (e.g.
* `"h 'in the morning'"`). In order to output single quote, use two single quotes in a sequence
* (e.g. `"h 'o''clock'"`).
*
* @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or
* number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.SSSZ and its
* shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is
* specified in the string input, the time is considered to be in the local timezone.
* @param {string=} format Formatting rules (see Description). If not specified,
* `mediumDate` is used.
* @returns {string} Formatted string or the input if input is not recognized as date/millis.
*
* @example
<doc:example>
<doc:source>
<span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>:
{{1288323623006 | date:'medium'}}<br>
<span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>:
{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}<br>
<span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>:
{{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}<br>
</doc:source>
<doc:scenario>
it('should format date', function() {
expect(binding("1288323623006 | date:'medium'")).
toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/);
expect(binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).
toMatch(/2010\-10\-2\d \d{2}:\d{2}:\d{2} (\-|\+)?\d{4}/);
expect(binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).
toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/);
});
</doc:scenario>
</doc:example>
*/
dateFilter.$inject = ["$locale"];
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))?)?$/;
// 1 2 3 4 5 6 7 8 9 10 11
function jsonStringToDate(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;
if (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;
var m = int(match[5] || 0) - tzMin;
var s = int(match[6] || 0);
var ms = Math.round(parseFloat("0." + (match[7] || 0)) * 1000);
timeSetter.call(date, h, m, s, ms);
return date;
}
return string;
}
return function (date, format) {
var text = "",
parts = [],
fn,
match;
format = format || "mediumDate";
format = $locale.DATETIME_FORMATS[format] || format;
if (isString(date)) {
if (NUMBER_STRING.test(date)) {
date = int(date);
} else {
date = jsonStringToDate(date);
}
}
if (isNumber(date)) {
date = new Date(date);
}
if (!isDate(date)) {
return date;
}
while (format) {
match = DATE_FORMATS_SPLIT.exec(format);
if (match) {
parts = concat(parts, match, 1);
format = parts.pop();
} else {
parts.push(format);
format = null;
}
}
forEach(parts, function (value) {
fn = DATE_FORMATS[value];
text += fn
? fn(date, $locale.DATETIME_FORMATS)
: value.replace(/(^'|'$)/g, "").replace(/''/g, "'");
});
return text;
};
}
/**
* @ngdoc filter
* @name ng.filter:json
* @function
*
* @description
* Allows you to convert a JavaScript object into JSON string.
*
* This filter is mostly useful for debugging. When using the double curly {{value}} notation
* the binding is automatically converted to JSON.
*
* @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
* @returns {string} JSON string.
*
*
* @example:
<doc:example>
<doc:source>
<pre>{{ {'name':'value'} | json }}</pre>
</doc:source>
<doc:scenario>
it('should jsonify filtered objects', function() {
expect(binding("{'name':'value'}")).toMatch(/\{\n "name": ?"value"\n}/);
});
</doc:scenario>
</doc:example>
*
*/
function jsonFilter() {
return function (object) {
return toJson(object, true);
};
}
/**
* @ngdoc filter
* @name ng.filter:lowercase
* @function
* @description
* Converts string to lowercase.
* @see angular.lowercase
*/
var lowercaseFilter = valueFn(lowercase);
/**
* @ngdoc filter
* @name ng.filter:uppercase
* @function
* @description
* Converts string to uppercase.
* @see angular.uppercase
*/
var uppercaseFilter = valueFn(uppercase);
/**
* @ngdoc function
* @name ng.filter:limitTo
* @function
*
* @description
* Creates a new array or string containing only a specified number of elements. The elements
* are taken from either the beginning or the end of the source array or string, as specified by
* the value and sign (positive or negative) of `limit`.
*
* @param {Array|string} input Source array or string to be limited.
* @param {string|number} limit The length of the returned array or string. If the `limit` number
* is positive, `limit` number of items from the beginning of the source array/string are copied.
* If the number is negative, `limit` number of items from the end of the source array/string
* are copied. The `limit` will be trimmed if it exceeds `array.length`
* @returns {Array|string} A new sub-array or substring of length `limit` or less if input array
* had less than `limit` elements.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.numbers = [1,2,3,4,5,6,7,8,9];
$scope.letters = "abcdefghi";
$scope.numLimit = 3;
$scope.letterLimit = 3;
}
</script>
<div ng-controller="Ctrl">
Limit {{numbers}} to: <input type="integer" ng-model="numLimit">
<p>Output numbers: {{ numbers | limitTo:numLimit }}</p>
Limit {{letters}} to: <input type="integer" ng-model="letterLimit">
<p>Output letters: {{ letters | limitTo:letterLimit }}</p>
</div>
</doc:source>
<doc:scenario>
it('should limit the number array to first three items', function() {
expect(element('.doc-example-live input[ng-model=numLimit]').val()).toBe('3');
expect(element('.doc-example-live input[ng-model=letterLimit]').val()).toBe('3');
expect(binding('numbers | limitTo:numLimit')).toEqual('[1,2,3]');
expect(binding('letters | limitTo:letterLimit')).toEqual('abc');
});
it('should update the output when -3 is entered', function() {
input('numLimit').enter(-3);
input('letterLimit').enter(-3);
expect(binding('numbers | limitTo:numLimit')).toEqual('[7,8,9]');
expect(binding('letters | limitTo:letterLimit')).toEqual('ghi');
});
it('should not exceed the maximum size of input array', function() {
input('numLimit').enter(100);
input('letterLimit').enter(100);
expect(binding('numbers | limitTo:numLimit')).toEqual('[1,2,3,4,5,6,7,8,9]');
expect(binding('letters | limitTo:letterLimit')).toEqual('abcdefghi');
});
</doc:scenario>
</doc:example>
*/
function limitToFilter() {
return function (input, limit) {
if (!isArray(input) && !isString(input)) return input;
limit = int(limit);
if (isString(input)) {
//NaN check on limit
if (limit) {
return limit >= 0
? input.slice(0, limit)
: input.slice(limit, input.length);
} else {
return "";
}
}
var out = [],
i,
n;
// if abs(limit) exceeds maximum length, trim it
if (limit > input.length) limit = input.length;
else if (limit < -input.length) limit = -input.length;
if (limit > 0) {
i = 0;
n = limit;
} else {
i = input.length + limit;
n = input.length;
}
for (; i < n; i++) {
out.push(input[i]);
}
return out;
};
}
/**
* @ngdoc function
* @name ng.filter:orderBy
* @function
*
* @description
* Orders a specified `array` by the `expression` predicate.
*
* @param {Array} array The array to sort.
* @param {function(*)|string|Array.<(function(*)|string)>} expression A predicate to be
* used by the comparator to determine the order of elements.
*
* Can be one of:
*
* - `function`: Getter function. The result of this function will be sorted using the
* `<`, `=`, `>` operator.
* - `string`: An Angular expression which evaluates to an object to order by, such as 'name'
* to sort by a property called 'name'. Optionally prefixed with `+` or `-` to control
* ascending or descending sort order (for example, +name or -name).
* - `Array`: An array of function or string predicates. The first predicate in the array
* is used for sorting, but when two items are equivalent, the next predicate is used.
*
* @param {boolean=} reverse Reverse the order the array.
* @returns {Array} Sorted copy of the source array.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.friends =
[{name:'John', phone:'555-1212', age:10},
{name:'Mary', phone:'555-9876', age:19},
{name:'Mike', phone:'555-4321', age:21},
{name:'Adam', phone:'555-5678', age:35},
{name:'Julie', phone:'555-8765', age:29}]
$scope.predicate = '-age';
}
</script>
<div ng-controller="Ctrl">
<pre>Sorting predicate = {{predicate}}; reverse = {{reverse}}</pre>
<hr/>
[ <a href="" ng-click="predicate=''">unsorted</a> ]
<table class="friend">
<tr>
<th><a href="" ng-click="predicate = 'name'; reverse=false">Name</a>
(<a href="" ng-click="predicate = '-name'; reverse=false">^</a>)</th>
<th><a href="" ng-click="predicate = 'phone'; reverse=!reverse">Phone Number</a></th>
<th><a href="" ng-click="predicate = 'age'; reverse=!reverse">Age</a></th>
</tr>
<tr ng-repeat="friend in friends | orderBy:predicate:reverse">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
<td>{{friend.age}}</td>
</tr>
</table>
</div>
</doc:source>
<doc:scenario>
it('should be reverse ordered by aged', function() {
expect(binding('predicate')).toBe('-age');
expect(repeater('table.friend', 'friend in friends').column('friend.age')).
toEqual(['35', '29', '21', '19', '10']);
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Adam', 'Julie', 'Mike', 'Mary', 'John']);
});
it('should reorder the table when user selects different predicate', function() {
element('.doc-example-live a:contains("Name")').click();
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Adam', 'John', 'Julie', 'Mary', 'Mike']);
expect(repeater('table.friend', 'friend in friends').column('friend.age')).
toEqual(['35', '10', '29', '19', '21']);
element('.doc-example-live a:contains("Phone")').click();
expect(repeater('table.friend', 'friend in friends').column('friend.phone')).
toEqual(['555-9876', '555-8765', '555-5678', '555-4321', '555-1212']);
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Julie', 'Adam', 'Mike', 'John']);
});
</doc:scenario>
</doc:example>
*/
orderByFilter.$inject = ["$parse"];
function orderByFilter($parse) {
return function (array, sortPredicate, reverseOrder) {
if (!isArray(array)) return array;
if (!sortPredicate) return array;
sortPredicate = isArray(sortPredicate) ? sortPredicate : [sortPredicate];
sortPredicate = map(sortPredicate, function (predicate) {
var descending = false,
get = predicate || identity;
if (isString(predicate)) {
if (predicate.charAt(0) == "+" || predicate.charAt(0) == "-") {
descending = predicate.charAt(0) == "-";
predicate = predicate.substring(1);
}
get = $parse(predicate);
}
return reverseComparator(function (a, b) {
return compare(get(a), get(b));
}, descending);
});
var arrayCopy = [];
for (var i = 0; i < array.length; i++) {
arrayCopy.push(array[i]);
}
return arrayCopy.sort(reverseComparator(comparator, reverseOrder));
function comparator(o1, o2) {
for (var i = 0; i < sortPredicate.length; i++) {
var comp = sortPredicate[i](o1, o2);
if (comp !== 0) return comp;
}
return 0;
}
function reverseComparator(comp, descending) {
return toBoolean(descending)
? function (a, b) {
return comp(b, a);
}
: comp;
}
function compare(v1, v2) {
var t1 = typeof v1;
var t2 = typeof v2;
if (t1 == t2) {
if (t1 == "string") {
v1 = v1.toLowerCase();
v2 = v2.toLowerCase();
}
if (v1 === v2) return 0;
return v1 < v2 ? -1 : 1;
} else {
return t1 < t2 ? -1 : 1;
}
}
};
}
function ngDirective(directive) {
if (isFunction(directive)) {
directive = {
link: directive,
};
}
directive.restrict = directive.restrict || "AC";
return valueFn(directive);
}
/**
* @ngdoc directive
* @name ng.directive:a
* @restrict E
*
* @description
* Modifies the default behavior of the html A tag so that the default action is prevented when
* the href attribute is empty.
*
* This change permits the easy creation of action links with the `ngClick` directive
* without changing the location or causing page reloads, e.g.:
* `<a href="" ng-click="list.addItem()">Add Item</a>`
*/
var htmlAnchorDirective = valueFn({
restrict: "E",
compile: function (element, attr) {
if (msie <= 8) {
// turn <a href ng-click="..">link</a> into a stylable link in IE
// but only if it doesn't have name attribute, in which case it's an anchor
if (!attr.href && !attr.name) {
attr.$set("href", "");
}
// add a comment node to anchors to workaround IE bug that causes element content to be reset
// to new attribute content if attribute is updated with value containing @ and element also
// contains value with @
// see issue #1949
element.append(document.createComment("IE fix"));
}
if (!attr.href && !attr.name) {
return function (scope, element) {
element.on("click", function (event) {
// if we have no href url, then don't navigate anywhere.
if (!element.attr("href")) {
event.preventDefault();
}
});
};
}
},
});
/**
* @ngdoc directive
* @name ng.directive:ngHref
* @restrict A
*
* @description
* Using Angular markup like `{{hash}}` in an href attribute will
* make the link go to the wrong URL if the user clicks it before
* Angular has a chance to replace the `{{hash}}` markup with its
* value. Until Angular replaces the markup the link will be broken
* and will most likely return a 404 error.
*
* The `ngHref` directive solves this problem.
*
* The wrong way to write it:
* <pre>
* <a href="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* The correct way to write it:
* <pre>
* <a ng-href="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* @element A
* @param {template} ngHref any string which can contain `{{}}` markup.
*
* @example
* This example shows various combinations of `href`, `ng-href` and `ng-click` attributes
* in links and their different behaviors:
<doc:example>
<doc:source>
<input ng-model="value" /><br />
<a id="link-1" href ng-click="value = 1">link 1</a> (link, don't reload)<br />
<a id="link-2" href="" ng-click="value = 2">link 2</a> (link, don't reload)<br />
<a id="link-3" ng-href="/{{'123'}}">link 3</a> (link, reload!)<br />
<a id="link-4" href="" name="xx" ng-click="value = 4">anchor</a> (link, don't reload)<br />
<a id="link-5" name="xxx" ng-click="value = 5">anchor</a> (no link)<br />
<a id="link-6" ng-href="{{value}}">link</a> (link, change location)
</doc:source>
<doc:scenario>
it('should execute ng-click but not reload when href without value', function() {
element('#link-1').click();
expect(input('value').val()).toEqual('1');
expect(element('#link-1').attr('href')).toBe("");
});
it('should execute ng-click but not reload when href empty string', function() {
element('#link-2').click();
expect(input('value').val()).toEqual('2');
expect(element('#link-2').attr('href')).toBe("");
});
it('should execute ng-click and change url when ng-href specified', function() {
expect(element('#link-3').attr('href')).toBe("/123");
element('#link-3').click();
expect(browser().window().path()).toEqual('/123');
});
it('should execute ng-click but not reload when href empty string and name specified', function() {
element('#link-4').click();
expect(input('value').val()).toEqual('4');
expect(element('#link-4').attr('href')).toBe('');
});
it('should execute ng-click but not reload when no href but name specified', function() {
element('#link-5').click();
expect(input('value').val()).toEqual('5');
expect(element('#link-5').attr('href')).toBe(undefined);
});
it('should only change url when only ng-href', function() {
input('value').enter('6');
expect(element('#link-6').attr('href')).toBe('6');
element('#link-6').click();
expect(browser().location().url()).toEqual('/6');
});
</doc:scenario>
</doc:example>
*/
/**
* @ngdoc directive
* @name ng.directive:ngSrc
* @restrict A
*
* @description
* Using Angular markup like `{{hash}}` in a `src` attribute doesn't
* work right: The browser will fetch from the URL with the literal
* text `{{hash}}` until Angular replaces the expression inside
* `{{hash}}`. The `ngSrc` directive solves this problem.
*
* The buggy way to write it:
* <pre>
* <img src="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* The correct way to write it:
* <pre>
* <img ng-src="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* @element IMG
* @param {template} ngSrc any string which can contain `{{}}` markup.
*/
/**
* @ngdoc directive
* @name ng.directive:ngSrcset
* @restrict A
*
* @description
* Using Angular markup like `{{hash}}` in a `srcset` attribute doesn't
* work right: The browser will fetch from the URL with the literal
* text `{{hash}}` until Angular replaces the expression inside
* `{{hash}}`. The `ngSrcset` directive solves this problem.
*
* The buggy way to write it:
* <pre>
* <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x"/>
* </pre>
*
* The correct way to write it:
* <pre>
* <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x"/>
* </pre>
*
* @element IMG
* @param {template} ngSrcset any string which can contain `{{}}` markup.
*/
/**
* @ngdoc directive
* @name ng.directive:ngDisabled
* @restrict A
*
* @description
*
* The following markup will make the button enabled on Chrome/Firefox but not on IE8 and older IEs:
* <pre>
* <div ng-init="scope = { isDisabled: false }">
* <button disabled="{{scope.isDisabled}}">Disabled</button>
* </div>
* </pre>
*
* The HTML specification does not require browsers to preserve the values of boolean attributes
* such as disabled. (Their presence means true and their absence means false.)
* If we put an Angular interpolation expression into such an attribute then the
* binding information would be lost when the browser removes the attribute.
* The `ngDisabled` directive solves this problem for the `disabled` attribute.
* This complementary directive is not removed by the browser and so provides
* a permanent reliable place to store the binding information.
*
* @example
<doc:example>
<doc:source>
Click me to toggle: <input type="checkbox" ng-model="checked"><br/>
<button ng-model="button" ng-disabled="checked">Button</button>
</doc:source>
<doc:scenario>
it('should toggle button', function() {
expect(element('.doc-example-live :button').prop('disabled')).toBeFalsy();
input('checked').check();
expect(element('.doc-example-live :button').prop('disabled')).toBeTruthy();
});
</doc:scenario>
</doc:example>
*
* @element INPUT
* @param {expression} ngDisabled If the {@link guide/expression expression} is truthy,
* then special attribute "disabled" will be set on the element
*/
/**
* @ngdoc directive
* @name ng.directive:ngChecked
* @restrict A
*
* @description
* The HTML specification does not require browsers to preserve the values of boolean attributes
* such as checked. (Their presence means true and their absence means false.)
* If we put an Angular interpolation expression into such an attribute then the
* binding information would be lost when the browser removes the attribute.
* The `ngChecked` directive solves this problem for the `checked` attribute.
* This complementary directive is not removed by the browser and so provides
* a permanent reliable place to store the binding information.
* @example
<doc:example>
<doc:source>
Check me to check both: <input type="checkbox" ng-model="master"><br/>
<input id="checkSlave" type="checkbox" ng-checked="master">
</doc:source>
<doc:scenario>
it('should check both checkBoxes', function() {
expect(element('.doc-example-live #checkSlave').prop('checked')).toBeFalsy();
input('master').check();
expect(element('.doc-example-live #checkSlave').prop('checked')).toBeTruthy();
});
</doc:scenario>
</doc:example>
*
* @element INPUT
* @param {expression} ngChecked If the {@link guide/expression expression} is truthy,
* then special attribute "checked" will be set on the element
*/
/**
* @ngdoc directive
* @name ng.directive:ngReadonly
* @restrict A
*
* @description
* The HTML specification does not require browsers to preserve the values of boolean attributes
* such as readonly. (Their presence means true and their absence means false.)
* If we put an Angular interpolation expression into such an attribute then the
* binding information would be lost when the browser removes the attribute.
* The `ngReadonly` directive solves this problem for the `readonly` attribute.
* This complementary directive is not removed by the browser and so provides
* a permanent reliable place to store the binding information.
* @example
<doc:example>
<doc:source>
Check me to make text readonly: <input type="checkbox" ng-model="checked"><br/>
<input type="text" ng-readonly="checked" value="I'm Angular"/>
</doc:source>
<doc:scenario>
it('should toggle readonly attr', function() {
expect(element('.doc-example-live :text').prop('readonly')).toBeFalsy();
input('checked').check();
expect(element('.doc-example-live :text').prop('readonly')).toBeTruthy();
});
</doc:scenario>
</doc:example>
*
* @element INPUT
* @param {expression} ngReadonly If the {@link guide/expression expression} is truthy,
* then special attribute "readonly" will be set on the element
*/
/**
* @ngdoc directive
* @name ng.directive:ngSelected
* @restrict A
*
* @description
* The HTML specification does not require browsers to preserve the values of boolean attributes
* such as selected. (Their presence means true and their absence means false.)
* If we put an Angular interpolation expression into such an attribute then the
* binding information would be lost when the browser removes the attribute.
* The `ngSelected` directive solves this problem for the `selected` atttribute.
* This complementary directive is not removed by the browser and so provides
* a permanent reliable place to store the binding information.
* @example
<doc:example>
<doc:source>
Check me to select: <input type="checkbox" ng-model="selected"><br/>
<select>
<option>Hello!</option>
<option id="greet" ng-selected="selected">Greetings!</option>
</select>
</doc:source>
<doc:scenario>
it('should select Greetings!', function() {
expect(element('.doc-example-live #greet').prop('selected')).toBeFalsy();
input('selected').check();
expect(element('.doc-example-live #greet').prop('selected')).toBeTruthy();
});
</doc:scenario>
</doc:example>
*
* @element OPTION
* @param {expression} ngSelected If the {@link guide/expression expression} is truthy,
* then special attribute "selected" will be set on the element
*/
/**
* @ngdoc directive
* @name ng.directive:ngOpen
* @restrict A
*
* @description
* The HTML specification does not require browsers to preserve the values of boolean attributes
* such as open. (Their presence means true and their absence means false.)
* If we put an Angular interpolation expression into such an attribute then the
* binding information would be lost when the browser removes the attribute.
* The `ngOpen` directive solves this problem for the `open` attribute.
* This complementary directive is not removed by the browser and so provides
* a permanent reliable place to store the binding information.
*
* @example
<doc:example>
<doc:source>
Check me check multiple: <input type="checkbox" ng-model="open"><br/>
<details id="details" ng-open="open">
<summary>Show/Hide me</summary>
</details>
</doc:source>
<doc:scenario>
it('should toggle open', function() {
expect(element('#details').prop('open')).toBeFalsy();
input('open').check();
expect(element('#details').prop('open')).toBeTruthy();
});
</doc:scenario>
</doc:example>
*
* @element DETAILS
* @param {expression} ngOpen If the {@link guide/expression expression} is truthy,
* then special attribute "open" will be set on the element
*/
var ngAttributeAliasDirectives = {};
// boolean attrs are evaluated
forEach(BOOLEAN_ATTR, function (propName, attrName) {
// binding to multiple is not supported
if (propName == "multiple") return;
var normalized = directiveNormalize("ng-" + attrName);
ngAttributeAliasDirectives[normalized] = function () {
return {
priority: 100,
compile: function () {
return function (scope, element, attr) {
scope.$watch(
attr[normalized],
function ngBooleanAttrWatchAction(value) {
attr.$set(attrName, !!value);
},
);
};
},
};
};
});
// ng-src, ng-srcset, ng-href are interpolated
forEach(["src", "srcset", "href"], function (attrName) {
var normalized = directiveNormalize("ng-" + attrName);
ngAttributeAliasDirectives[normalized] = function () {
return {
priority: 99, // it needs to run after the attributes are interpolated
link: function (scope, element, attr) {
attr.$observe(normalized, function (value) {
if (!value) return;
attr.$set(attrName, value);
// on IE, if "ng:src" directive declaration is used and "src" attribute doesn't exist
// then calling element.setAttribute('src', 'foo') doesn't do anything, so we need
// to set the property as well to achieve the desired effect.
// we use attr[attrName] value since $set can sanitize the url.
if (msie) element.prop(attrName, attr[attrName]);
});
},
};
};
});
/* global -nullFormCtrl */
var nullFormCtrl = {
$addControl: noop,
$removeControl: noop,
$setValidity: noop,
$setDirty: noop,
$setPristine: noop,
};
/**
* @ngdoc object
* @name ng.directive:form.FormController
*
* @property {boolean} $pristine True if user has not interacted with the form yet.
* @property {boolean} $dirty True if user has already interacted with the form.
* @property {boolean} $valid True if all of the containing forms and controls are valid.
* @property {boolean} $invalid True if at least one containing control or form is invalid.
*
* @property {Object} $error Is an object hash, containing references to all invalid controls or
* forms, where:
*
* - keys are validation tokens (error names),
* - values are arrays of controls or forms that are invalid for given error name.
*
*
* Built-in validation tokens:
*
* - `email`
* - `max`
* - `maxlength`
* - `min`
* - `minlength`
* - `number`
* - `pattern`
* - `required`
* - `url`
*
* @description
* `FormController` keeps track of all its controls and nested forms as well as state of them,
* such as being valid/invalid or dirty/pristine.
*
* Each {@link ng.directive:form form} directive creates an instance
* of `FormController`.
*
*/
//asks for $scope to fool the BC controller module
FormController.$inject = ["$element", "$attrs", "$scope"];
function FormController(element, attrs) {
var form = this,
parentForm = element.parent().controller("form") || nullFormCtrl,
invalidCount = 0, // used to easily determine if we are valid
errors = (form.$error = {}),
controls = [];
// init state
form.$name = attrs.name || attrs.ngForm;
form.$dirty = false;
form.$pristine = true;
form.$valid = true;
form.$invalid = false;
parentForm.$addControl(form);
// Setup initial state of the control
element.addClass(PRISTINE_CLASS);
toggleValidCss(true);
// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
validationErrorKey = validationErrorKey
? "-" + snake_case(validationErrorKey, "-")
: "";
element
.removeClass(
(isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey,
)
.addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
}
/**
* @ngdoc function
* @name ng.directive:form.FormController#$addControl
* @methodOf ng.directive:form.FormController
*
* @description
* Register a control with the form.
*
* Input elements using ngModelController do this automatically when they are linked.
*/
form.$addControl = function (control) {
// Breaking change - before, inputs whose name was "hasOwnProperty" were quietly ignored
// and not added to the scope. Now we throw an error.
assertNotHasOwnProperty(control.$name, "input");
controls.push(control);
if (control.$name) {
form[control.$name] = control;
}
};
/**
* @ngdoc function
* @name ng.directive:form.FormController#$removeControl
* @methodOf ng.directive:form.FormController
*
* @description
* Deregister a control from the form.
*
* Input elements using ngModelController do this automatically when they are destroyed.
*/
form.$removeControl = function (control) {
if (control.$name && form[control.$name] === control) {
delete form[control.$name];
}
forEach(errors, function (queue, validationToken) {
form.$setValidity(validationToken, true, control);
});
arrayRemove(controls, control);
};
/**
* @ngdoc function
* @name ng.directive:form.FormController#$setValidity
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the validity of a form control.
*
* This method will also propagate to parent forms.
*/
form.$setValidity = function (validationToken, isValid, control) {
var queue = errors[validationToken];
if (isValid) {
if (queue) {
arrayRemove(queue, control);
if (!queue.length) {
invalidCount--;
if (!invalidCount) {
toggleValidCss(isValid);
form.$valid = true;
form.$invalid = false;
}
errors[validationToken] = false;
toggleValidCss(true, validationToken);
parentForm.$setValidity(validationToken, true, form);
}
}
} else {
if (!invalidCount) {
toggleValidCss(isValid);
}
if (queue) {
if (includes(queue, control)) return;
} else {
errors[validationToken] = queue = [];
invalidCount++;
toggleValidCss(false, validationToken);
parentForm.$setValidity(validationToken, false, form);
}
queue.push(control);
form.$valid = false;
form.$invalid = true;
}
};
/**
* @ngdoc function
* @name ng.directive:form.FormController#$setDirty
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the form to a dirty state.
*
* This method can be called to add the 'ng-dirty' class and set the form to a dirty
* state (ng-dirty class). This method will also propagate to parent forms.
*/
form.$setDirty = function () {
element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
form.$dirty = true;
form.$pristine = false;
parentForm.$setDirty();
};
/**
* @ngdoc function
* @name ng.directive:form.FormController#$setPristine
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the form to its pristine state.
*
* This method can be called to remove the 'ng-dirty' class and set the form to its pristine
* state (ng-pristine class). This method will also propagate to all the controls contained
* in this form.
*
* Setting a form back to a pristine state is often useful when we want to 'reuse' a form after
* saving or resetting it.
*/
form.$setPristine = function () {
element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS);
form.$dirty = false;
form.$pristine = true;
forEach(controls, function (control) {
control.$setPristine();
});
};
}
/**
* @ngdoc directive
* @name ng.directive:ngForm
* @restrict EAC
*
* @description
* Nestable alias of {@link ng.directive:form `form`} directive. HTML
* does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a
* sub-group of controls needs to be determined.
*
* @param {string=} ngForm|name Name of the form. If specified, the form controller will be published into
* related scope, under this name.
*
*/
/**
* @ngdoc directive
* @name ng.directive:form
* @restrict E
*
* @description
* Directive that instantiates
* {@link ng.directive:form.FormController FormController}.
*
* If the `name` attribute is specified, the form controller is published onto the current scope under
* this name.
*
* # Alias: {@link ng.directive:ngForm `ngForm`}
*
* In Angular forms can be nested. This means that the outer form is valid when all of the child
* forms are valid as well. However, browsers do not allow nesting of `<form>` elements, so
* Angular provides the {@link ng.directive:ngForm `ngForm`} directive which behaves identically to
* `<form>` but can be nested. This allows you to have nested forms, which is very useful when
* using Angular validation directives in forms that are dynamically generated using the
* {@link ng.directive:ngRepeat `ngRepeat`} directive. Since you cannot dynamically generate the `name`
* attribute of input elements using interpolation, you have to wrap each set of repeated inputs in an
* `ngForm` directive and nest these in an outer `form` element.
*
*
* # CSS classes
* - `ng-valid` Is set if the form is valid.
* - `ng-invalid` Is set if the form is invalid.
* - `ng-pristine` Is set if the form is pristine.
* - `ng-dirty` Is set if the form is dirty.
*
*
* # Submitting a form and preventing the default action
*
* Since the role of forms in client-side Angular applications is different than in classical
* roundtrip apps, it is desirable for the browser not to translate the form submission into a full
* page reload that sends the data to the server. Instead some javascript logic should be triggered
* to handle the form submission in an application-specific way.
*
* For this reason, Angular prevents the default action (form submission to the server) unless the
* `<form>` element has an `action` attribute specified.
*
* You can use one of the following two ways to specify what javascript method should be called when
* a form is submitted:
*
* - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
* - {@link ng.directive:ngClick ngClick} directive on the first
* button or input field of type submit (input[type=submit])
*
* To prevent double execution of the handler, use only one of the {@link ng.directive:ngSubmit ngSubmit}
* or {@link ng.directive:ngClick ngClick} directives.
* This is because of the following form submission rules in the HTML specification:
*
* - If a form has only one input field then hitting enter in this field triggers form submit
* (`ngSubmit`)
* - if a form has 2+ input fields and no buttons or input[type=submit] then hitting enter
* doesn't trigger submit
* - if a form has one or more input fields and one or more buttons or input[type=submit] then
* hitting enter in any of the input fields will trigger the click handler on the *first* button or
* input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`)
*
* @param {string=} name Name of the form. If specified, the form controller will be published into
* related scope, under this name.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.userType = 'guest';
}
</script>
<form name="myForm" ng-controller="Ctrl">
userType: <input name="input" ng-model="userType" required>
<span class="error" ng-show="myForm.input.$error.required">Required!</span><br>
<tt>userType = {{userType}}</tt><br>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('userType')).toEqual('guest');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('userType').enter('');
expect(binding('userType')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/
var formDirectiveFactory = function (isNgForm) {
return [
"$timeout",
function ($timeout) {
var formDirective = {
name: "form",
restrict: isNgForm ? "EAC" : "E",
controller: FormController,
compile: function () {
return {
pre: function (scope, formElement, attr, controller) {
if (!attr.action) {
// we can't use jq events because if a form is destroyed during submission the default
// action is not prevented. see #1238
//
// IE 9 is not affected because it doesn't fire a submit event and try to do a full
// page reload if the form was destroyed by submission of the form via a click handler
// on a button in the form. Looks like an IE9 specific bug.
var preventDefaultListener = function (event) {
event.preventDefault
? event.preventDefault()
: (event.returnValue = false); // IE
};
addEventListenerFn(
formElement[0],
"submit",
preventDefaultListener,
);
// unregister the preventDefault listener so that we don't not leak memory but in a
// way that will achieve the prevention of the default action.
formElement.on("$destroy", function () {
$timeout(
function () {
removeEventListenerFn(
formElement[0],
"submit",
preventDefaultListener,
);
},
0,
false,
);
});
}
var parentFormCtrl = formElement.parent().controller("form"),
alias = attr.name || attr.ngForm;
if (alias) {
setter(scope, alias, controller, alias);
}
if (parentFormCtrl) {
formElement.on("$destroy", function () {
parentFormCtrl.$removeControl(controller);
if (alias) {
setter(scope, alias, undefined, alias);
}
extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
});
}
},
};
},
};
return formDirective;
},
];
};
var formDirective = formDirectiveFactory();
var ngFormDirective = formDirectiveFactory(true);
/* global
-VALID_CLASS,
-INVALID_CLASS,
-PRISTINE_CLASS,
-DIRTY_CLASS
*/
var URL_REGEXP =
/^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/;
var EMAIL_REGEXP = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}$/;
var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;
var inputType = {
/**
* @ngdoc inputType
* @name ng.directive:input.text
*
* @description
* Standard HTML text input with angular data binding.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Adds `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
* @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'guest';
$scope.word = /^\s*\w*\s*$/;
}
</script>
<form name="myForm" ng-controller="Ctrl">
Single word: <input type="text" name="input" ng-model="text"
ng-pattern="word" required ng-trim="false">
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.pattern">
Single word only!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('guest');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if multi word', function() {
input('text').enter('hello world');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should not be trimmed', function() {
input('text').enter('untrimmed ');
expect(binding('text')).toEqual('untrimmed ');
expect(binding('myForm.input.$valid')).toEqual('true');
});
</doc:scenario>
</doc:example>
*/
text: textInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.number
*
* @description
* Text input with number validation and transformation. Sets the `number` validation
* error if not a valid number.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
* @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.value = 12;
}
</script>
<form name="myForm" ng-controller="Ctrl">
Number: <input type="number" name="input" ng-model="value"
min="0" max="99" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.number">
Not valid number!</span>
<tt>value = {{value}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('value')).toEqual('12');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('value').enter('');
expect(binding('value')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if over max', function() {
input('value').enter('123');
expect(binding('value')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/
number: numberInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.url
*
* @description
* Text input with URL validation. Sets the `url` validation error key if the content is not a
* valid URL.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'http://google.com';
}
</script>
<form name="myForm" ng-controller="Ctrl">
URL: <input type="url" name="input" ng-model="text" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.url">
Not valid url!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
<tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('http://google.com');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if not url', function() {
input('text').enter('xxx');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/
url: urlInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.email
*
* @description
* Text input with email validation. Sets the `email` validation error key if not a valid email
* address.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'me@example.com';
}
</script>
<form name="myForm" ng-controller="Ctrl">
Email: <input type="email" name="input" ng-model="text" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.email">
Not valid email!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
<tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('me@example.com');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if not email', function() {
input('text').enter('xxx');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/
email: emailInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.radio
*
* @description
* HTML radio button.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string} value The value to which the expression should be set when selected.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.color = 'blue';
}
</script>
<form name="myForm" ng-controller="Ctrl">
<input type="radio" ng-model="color" value="red"> Red <br/>
<input type="radio" ng-model="color" value="green"> Green <br/>
<input type="radio" ng-model="color" value="blue"> Blue <br/>
<tt>color = {{color}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should change state', function() {
expect(binding('color')).toEqual('blue');
input('color').select('red');
expect(binding('color')).toEqual('red');
});
</doc:scenario>
</doc:example>
*/
radio: radioInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.checkbox
*
* @description
* HTML checkbox.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} ngTrueValue The value to which the expression should be set when selected.
* @param {string=} ngFalseValue The value to which the expression should be set when not selected.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.value1 = true;
$scope.value2 = 'YES'
}
</script>
<form name="myForm" ng-controller="Ctrl">
Value1: <input type="checkbox" ng-model="value1"> <br/>
Value2: <input type="checkbox" ng-model="value2"
ng-true-value="YES" ng-false-value="NO"> <br/>
<tt>value1 = {{value1}}</tt><br/>
<tt>value2 = {{value2}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should change state', function() {
expect(binding('value1')).toEqual('true');
expect(binding('value2')).toEqual('YES');
input('value1').check();
input('value2').check();
expect(binding('value1')).toEqual('false');
expect(binding('value2')).toEqual('NO');
});
</doc:scenario>
</doc:example>
*/
checkbox: checkboxInputType,
hidden: noop,
button: noop,
submit: noop,
reset: noop,
};
function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
// In composition mode, users are still inputing intermediate text buffer,
// hold the listener until composition is done.
// More about composition events: https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent
var composing = false;
element.on("compositionstart", function () {
composing = true;
});
element.on("compositionend", function () {
composing = false;
});
var listener = function () {
if (composing) return;
var value = element.val();
// By default we will trim the value
// If the attribute ng-trim exists we will avoid trimming
// e.g. <input ng-model="foo" ng-trim="false">
if (toBoolean(attr.ngTrim || "T")) {
value = trim(value);
}
if (ctrl.$viewValue !== value) {
scope.$apply(function () {
ctrl.$setViewValue(value);
});
}
};
// if the browser does support "input" event, we are fine - except on IE9 which doesn't fire the
// input event on backspace, delete or cut
if ($sniffer.hasEvent("input")) {
element.on("input", listener);
} else {
var timeout;
var deferListener = function () {
if (!timeout) {
timeout = $browser.defer(function () {
listener();
timeout = null;
});
}
};
element.on("keydown", function (event) {
var key = event.keyCode;
// ignore
// command modifiers arrows
if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40))
return;
deferListener();
});
// if user modifies input value using context menu in IE, we need "paste" and "cut" events to catch it
if ($sniffer.hasEvent("paste")) {
element.on("paste cut", deferListener);
}
}
// if user paste into input using mouse on older browser
// or form autocomplete on newer browser, we need "change" event to catch it
element.on("change", listener);
ctrl.$render = function () {
element.val(ctrl.$isEmpty(ctrl.$viewValue) ? "" : ctrl.$viewValue);
};
// pattern validator
var pattern = attr.ngPattern,
patternValidator,
match;
var validate = function (regexp, value) {
if (ctrl.$isEmpty(value) || regexp.test(value)) {
ctrl.$setValidity("pattern", true);
return value;
} else {
ctrl.$setValidity("pattern", false);
return undefined;
}
};
if (pattern) {
match = pattern.match(/^\/(.*)\/([gim]*)$/);
if (match) {
pattern = new RegExp(match[1], match[2]);
patternValidator = function (value) {
return validate(pattern, value);
};
} else {
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);
}
// min length validator
if (attr.ngMinlength) {
var minlength = int(attr.ngMinlength);
var minLengthValidator = function (value) {
if (!ctrl.$isEmpty(value) && value.length < minlength) {
ctrl.$setValidity("minlength", false);
return undefined;
} else {
ctrl.$setValidity("minlength", true);
return value;
}
};
ctrl.$parsers.push(minLengthValidator);
ctrl.$formatters.push(minLengthValidator);
}
// max length validator
if (attr.ngMaxlength) {
var maxlength = int(attr.ngMaxlength);
var maxLengthValidator = function (value) {
if (!ctrl.$isEmpty(value) && value.length > maxlength) {
ctrl.$setValidity("maxlength", false);
return undefined;
} else {
ctrl.$setValidity("maxlength", true);
return value;
}
};
ctrl.$parsers.push(maxLengthValidator);
ctrl.$formatters.push(maxLengthValidator);
}
}
function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
textInputType(scope, element, attr, ctrl, $sniffer, $browser);
ctrl.$parsers.push(function (value) {
var empty = ctrl.$isEmpty(value);
if (empty || NUMBER_REGEXP.test(value)) {
ctrl.$setValidity("number", true);
return value === "" ? null : empty ? value : parseFloat(value);
} else {
ctrl.$setValidity("number", false);
return undefined;
}
});
ctrl.$formatters.push(function (value) {
return ctrl.$isEmpty(value) ? "" : "" + value;
});
if (attr.min) {
var minValidator = function (value) {
var min = parseFloat(attr.min);
if (!ctrl.$isEmpty(value) && value < min) {
ctrl.$setValidity("min", false);
return undefined;
} else {
ctrl.$setValidity("min", true);
return value;
}
};
ctrl.$parsers.push(minValidator);
ctrl.$formatters.push(minValidator);
}
if (attr.max) {
var maxValidator = function (value) {
var max = parseFloat(attr.max);
if (!ctrl.$isEmpty(value) && value > max) {
ctrl.$setValidity("max", false);
return undefined;
} else {
ctrl.$setValidity("max", true);
return value;
}
};
ctrl.$parsers.push(maxValidator);
ctrl.$formatters.push(maxValidator);
}
ctrl.$formatters.push(function (value) {
if (ctrl.$isEmpty(value) || isNumber(value)) {
ctrl.$setValidity("number", true);
return value;
} else {
ctrl.$setValidity("number", false);
return undefined;
}
});
}
function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
textInputType(scope, element, attr, ctrl, $sniffer, $browser);
var urlValidator = function (value) {
if (ctrl.$isEmpty(value) || URL_REGEXP.test(value)) {
ctrl.$setValidity("url", true);
return value;
} else {
ctrl.$setValidity("url", false);
return undefined;
}
};
ctrl.$formatters.push(urlValidator);
ctrl.$parsers.push(urlValidator);
}
function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
textInputType(scope, element, attr, ctrl, $sniffer, $browser);
var emailValidator = function (value) {
if (ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value)) {
ctrl.$setValidity("email", true);
return value;
} else {
ctrl.$setValidity("email", false);
return undefined;
}
};
ctrl.$formatters.push(emailValidator);
ctrl.$parsers.push(emailValidator);
}
function radioInputType(scope, element, attr, ctrl) {
// make the name unique, if not defined
if (isUndefined(attr.name)) {
element.attr("name", nextUid());
}
element.on("click", function () {
if (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);
}
function checkboxInputType(scope, element, attr, ctrl) {
var trueValue = attr.ngTrueValue,
falseValue = attr.ngFalseValue;
if (!isString(trueValue)) trueValue = true;
if (!isString(falseValue)) falseValue = false;
element.on("click", function () {
scope.$apply(function () {
ctrl.$setViewValue(element[0].checked);
});
});
ctrl.$render = function () {
element[0].checked = ctrl.$viewValue;
};
// Override the standard `$isEmpty` because a value of `false` means empty in a checkbox.
ctrl.$isEmpty = function (value) {
return value !== trueValue;
};
ctrl.$formatters.push(function (value) {
return value === trueValue;
});
ctrl.$parsers.push(function (value) {
return value ? trueValue : falseValue;
});
}
/**
* @ngdoc directive
* @name ng.directive:textarea
* @restrict E
*
* @description
* HTML textarea element control with angular data-binding. The data-binding and validation
* properties of this element are exactly the same as those of the
* {@link ng.directive:input input element}.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*/
/**
* @ngdoc directive
* @name ng.directive:input
* @restrict E
*
* @description
* HTML input element control with angular data-binding. Input control follows HTML5 input types
* and polyfills the HTML5 validation behavior for older browsers.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {boolean=} ngRequired Sets `required` attribute if set to true
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.user = {name: 'guest', last: 'visitor'};
}
</script>
<div ng-controller="Ctrl">
<form name="myForm">
User name: <input type="text" name="userName" ng-model="user.name" required>
<span class="error" ng-show="myForm.userName.$error.required">
Required!</span><br>
Last name: <input type="text" name="lastName" ng-model="user.last"
ng-minlength="3" ng-maxlength="10">
<span class="error" ng-show="myForm.lastName.$error.minlength">
Too short!</span>
<span class="error" ng-show="myForm.lastName.$error.maxlength">
Too long!</span><br>
</form>
<hr>
<tt>user = {{user}}</tt><br/>
<tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br>
<tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br>
<tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br>
<tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
<tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br>
<tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br>
</div>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('user')).toEqual('{"name":"guest","last":"visitor"}');
expect(binding('myForm.userName.$valid')).toEqual('true');
expect(binding('myForm.$valid')).toEqual('true');
});
it('should be invalid if empty when required', function() {
input('user.name').enter('');
expect(binding('user')).toEqual('{"last":"visitor"}');
expect(binding('myForm.userName.$valid')).toEqual('false');
expect(binding('myForm.$valid')).toEqual('false');
});
it('should be valid if empty when min length is set', function() {
input('user.last').enter('');
expect(binding('user')).toEqual('{"name":"guest","last":""}');
expect(binding('myForm.lastName.$valid')).toEqual('true');
expect(binding('myForm.$valid')).toEqual('true');
});
it('should be invalid if less than required min length', function() {
input('user.last').enter('xx');
expect(binding('user')).toEqual('{"name":"guest"}');
expect(binding('myForm.lastName.$valid')).toEqual('false');
expect(binding('myForm.lastName.$error')).toMatch(/minlength/);
expect(binding('myForm.$valid')).toEqual('false');
});
it('should be invalid if longer than max length', function() {
input('user.last').enter('some ridiculously long name');
expect(binding('user'))
.toEqual('{"name":"guest"}');
expect(binding('myForm.lastName.$valid')).toEqual('false');
expect(binding('myForm.lastName.$error')).toMatch(/maxlength/);
expect(binding('myForm.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/
var inputDirective = [
"$browser",
"$sniffer",
function ($browser, $sniffer) {
return {
restrict: "E",
require: "?ngModel",
link: function (scope, element, attr, ctrl) {
if (ctrl) {
(inputType[lowercase(attr.type)] || inputType.text)(
scope,
element,
attr,
ctrl,
$sniffer,
$browser,
);
}
},
};
},
];
var VALID_CLASS = "ng-valid",
INVALID_CLASS = "ng-invalid",
PRISTINE_CLASS = "ng-pristine",
DIRTY_CLASS = "ng-dirty";
/**
* @ngdoc object
* @name ng.directive:ngModel.NgModelController
*
* @property {string} $viewValue Actual string value in the view.
* @property {*} $modelValue The value in the model, that the control is bound to.
* @property {Array.<Function>} $parsers Array of functions to execute, as a pipeline, whenever
the control reads value from the DOM. Each function is called, in turn, passing the value
through to the next. Used to sanitize / convert the value as well as validation.
For validation, the parsers should update the validity state using
{@link ng.directive:ngModel.NgModelController#methods_$setValidity $setValidity()},
and return `undefined` for invalid values.
*
* @property {Array.<Function>} $formatters Array of functions to execute, as a pipeline, whenever
the model value changes. Each function is called, in turn, passing the value through to the
next. Used to format / convert values for display in the control and validation.
* <pre>
* function formatter(value) {
* if (value) {
* return value.toUpperCase();
* }
* }
* ngModel.$formatters.push(formatter);
* </pre>
*
* @property {Array.<Function>} $viewChangeListeners Array of functions to execute whenever the
* view value has changed. It is called with no arguments, and its return value is ignored.
* This can be used in place of additional $watches against the model value.
*
* @property {Object} $error An object hash with all errors as keys.
*
* @property {boolean} $pristine True if user has not interacted with the control yet.
* @property {boolean} $dirty True if user has already interacted with the control.
* @property {boolean} $valid True if there is no error.
* @property {boolean} $invalid True if at least one error on the control.
*
* @description
*
* `NgModelController` provides API for the `ng-model` directive. The controller contains
* services for data-binding, validation, CSS updates, and value formatting and parsing. It
* purposefully does not contain any logic which deals with DOM rendering or listening to
* DOM events. Such DOM related logic should be provided by other directives which make use of
* `NgModelController` for data-binding.
*
* ## Custom Control Example
* This example shows how to use `NgModelController` with a custom control to achieve
* data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`)
* collaborate together to achieve the desired result.
*
* Note that `contenteditable` is an HTML5 attribute, which tells the browser to let the element
* contents be edited in place by the user. This will not work on older browsers.
*
* <example module="customControl">
<file name="style.css">
[contenteditable] {
border: 1px solid black;
background-color: white;
min-height: 20px;
}
.ng-invalid {
border: 1px solid red;
}
</file>
<file name="script.js">
angular.module('customControl', []).
directive('contenteditable', function() {
return {
restrict: 'A', // only activate on element attribute
require: '?ngModel', // get a hold of NgModelController
link: function(scope, element, attrs, ngModel) {
if(!ngModel) return; // do nothing if no ng-model
// Specify how UI should be updated
ngModel.$render = function() {
element.html(ngModel.$viewValue || '');
};
// Listen for change events to enable binding
element.on('blur keyup change', function() {
scope.$apply(read);
});
read(); // initialize
// Write data to the model
function read() {
var html = element.html();
// When we clear the content editable the browser leaves a <br> behind
// If strip-br attribute is provided then we strip this out
if( attrs.stripBr && html == '<br>' ) {
html = '';
}
ngModel.$setViewValue(html);
}
}
};
});
</file>
<file name="index.html">
<form name="myForm">
<div contenteditable
name="myWidget" ng-model="userContent"
strip-br="true"
required>Change me!</div>
<span ng-show="myForm.myWidget.$error.required">Required!</span>
<hr>
<textarea ng-model="userContent"></textarea>
</form>
</file>
<file name="scenario.js">
it('should data-bind and become invalid', function() {
var contentEditable = element('[contenteditable]');
expect(contentEditable.text()).toEqual('Change me!');
input('userContent').enter('');
expect(contentEditable.text()).toEqual('');
expect(contentEditable.prop('className')).toMatch(/ng-invalid-required/);
});
</file>
* </example>
*
*
*/
var 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 = true;
this.$dirty = false;
this.$valid = true;
this.$invalid = false;
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),
);
}
/**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$render
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Called when the view needs to be updated. It is expected that the user of the ng-model
* directive will implement this method.
*/
this.$render = noop;
/**
* @ngdoc function
* @name { ng.directive:ngModel.NgModelController#$isEmpty
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* This is called when we need to determine if the value of the input is empty.
*
* For instance, the required directive does this to work out if the input has data or not.
* The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`.
*
* You can override this for input directives whose concept of being empty is different to the
* default. The `checkboxInputType` directive does this because in its case a value of `false`
* implies empty.
*/
this.$isEmpty = function (value) {
return (
isUndefined(value) ||
value === "" ||
value === null ||
value !== value
);
};
var parentForm =
$element.inheritedData("$formController") || nullFormCtrl,
invalidCount = 0, // used to easily determine if we are valid
$error = (this.$error = {}); // keep invalid keys here
// Setup initial state of the control
$element.addClass(PRISTINE_CLASS);
toggleValidCss(true);
// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
validationErrorKey = validationErrorKey
? "-" + snake_case(validationErrorKey, "-")
: "";
$element
.removeClass(
(isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey,
)
.addClass(
(isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey,
);
}
/**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setValidity
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Change the validity state, and notifies the form when the control changes validity. (i.e. it
* does not notify form if given validator is already marked as invalid).
*
* This method should be called by validators - i.e. the parser or formatter functions.
*
* @param {string} validationErrorKey Name of the validator. the `validationErrorKey` will assign
* to `$error[validationErrorKey]=isValid` so that it is available for data-binding.
* The `validationErrorKey` should be in camelCase and will get converted into dash-case
* for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error`
* class and can be bound to as `{{someForm.someControl.$error.myError}}` .
* @param {boolean} isValid Whether the current state is valid (true) or invalid (false).
*/
this.$setValidity = function (validationErrorKey, isValid) {
// Purposeful use of ! here to cast isValid to boolean in case it is undefined
// jshint -W018
if ($error[validationErrorKey] === !isValid) return;
// jshint +W018
if (isValid) {
if ($error[validationErrorKey]) invalidCount--;
if (!invalidCount) {
toggleValidCss(true);
this.$valid = true;
this.$invalid = false;
}
} else {
toggleValidCss(false);
this.$invalid = true;
this.$valid = false;
invalidCount++;
}
$error[validationErrorKey] = !isValid;
toggleValidCss(isValid, validationErrorKey);
parentForm.$setValidity(validationErrorKey, isValid, this);
};
/**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setPristine
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Sets the control to its pristine state.
*
* This method can be called to remove the 'ng-dirty' class and set the control to its pristine
* state (ng-pristine class).
*/
this.$setPristine = function () {
this.$dirty = false;
this.$pristine = true;
$element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS);
};
/**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setViewValue
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Update the view value.
*
* This method should be called when the view value changes, typically from within a DOM event handler.
* For example {@link ng.directive:input input} and
* {@link ng.directive:select select} directives call it.
*
* It will update the $viewValue, then pass this value through each of the functions in `$parsers`,
* which includes any validators. The value that comes out of this `$parsers` pipeline, be applied to
* `$modelValue` and the **expression** specified in the `ng-model` attribute.
*
* Lastly, all the registered change listeners, in the `$viewChangeListeners` list, are called.
*
* Note that calling this function does not trigger a `$digest`.
*
* @param {string} value Value from the view.
*/
this.$setViewValue = function (value) {
this.$viewValue = value;
// change to dirty
if (this.$pristine) {
this.$dirty = true;
this.$pristine = false;
$element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
parentForm.$setDirty();
}
forEach(this.$parsers, function (fn) {
value = fn(value);
});
if (this.$modelValue !== value) {
this.$modelValue = value;
ngModelSet($scope, value);
forEach(this.$viewChangeListeners, function (listener) {
try {
listener();
} catch (e) {
$exceptionHandler(e);
}
});
}
};
// model -> value
var ctrl = this;
$scope.$watch(function ngModelWatch() {
var value = ngModelGet($scope);
// if scope model value and ngModel value are out of sync
if (ctrl.$modelValue !== value) {
var formatters = ctrl.$formatters,
idx = formatters.length;
ctrl.$modelValue = value;
while (idx--) {
value = formatters[idx](value);
}
if (ctrl.$viewValue !== value) {
ctrl.$viewValue = value;
ctrl.$render();
}
}
return value;
});
},
];
/**
* @ngdoc directive
* @name ng.directive:ngModel
*
* @element input
*
* @description
* The `ngModel` directive binds an `input`,`select`, `textarea` (or custom form control) to a
* property on the scope using {@link ng.directive:ngModel.NgModelController NgModelController},
* which is created and exposed by this directive.
*
* `ngModel` is responsible for:
*
* - Binding the view into the model, which other directives such as `input`, `textarea` or `select`
* require.
* - Providing validation behavior (i.e. required, number, email, url).
* - Keeping the state of the control (valid/invalid, dirty/pristine, validation errors).
* - Setting related css classes on the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`).
* - Registering the control with its parent {@link ng.directive:form form}.
*
* Note: `ngModel` will try to bind to the property given by evaluating the expression on the
* current scope. If the property doesn't already exist on this scope, it will be created
* implicitly and added to the scope.
*
* For best practices on using `ngModel`, see:
*
* - {@link https://github.com/angular/angular.js/wiki/Understanding-Scopes}
*
* For basic examples, how to use `ngModel`, see:
*
* - {@link ng.directive:input input}
* - {@link ng.directive:input.text text}
* - {@link ng.directive:input.checkbox checkbox}
* - {@link ng.directive:input.radio radio}
* - {@link ng.directive:input.number number}
* - {@link ng.directive:input.email email}
* - {@link ng.directive:input.url url}
* - {@link ng.directive:select select}
* - {@link ng.directive:textarea textarea}
*
*/
var ngModelDirective = function () {
return {
require: ["ngModel", "^?form"],
controller: NgModelController,
link: function (scope, element, attr, ctrls) {
// notify others, especially parent forms
var modelCtrl = ctrls[0],
formCtrl = ctrls[1] || nullFormCtrl;
formCtrl.$addControl(modelCtrl);
scope.$on("$destroy", function () {
formCtrl.$removeControl(modelCtrl);
});
},
};
};
/**
* @ngdoc directive
* @name ng.directive:ngChange
*
* @description
* Evaluate given expression when user changes the input.
* The expression is not evaluated when the value change is coming from the model.
*
* Note, this directive requires `ngModel` to be present.
*
* @element input
* @param {expression} ngChange {@link guide/expression Expression} to evaluate upon change
* in input value.
*
* @example
* <doc:example>
* <doc:source>
* <script>
* function Controller($scope) {
* $scope.counter = 0;
* $scope.change = function() {
* $scope.counter++;
* };
* }
* </script>
* <div ng-controller="Controller">
* <input type="checkbox" ng-model="confirmed" ng-change="change()" id="ng-change-example1" />
* <input type="checkbox" ng-model="confirmed" id="ng-change-example2" />
* <label for="ng-change-example2">Confirmed</label><br />
* debug = {{confirmed}}<br />
* counter = {{counter}}
* </div>
* </doc:source>
* <doc:scenario>
* it('should evaluate the expression if changing from view', function() {
* expect(binding('counter')).toEqual('0');
* element('#ng-change-example1').click();
* expect(binding('counter')).toEqual('1');
* expect(binding('confirmed')).toEqual('true');
* });
*
* it('should not evaluate the expression if changing from model', function() {
* element('#ng-change-example2').click();
* expect(binding('counter')).toEqual('0');
* expect(binding('confirmed')).toEqual('true');
* });
* </doc:scenario>
* </doc:example>
*/
var ngChangeDirective = valueFn({
require: "ngModel",
link: function (scope, element, attr, ctrl) {
ctrl.$viewChangeListeners.push(function () {
scope.$eval(attr.ngChange);
});
},
});
var requiredDirective = function () {
return {
require: "?ngModel",
link: function (scope, elm, attr, ctrl) {
if (!ctrl) return;
attr.required = true; // force truthy in case we are on non input element
var validator = function (value) {
if (attr.required && ctrl.$isEmpty(value)) {
ctrl.$setValidity("required", false);
return;
} else {
ctrl.$setValidity("required", true);
return value;
}
};
ctrl.$formatters.push(validator);
ctrl.$parsers.unshift(validator);
attr.$observe("required", function () {
validator(ctrl.$viewValue);
});
},
};
};
/**
* @ngdoc directive
* @name ng.directive:ngList
*
* @description
* Text input that converts between a delimited string and an array of strings. The delimiter
* can be a fixed string (by default a comma) or a regular expression.
*
* @element input
* @param {string=} ngList optional delimiter that should be used to split the value. If
* specified in form `/something/` then the value will be converted into a regular expression.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.names = ['igor', 'misko', 'vojta'];
}
</script>
<form name="myForm" ng-controller="Ctrl">
List: <input name="namesInput" ng-model="names" ng-list required>
<span class="error" ng-show="myForm.namesInput.$error.required">
Required!</span>
<br>
<tt>names = {{names}}</tt><br/>
<tt>myForm.namesInput.$valid = {{myForm.namesInput.$valid}}</tt><br/>
<tt>myForm.namesInput.$error = {{myForm.namesInput.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('names')).toEqual('["igor","misko","vojta"]');
expect(binding('myForm.namesInput.$valid')).toEqual('true');
expect(element('span.error').css('display')).toBe('none');
});
it('should be invalid if empty', function() {
input('names').enter('');
expect(binding('names')).toEqual('');
expect(binding('myForm.namesInput.$valid')).toEqual('false');
expect(element('span.error').css('display')).not().toBe('none');
});
</doc:scenario>
</doc:example>
*/
var ngListDirective = function () {
return {
require: "ngModel",
link: function (scope, element, attr, ctrl) {
var match = /\/(.*)\//.exec(attr.ngList),
separator = (match && new RegExp(match[1])) || attr.ngList || ",";
var parse = function (viewValue) {
// If the viewValue is invalid (say required but empty) it will be `undefined`
if (isUndefined(viewValue)) return;
var list = [];
if (viewValue) {
forEach(viewValue.split(separator), function (value) {
if (value) list.push(trim(value));
});
}
return list;
};
ctrl.$parsers.push(parse);
ctrl.$formatters.push(function (value) {
if (isArray(value)) {
return value.join(", ");
}
return undefined;
});
// Override the standard $isEmpty because an empty array means the input is empty.
ctrl.$isEmpty = function (value) {
return !value || !value.length;
};
},
};
};
var CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
/**
* @ngdoc directive
* @name ng.directive:ngValue
*
* @description
* Binds the given expression to the value of `input[select]` or `input[radio]`, so
* that when the element is selected, the `ngModel` of that element is set to the
* bound value.
*
* `ngValue` is useful when dynamically generating lists of radio buttons using `ng-repeat`, as
* shown below.
*
* @element input
* @param {string=} ngValue angular expression, whose value will be bound to the `value` attribute
* of the `input` element
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.names = ['pizza', 'unicorns', 'robots'];
$scope.my = { favorite: 'unicorns' };
}
</script>
<form ng-controller="Ctrl">
<h2>Which is your favorite?</h2>
<label ng-repeat="name in names" for="{{name}}">
{{name}}
<input type="radio"
ng-model="my.favorite"
ng-value="name"
id="{{name}}"
name="favorite">
</label>
<div>You chose {{my.favorite}}</div>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('my.favorite')).toEqual('unicorns');
});
it('should bind the values to the inputs', function() {
input('my.favorite').select('pizza');
expect(binding('my.favorite')).toEqual('pizza');
});
</doc:scenario>
</doc:example>
*/
var ngValueDirective = function () {
return {
priority: 100,
compile: function (tpl, tplAttr) {
if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
return function ngValueConstantLink(scope, elm, attr) {
attr.$set("value", scope.$eval(attr.ngValue));
};
} else {
return function ngValueLink(scope, elm, attr) {
scope.$watch(attr.ngValue, function valueWatchAction(value) {
attr.$set("value", value);
});
};
}
},
};
};
/**
* @ngdoc directive
* @name ng.directive:ngBind
* @restrict AC
*
* @description
* The `ngBind` attribute tells Angular to replace the text content of the specified HTML element
* with the value of a given expression, and to update the text content when the value of that
* expression changes.
*
* Typically, you don't use `ngBind` directly, but instead you use the double curly markup like
* `{{ expression }}` which is similar but less verbose.
*
* It is preferrable to use `ngBind` instead of `{{ expression }}` when a template is momentarily
* displayed by the browser in its raw state before Angular compiles it. Since `ngBind` is an
* element attribute, it makes the bindings invisible to the user while the page is loading.
*
* An alternative solution to this problem would be using the
* {@link ng.directive:ngCloak ngCloak} directive.
*
*
* @element ANY
* @param {expression} ngBind {@link guide/expression Expression} to evaluate.
*
* @example
* Enter a name in the Live Preview text box; the greeting below the text box changes instantly.
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.name = 'Whirled';
}
</script>
<div ng-controller="Ctrl">
Enter name: <input type="text" ng-model="name"><br>
Hello <span ng-bind="name"></span>!
</div>
</doc:source>
<doc:scenario>
it('should check ng-bind', function() {
expect(using('.doc-example-live').binding('name')).toBe('Whirled');
using('.doc-example-live').input('name').enter('world');
expect(using('.doc-example-live').binding('name')).toBe('world');
});
</doc:scenario>
</doc:example>
*/
var ngBindDirective = ngDirective(function (scope, element, attr) {
element.addClass("ng-binding").data("$binding", attr.ngBind);
scope.$watch(attr.ngBind, function ngBindWatchAction(value) {
// We are purposefully using == here rather than === because we want to
// catch when value is "null or undefined"
// jshint -W041
element.text(value == undefined ? "" : value);
});
});
/**
* @ngdoc directive
* @name ng.directive:ngBindTemplate
*
* @description
* The `ngBindTemplate` directive specifies that the element
* text content should be replaced with the interpolation of the template
* in the `ngBindTemplate` attribute.
* Unlike `ngBind`, the `ngBindTemplate` can contain multiple `{{` `}}`
* expressions. This directive is needed since some HTML elements
* (such as TITLE and OPTION) cannot contain SPAN elements.
*
* @element ANY
* @param {string} ngBindTemplate template of form
* <tt>{{</tt> <tt>expression</tt> <tt>}}</tt> to eval.
*
* @example
* Try it here: enter text in text box and watch the greeting change.
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.salutation = 'Hello';
$scope.name = 'World';
}
</script>
<div ng-controller="Ctrl">
Salutation: <input type="text" ng-model="salutation"><br>
Name: <input type="text" ng-model="name"><br>
<pre ng-bind-template="{{salutation}} {{name}}!"></pre>
</div>
</doc:source>
<doc:scenario>
it('should check ng-bind', function() {
expect(using('.doc-example-live').binding('salutation')).
toBe('Hello');
expect(using('.doc-example-live').binding('name')).
toBe('World');
using('.doc-example-live').input('salutation').enter('Greetings');
using('.doc-example-live').input('name').enter('user');
expect(using('.doc-example-live').binding('salutation')).
toBe('Greetings');
expect(using('.doc-example-live').binding('name')).
toBe('user');
});
</doc:scenario>
</doc:example>
*/
var ngBindTemplateDirective = [
"$interpolate",
function ($interpolate) {
return function (scope, element, attr) {
// TODO: move this to scenario runner
var interpolateFn = $interpolate(
element.attr(attr.$attr.ngBindTemplate),
);
element.addClass("ng-binding").data("$binding", interpolateFn);
attr.$observe("ngBindTemplate", function (value) {
element.text(value);
});
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngBindHtml
*
* @description
* Creates a binding that will innerHTML the result of evaluating the `expression` into the current
* element in a secure way. By default, the innerHTML-ed content will be sanitized using the {@link
* ngSanitize.$sanitize $sanitize} service. To utilize this functionality, ensure that `$sanitize`
* is available, for example, by including {@link ngSanitize} in your module's dependencies (not in
* core Angular.) You may also bypass sanitization for values you know are safe. To do so, bind to
* an explicitly trusted value via {@link ng.$sce#methods_trustAsHtml $sce.trustAsHtml}. See the example
* under {@link ng.$sce#Example Strict Contextual Escaping (SCE)}.
*
* Note: If a `$sanitize` service is unavailable and the bound value isn't explicitly trusted, you
* will have an exception (instead of an exploit.)
*
* @element ANY
* @param {expression} ngBindHtml {@link guide/expression Expression} to evaluate.
*
* @example
Try it here: enter text in text box and watch the greeting change.
<example module="ngBindHtmlExample" deps="angular-sanitize.js">
<file name="index.html">
<div ng-controller="ngBindHtmlCtrl">
<p ng-bind-html="myHTML"></p>
</div>
</file>
<file name="script.js">
angular.module('ngBindHtmlExample', ['ngSanitize'])
.controller('ngBindHtmlCtrl', ['$scope', function ngBindHtmlCtrl($scope) {
$scope.myHTML =
'I am an <code>HTML</code>string with <a href="#">links!</a> and other <em>stuff</em>';
}]);
</file>
<file name="scenario.js">
it('should check ng-bind-html', function() {
expect(using('.doc-example-live').binding('myHTML')).
toBe(
'I am an <code>HTML</code>string with <a href="#">links!</a> and other <em>stuff</em>'
);
});
</file>
</example>
*/
var ngBindHtmlDirective = [
"$sce",
"$parse",
function ($sce, $parse) {
return function (scope, element, attr) {
element.addClass("ng-binding").data("$binding", attr.ngBindHtml);
var parsed = $parse(attr.ngBindHtml);
function getStringValue() {
return (parsed(scope) || "").toString();
}
scope.$watch(getStringValue, function ngBindHtmlWatchAction(value) {
element.html($sce.getTrustedHtml(parsed(scope)) || "");
});
};
},
];
function classDirective(name, selector) {
name = "ngClass" + name;
return function () {
return {
restrict: "AC",
link: function (scope, element, attr) {
var oldVal;
scope.$watch(attr[name], ngClassWatchAction, true);
attr.$observe("class", function (value) {
ngClassWatchAction(scope.$eval(attr[name]));
});
if (name !== "ngClass") {
scope.$watch("$index", function ($index, old$index) {
// jshint bitwise: false
var mod = $index & 1;
if ((mod !== old$index) & 1) {
var classes = flattenClasses(scope.$eval(attr[name]));
mod === selector
? attr.$addClass(classes)
: attr.$removeClass(classes);
}
});
}
function ngClassWatchAction(newVal) {
if (selector === true || scope.$index % 2 === selector) {
var newClasses = flattenClasses(newVal || "");
if (!oldVal) {
attr.$addClass(newClasses);
} else if (!equals(newVal, oldVal)) {
attr.$updateClass(newClasses, flattenClasses(oldVal));
}
}
oldVal = copy(newVal);
}
function flattenClasses(classVal) {
if (isArray(classVal)) {
return classVal.join(" ");
} else if (isObject(classVal)) {
var classes = [],
i = 0;
forEach(classVal, function (v, k) {
if (v) {
classes.push(k);
}
});
return classes.join(" ");
}
return classVal;
}
},
};
};
}
/**
* @ngdoc directive
* @name ng.directive:ngClass
* @restrict AC
*
* @description
* The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding
* an expression that represents all classes to be added.
*
* The directive won't add duplicate classes if a particular class was already set.
*
* When the expression changes, the previously added classes are removed and only then the
* new classes are added.
*
* @animations
* add - happens just before the class is applied to the element
* remove - happens just before the class is removed from the element
*
* @element ANY
* @param {expression} ngClass {@link guide/expression Expression} to eval. The result
* of the evaluation can be a string representing space delimited class
* names, an array, or a map of class names to boolean values. In the case of a map, the
* names of the properties whose values are truthy will be added as css classes to the
* element.
*
* @example Example that demonstrates basic bindings via ngClass directive.
<example>
<file name="index.html">
<p ng-class="{strike: deleted, bold: important, red: error}">Map Syntax Example</p>
<input type="checkbox" ng-model="deleted"> deleted (apply "strike" class)<br>
<input type="checkbox" ng-model="important"> important (apply "bold" class)<br>
<input type="checkbox" ng-model="error"> error (apply "red" class)
<hr>
<p ng-class="style">Using String Syntax</p>
<input type="text" ng-model="style" placeholder="Type: bold strike red">
<hr>
<p ng-class="[style1, style2, style3]">Using Array Syntax</p>
<input ng-model="style1" placeholder="Type: bold, strike or red"><br>
<input ng-model="style2" placeholder="Type: bold, strike or red"><br>
<input ng-model="style3" placeholder="Type: bold, strike or red"><br>
</file>
<file name="style.css">
.strike {
text-decoration: line-through;
}
.bold {
font-weight: bold;
}
.red {
color: red;
}
</file>
<file name="scenario.js">
it('should let you toggle the class', function() {
expect(element('.doc-example-live p:first').prop('className')).not().toMatch(/bold/);
expect(element('.doc-example-live p:first').prop('className')).not().toMatch(/red/);
input('important').check();
expect(element('.doc-example-live p:first').prop('className')).toMatch(/bold/);
input('error').check();
expect(element('.doc-example-live p:first').prop('className')).toMatch(/red/);
});
it('should let you toggle string example', function() {
expect(element('.doc-example-live p:nth-of-type(2)').prop('className')).toBe('');
input('style').enter('red');
expect(element('.doc-example-live p:nth-of-type(2)').prop('className')).toBe('red');
});
it('array example should have 3 classes', function() {
expect(element('.doc-example-live p:last').prop('className')).toBe('');
input('style1').enter('bold');
input('style2').enter('strike');
input('style3').enter('red');
expect(element('.doc-example-live p:last').prop('className')).toBe('bold strike red');
});
</file>
</example>
## Animations
The example below demonstrates how to perform animations using ngClass.
<example animations="true">
<file name="index.html">
<input type="button" value="set" ng-click="myVar='my-class'">
<input type="button" value="clear" ng-click="myVar=''">
<br>
<span class="base-class" ng-class="myVar">Sample Text</span>
</file>
<file name="style.css">
.base-class {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
}
.base-class.my-class {
color: red;
font-size:3em;
}
</file>
<file name="scenario.js">
it('should check ng-class', function() {
expect(element('.doc-example-live span').prop('className')).not().
toMatch(/my-class/);
using('.doc-example-live').element(':button:first').click();
expect(element('.doc-example-live span').prop('className')).
toMatch(/my-class/);
using('.doc-example-live').element(':button:last').click();
expect(element('.doc-example-live span').prop('className')).not().
toMatch(/my-class/);
});
</file>
</example>
## ngClass and pre-existing CSS3 Transitions/Animations
The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
to view the step by step details of {@link ngAnimate.$animate#methods_addclass $animate.addClass} and
{@link ngAnimate.$animate#methods_removeclass $animate.removeClass}.
*/
var ngClassDirective = classDirective("", true);
/**
* @ngdoc directive
* @name ng.directive:ngClassOdd
* @restrict AC
*
* @description
* The `ngClassOdd` and `ngClassEven` directives work exactly as
* {@link ng.directive:ngClass ngClass}, except they work in
* conjunction with `ngRepeat` and take effect only on odd (even) rows.
*
* This directive can be applied only within the scope of an
* {@link ng.directive:ngRepeat ngRepeat}.
*
* @element ANY
* @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result
* of the evaluation can be a string representing space delimited class names or an array.
*
* @example
<example>
<file name="index.html">
<ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
<li ng-repeat="name in names">
<span ng-class-odd="'odd'" ng-class-even="'even'">
{{name}}
</span>
</li>
</ol>
</file>
<file name="style.css">
.odd {
color: red;
}
.even {
color: blue;
}
</file>
<file name="scenario.js">
it('should check ng-class-odd and ng-class-even', function() {
expect(element('.doc-example-live li:first span').prop('className')).
toMatch(/odd/);
expect(element('.doc-example-live li:last span').prop('className')).
toMatch(/even/);
});
</file>
</example>
*/
var ngClassOddDirective = classDirective("Odd", 0);
/**
* @ngdoc directive
* @name ng.directive:ngClassEven
* @restrict AC
*
* @description
* The `ngClassOdd` and `ngClassEven` directives work exactly as
* {@link ng.directive:ngClass ngClass}, except they work in
* conjunction with `ngRepeat` and take effect only on odd (even) rows.
*
* This directive can be applied only within the scope of an
* {@link ng.directive:ngRepeat ngRepeat}.
*
* @element ANY
* @param {expression} ngClassEven {@link guide/expression Expression} to eval. The
* result of the evaluation can be a string representing space delimited class names or an array.
*
* @example
<example>
<file name="index.html">
<ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
<li ng-repeat="name in names">
<span ng-class-odd="'odd'" ng-class-even="'even'">
{{name}}
</span>
</li>
</ol>
</file>
<file name="style.css">
.odd {
color: red;
}
.even {
color: blue;
}
</file>
<file name="scenario.js">
it('should check ng-class-odd and ng-class-even', function() {
expect(element('.doc-example-live li:first span').prop('className')).
toMatch(/odd/);
expect(element('.doc-example-live li:last span').prop('className')).
toMatch(/even/);
});
</file>
</example>
*/
var ngClassEvenDirective = classDirective("Even", 1);
/**
* @ngdoc directive
* @name ng.directive:ngCloak
* @restrict AC
*
* @description
* The `ngCloak` directive is used to prevent the Angular html template from being briefly
* displayed by the browser in its raw (uncompiled) form while your application is loading. Use this
* directive to avoid the undesirable flicker effect caused by the html template display.
*
* The directive can be applied to the `<body>` element, but the preferred usage is to apply
* multiple `ngCloak` directives to small portions of the page to permit progressive rendering
* of the browser view.
*
* `ngCloak` works in cooperation with the following css rule embedded within `angular.js` and
* `angular.min.js`.
* For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}).
*
* <pre>
* [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak {
* display: none !important;
* }
* </pre>
*
* When this css rule is loaded by the browser, all html elements (including their children) that
* are tagged with the `ngCloak` directive are hidden. When Angular encounters this directive
* during the compilation of the template it deletes the `ngCloak` element attribute, making
* the compiled element visible.
*
* For the best result, the `angular.js` script must be loaded in the head section of the html
* document; alternatively, the css rule above must be included in the external stylesheet of the
* application.
*
* Legacy browsers, like IE7, do not provide attribute selector support (added in CSS 2.1) so they
* cannot match the `[ng\:cloak]` selector. To work around this limitation, you must add the css
* class `ngCloak` in addition to the `ngCloak` directive as shown in the example below.
*
* @element ANY
*
* @example
<doc:example>
<doc:source>
<div id="template1" ng-cloak>{{ 'hello' }}</div>
<div id="template2" ng-cloak class="ng-cloak">{{ 'hello IE7' }}</div>
</doc:source>
<doc:scenario>
it('should remove the template directive and css class', function() {
expect(element('.doc-example-live #template1').attr('ng-cloak')).
not().toBeDefined();
expect(element('.doc-example-live #template2').attr('ng-cloak')).
not().toBeDefined();
});
</doc:scenario>
</doc:example>
*
*/
var ngCloakDirective = ngDirective({
compile: function (element, attr) {
attr.$set("ngCloak", undefined);
element.removeClass("ng-cloak");
},
});
/**
* @ngdoc directive
* @name ng.directive:ngController
*
* @description
* The `ngController` directive attaches a controller class to the view. This is a key aspect of how angular
* supports the principles behind the Model-View-Controller design pattern.
*
* MVC components in angular:
*
* * Model — The Model is scope properties; scopes are attached to the DOM where scope properties
* are accessed through bindings.
* * View — The template (HTML with data bindings) that is rendered into the View.
* * Controller — The `ngController` directive specifies a Controller class; the class contains business
* logic behind the application to decorate the scope with functions and values
*
* Note that you can also attach controllers to the DOM by declaring it in a route definition
* via the {@link ngRoute.$route $route} service. A common mistake is to declare the controller
* again using `ng-controller` in the template itself. This will cause the controller to be attached
* and executed twice.
*
* @element ANY
* @scope
* @param {expression} ngController Name of a globally accessible constructor function or an
* {@link guide/expression expression} that on the current scope evaluates to a
* constructor function. The controller instance can be published into a scope property
* by specifying `as propertyName`.
*
* @example
* Here is a simple form for editing user contact information. Adding, removing, clearing, and
* greeting are methods declared on the controller (see source tab). These methods can
* easily be called from the angular markup. Notice that the scope becomes the `this` for the
* controller's instance. This allows for easy access to the view data from the controller. Also
* notice that any changes to the data are automatically reflected in the View without the need
* for a manual update. The example is shown in two different declaration styles you may use
* according to preference.
<doc:example>
<doc:source>
<script>
function SettingsController1() {
this.name = "John Smith";
this.contacts = [
{type: 'phone', value: '408 555 1212'},
{type: 'email', value: 'john.smith@example.org'} ];
};
SettingsController1.prototype.greet = function() {
alert(this.name);
};
SettingsController1.prototype.addContact = function() {
this.contacts.push({type: 'email', value: 'yourname@example.org'});
};
SettingsController1.prototype.removeContact = function(contactToRemove) {
var index = this.contacts.indexOf(contactToRemove);
this.contacts.splice(index, 1);
};
SettingsController1.prototype.clearContact = function(contact) {
contact.type = 'phone';
contact.value = '';
};
</script>
<div id="ctrl-as-exmpl" ng-controller="SettingsController1 as settings">
Name: <input type="text" ng-model="settings.name"/>
[ <a href="" ng-click="settings.greet()">greet</a> ]<br/>
Contact:
<ul>
<li ng-repeat="contact in settings.contacts">
<select ng-model="contact.type">
<option>phone</option>
<option>email</option>
</select>
<input type="text" ng-model="contact.value"/>
[ <a href="" ng-click="settings.clearContact(contact)">clear</a>
| <a href="" ng-click="settings.removeContact(contact)">X</a> ]
</li>
<li>[ <a href="" ng-click="settings.addContact()">add</a> ]</li>
</ul>
</div>
</doc:source>
<doc:scenario>
it('should check controller as', function() {
expect(element('#ctrl-as-exmpl>:input').val()).toBe('John Smith');
expect(element('#ctrl-as-exmpl li:nth-child(1) input').val())
.toBe('408 555 1212');
expect(element('#ctrl-as-exmpl li:nth-child(2) input').val())
.toBe('john.smith@example.org');
element('#ctrl-as-exmpl li:first a:contains("clear")').click();
expect(element('#ctrl-as-exmpl li:first input').val()).toBe('');
element('#ctrl-as-exmpl li:last a:contains("add")').click();
expect(element('#ctrl-as-exmpl li:nth-child(3) input').val())
.toBe('yourname@example.org');
});
</doc:scenario>
</doc:example>
<doc:example>
<doc:source>
<script>
function SettingsController2($scope) {
$scope.name = "John Smith";
$scope.contacts = [
{type:'phone', value:'408 555 1212'},
{type:'email', value:'john.smith@example.org'} ];
$scope.greet = function() {
alert(this.name);
};
$scope.addContact = function() {
this.contacts.push({type:'email', value:'yourname@example.org'});
};
$scope.removeContact = function(contactToRemove) {
var index = this.contacts.indexOf(contactToRemove);
this.contacts.splice(index, 1);
};
$scope.clearContact = function(contact) {
contact.type = 'phone';
contact.value = '';
};
}
</script>
<div id="ctrl-exmpl" ng-controller="SettingsController2">
Name: <input type="text" ng-model="name"/>
[ <a href="" ng-click="greet()">greet</a> ]<br/>
Contact:
<ul>
<li ng-repeat="contact in contacts">
<select ng-model="contact.type">
<option>phone</option>
<option>email</option>
</select>
<input type="text" ng-model="contact.value"/>
[ <a href="" ng-click="clearContact(contact)">clear</a>
| <a href="" ng-click="removeContact(contact)">X</a> ]
</li>
<li>[ <a href="" ng-click="addContact()">add</a> ]</li>
</ul>
</div>
</doc:source>
<doc:scenario>
it('should check controller', function() {
expect(element('#ctrl-exmpl>:input').val()).toBe('John Smith');
expect(element('#ctrl-exmpl li:nth-child(1) input').val())
.toBe('408 555 1212');
expect(element('#ctrl-exmpl li:nth-child(2) input').val())
.toBe('john.smith@example.org');
element('#ctrl-exmpl li:first a:contains("clear")').click();
expect(element('#ctrl-exmpl li:first input').val()).toBe('');
element('#ctrl-exmpl li:last a:contains("add")').click();
expect(element('#ctrl-exmpl li:nth-child(3) input').val())
.toBe('yourname@example.org');
});
</doc:scenario>
</doc:example>
*/
var ngControllerDirective = [
function () {
return {
scope: true,
controller: "@",
priority: 500,
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngCsp
*
* @element html
* @description
* Enables [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) support.
*
* This is necessary when developing things like Google Chrome Extensions.
*
* CSP forbids apps to use `eval` or `Function(string)` generated functions (among other things).
* For us to be compatible, we just need to implement the "getterFn" in $parse without violating
* any of these restrictions.
*
* AngularJS uses `Function(string)` generated functions as a speed optimization. Applying the `ngCsp`
* directive will cause Angular to use CSP compatibility mode. When this mode is on AngularJS will
* evaluate all expressions up to 30% slower than in non-CSP mode, but no security violations will
* be raised.
*
* CSP forbids JavaScript to inline stylesheet rules. In non CSP mode Angular automatically
* includes some CSS rules (e.g. {@link ng.directive:ngCloak ngCloak}).
* To make those directives work in CSP mode, include the `angular-csp.css` manually.
*
* In order to use this feature put the `ngCsp` directive on the root element of the application.
*
* *Note: This directive is only available in the `ng-csp` and `data-ng-csp` attribute form.*
*
* @example
* This example shows how to apply the `ngCsp` directive to the `html` tag.
<pre>
<!doctype html>
<html ng-app ng-csp>
...
...
</html>
</pre>
*/
// ngCsp is not implemented as a proper directive any more, because we need it be processed while we bootstrap
// the system (before $parse is instantiated), for this reason we just have a csp() fn that looks for ng-csp attribute
// anywhere in the current doc
/**
* @ngdoc directive
* @name ng.directive:ngClick
*
* @description
* The ngClick directive allows you to specify custom behavior when
* an element is clicked.
*
* @element ANY
* @param {expression} ngClick {@link guide/expression Expression} to evaluate upon
* click. (Event object is available as `$event`)
*
* @example
<doc:example>
<doc:source>
<button ng-click="count = count + 1" ng-init="count=0">
Increment
</button>
count: {{count}}
</doc:source>
<doc:scenario>
it('should check ng-click', function() {
expect(binding('count')).toBe('0');
element('.doc-example-live :button').click();
expect(binding('count')).toBe('1');
});
</doc:scenario>
</doc:example>
*/
/*
* A directive that allows creation of custom onclick handlers that are defined as angular
* expressions and are compiled and executed within the current scope.
*
* Events that are handled via these handler are always configured not to propagate further.
*/
var 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 });
});
});
};
},
};
},
];
},
);
/**
* @ngdoc directive
* @name ng.directive:ngDblclick
*
* @description
* The `ngDblclick` directive allows you to specify custom behavior on a dblclick event.
*
* @element ANY
* @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon
* a dblclick. (The Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMousedown
*
* @description
* The ngMousedown directive allows you to specify custom behavior on mousedown event.
*
* @element ANY
* @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon
* mousedown. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMouseup
*
* @description
* Specify custom behavior on mouseup event.
*
* @element ANY
* @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon
* mouseup. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMouseover
*
* @description
* Specify custom behavior on mouseover event.
*
* @element ANY
* @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon
* mouseover. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMouseenter
*
* @description
* Specify custom behavior on mouseenter event.
*
* @element ANY
* @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon
* mouseenter. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMouseleave
*
* @description
* Specify custom behavior on mouseleave event.
*
* @element ANY
* @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon
* mouseleave. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngMousemove
*
* @description
* Specify custom behavior on mousemove event.
*
* @element ANY
* @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon
* mousemove. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngKeydown
*
* @description
* Specify custom behavior on keydown event.
*
* @element ANY
* @param {expression} ngKeydown {@link guide/expression Expression} to evaluate upon
* keydown. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngKeyup
*
* @description
* Specify custom behavior on keyup event.
*
* @element ANY
* @param {expression} ngKeyup {@link guide/expression Expression} to evaluate upon
* keyup. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngKeypress
*
* @description
* Specify custom behavior on keypress event.
*
* @element ANY
* @param {expression} ngKeypress {@link guide/expression Expression} to evaluate upon
* keypress. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngSubmit
*
* @description
* Enables binding angular expressions to onsubmit events.
*
* Additionally it prevents the default action (which for form means sending the request to the
* server and reloading the current page) **but only if the form does not contain an `action`
* attribute**.
*
* @element form
* @param {expression} ngSubmit {@link guide/expression Expression} to eval. (Event object is available as `$event`)
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.list = [];
$scope.text = 'hello';
$scope.submit = function() {
if (this.text) {
this.list.push(this.text);
this.text = '';
}
};
}
</script>
<form ng-submit="submit()" ng-controller="Ctrl">
Enter text and hit enter:
<input type="text" ng-model="text" name="text" />
<input type="submit" id="submit" value="Submit" />
<pre>list={{list}}</pre>
</form>
</doc:source>
<doc:scenario>
it('should check ng-submit', function() {
expect(binding('list')).toBe('[]');
element('.doc-example-live #submit').click();
expect(binding('list')).toBe('["hello"]');
expect(input('text').val()).toBe('');
});
it('should ignore empty strings', function() {
expect(binding('list')).toBe('[]');
element('.doc-example-live #submit').click();
element('.doc-example-live #submit').click();
expect(binding('list')).toBe('["hello"]');
});
</doc:scenario>
</doc:example>
*/
/**
* @ngdoc directive
* @name ng.directive:ngFocus
*
* @description
* Specify custom behavior on focus event.
*
* @element window, input, select, textarea, a
* @param {expression} ngFocus {@link guide/expression Expression} to evaluate upon
* focus. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngBlur
*
* @description
* Specify custom behavior on blur event.
*
* @element window, input, select, textarea, a
* @param {expression} ngBlur {@link guide/expression Expression} to evaluate upon
* blur. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngCopy
*
* @description
* Specify custom behavior on copy event.
*
* @element window, input, select, textarea, a
* @param {expression} ngCopy {@link guide/expression Expression} to evaluate upon
* copy. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngCut
*
* @description
* Specify custom behavior on cut event.
*
* @element window, input, select, textarea, a
* @param {expression} ngCut {@link guide/expression Expression} to evaluate upon
* cut. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngPaste
*
* @description
* Specify custom behavior on paste event.
*
* @element window, input, select, textarea, a
* @param {expression} ngPaste {@link guide/expression Expression} to evaluate upon
* paste. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/
/**
* @ngdoc directive
* @name ng.directive:ngIf
* @restrict A
*
* @description
* The `ngIf` directive removes or recreates a portion of the DOM tree based on an
* {expression}. If the expression assigned to `ngIf` evaluates to a false
* value then the element is removed from the DOM, otherwise a clone of the
* element is reinserted into the DOM.
*
* `ngIf` differs from `ngShow` and `ngHide` in that `ngIf` completely removes and recreates the
* element in the DOM rather than changing its visibility via the `display` css property. A common
* case when this difference is significant is when using css selectors that rely on an element's
* position within the DOM, such as the `:first-child` or `:last-child` pseudo-classes.
*
* Note that when an element is removed using `ngIf` its scope is destroyed and a new scope
* is created when the element is restored. The scope created within `ngIf` inherits from
* its parent scope using
* {@link https://github.com/angular/angular.js/wiki/The-Nuances-of-Scope-Prototypal-Inheritance prototypal inheritance}.
* An important implication of this is if `ngModel` is used within `ngIf` to bind to
* a javascript primitive defined in the parent scope. In this case any modifications made to the
* variable within the child scope will override (hide) the value in the parent scope.
*
* Also, `ngIf` recreates elements using their compiled state. An example of this behavior
* is if an element's class attribute is directly modified after it's compiled, using something like
* jQuery's `.addClass()` method, and the element is later removed. When `ngIf` recreates the element
* the added class will be lost because the original compiled state is used to regenerate the element.
*
* Additionally, you can provide animations via the `ngAnimate` module to animate the `enter`
* and `leave` effects.
*
* @animations
* enter - happens just after the ngIf contents change and a new DOM element is created and injected into the ngIf container
* leave - happens just before the ngIf contents are removed from the DOM
*
* @element ANY
* @scope
* @priority 600
* @param {expression} ngIf If the {@link guide/expression expression} is falsy then
* the element is removed from the DOM tree. If it is truthy a copy of the compiled
* element is added to the DOM tree.
*
* @example
<example animations="true">
<file name="index.html">
Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /><br/>
Show when checked:
<span ng-if="checked" class="animate-if">
I'm removed when the checkbox is unchecked.
</span>
</file>
<file name="animations.css">
.animate-if {
background:white;
border:1px solid black;
padding:10px;
}
/*
The transition styles can also be placed on the CSS base class above
*/
.animate-if.ng-enter, .animate-if.ng-leave {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
}
.animate-if.ng-enter,
.animate-if.ng-leave.ng-leave-active {
opacity:0;
}
.animate-if.ng-leave,
.animate-if.ng-enter.ng-enter-active {
opacity:1;
}
</file>
</example>
*/
var ngIfDirective = [
"$animate",
function ($animate) {
return {
transclude: "element",
priority: 600,
terminal: true,
restrict: "A",
$$tlb: true,
link: function ($scope, $element, $attr, ctrl, $transclude) {
var block, childScope;
$scope.$watch($attr.ngIf, function ngIfWatchAction(value) {
if (toBoolean(value)) {
if (!childScope) {
childScope = $scope.$new();
$transclude(childScope, function (clone) {
clone[clone.length++] = document.createComment(
" end ngIf: " + $attr.ngIf + " ",
);
// Note: We only need the first/last node of the cloned nodes.
// However, we need to keep the reference to the jqlite wrapper as it might be changed later
// by a directive with templateUrl when it's template arrives.
block = {
clone: clone,
};
$animate.enter(clone, $element.parent(), $element);
});
}
} else {
if (childScope) {
childScope.$destroy();
childScope = null;
}
if (block) {
$animate.leave(getBlockElements(block.clone));
block = null;
}
}
});
},
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngInclude
* @restrict ECA
*
* @description
* Fetches, compiles and includes an external HTML fragment.
*
* By default, the template URL is restricted to the same domain and protocol as the
* application document. This is done by calling {@link ng.$sce#methods_getTrustedResourceUrl
* $sce.getTrustedResourceUrl} on it. To load templates from other domains or protocols
* you may either {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist them} or
* {@link ng.$sce#methods_trustAsResourceUrl wrap them} as trusted values. Refer to Angular's {@link
* ng.$sce Strict Contextual Escaping}.
*
* In addition, the browser's
* {@link https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest
* Same Origin Policy} and {@link http://www.w3.org/TR/cors/ Cross-Origin Resource Sharing
* (CORS)} policy may further restrict whether the template is successfully loaded.
* For example, `ngInclude` won't work for cross-domain requests on all browsers and for `file://`
* access on some browsers.
*
* @animations
* enter - animation is used to bring new content into the browser.
* leave - animation is used to animate existing content away.
*
* The enter and leave animation occur concurrently.
*
* @scope
* @priority 400
*
* @param {string} ngInclude|src angular expression evaluating to URL. If the source is a string constant,
* make sure you wrap it in quotes, e.g. `src="'myPartialTemplate.html'"`.
* @param {string=} onload Expression to evaluate when a new partial is loaded.
*
* @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll
* $anchorScroll} to scroll the viewport after the content is loaded.
*
* - If the attribute is not set, disable scrolling.
* - If the attribute is set without value, enable scrolling.
* - Otherwise enable scrolling only if the expression evaluates to truthy value.
*
* @example
<example animations="true">
<file name="index.html">
<div ng-controller="Ctrl">
<select ng-model="template" ng-options="t.name for t in templates">
<option value="">(blank)</option>
</select>
url of the template: <tt>{{template.url}}</tt>
<hr/>
<div class="slide-animate-container">
<div class="slide-animate" ng-include="template.url"></div>
</div>
</div>
</file>
<file name="script.js">
function Ctrl($scope) {
$scope.templates =
[ { name: 'template1.html', url: 'template1.html'}
, { name: 'template2.html', url: 'template2.html'} ];
$scope.template = $scope.templates[0];
}
</file>
<file name="template1.html">
Content of template1.html
</file>
<file name="template2.html">
Content of template2.html
</file>
<file name="animations.css">
.slide-animate-container {
position:relative;
background:white;
border:1px solid black;
height:40px;
overflow:hidden;
}
.slide-animate {
padding:10px;
}
.slide-animate.ng-enter, .slide-animate.ng-leave {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
position:absolute;
top:0;
left:0;
right:0;
bottom:0;
display:block;
padding:10px;
}
.slide-animate.ng-enter {
top:-50px;
}
.slide-animate.ng-enter.ng-enter-active {
top:0;
}
.slide-animate.ng-leave {
top:0;
}
.slide-animate.ng-leave.ng-leave-active {
top:50px;
}
</file>
<file name="scenario.js">
it('should load template1.html', function() {
expect(element('.doc-example-live [ng-include]').text()).
toMatch(/Content of template1.html/);
});
it('should load template2.html', function() {
select('template').option('1');
expect(element('.doc-example-live [ng-include]').text()).
toMatch(/Content of template2.html/);
});
it('should change to blank', function() {
select('template').option('');
expect(element('.doc-example-live [ng-include]')).toBe(undefined);
});
</file>
</example>
*/
/**
* @ngdoc event
* @name ng.directive:ngInclude#$includeContentRequested
* @eventOf ng.directive:ngInclude
* @eventType emit on the scope ngInclude was declared in
* @description
* Emitted every time the ngInclude content is requested.
*/
/**
* @ngdoc event
* @name ng.directive:ngInclude#$includeContentLoaded
* @eventOf ng.directive:ngInclude
* @eventType emit on the current ngInclude scope
* @description
* Emitted every time the ngInclude content is reloaded.
*/
var ngIncludeDirective = [
"$http",
"$templateCache",
"$anchorScroll",
"$animate",
"$sce",
function ($http, $templateCache, $anchorScroll, $animate, $sce) {
return {
restrict: "ECA",
priority: 400,
terminal: true,
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 changeCounter = 0,
currentScope,
currentElement;
var cleanupLastIncludeContent = function () {
if (currentScope) {
currentScope.$destroy();
currentScope = null;
}
if (currentElement) {
$animate.leave(currentElement);
currentElement = null;
}
};
scope.$watch(
$sce.parseAsResourceUrl(srcExp),
function ngIncludeWatchAction(src) {
var afterAnimation = function () {
if (
isDefined(autoScrollExp) &&
(!autoScrollExp || scope.$eval(autoScrollExp))
) {
$anchorScroll();
}
};
var thisChangeId = ++changeCounter;
if (src) {
$http
.get(src, { cache: $templateCache })
.success(function (response) {
if (thisChangeId !== changeCounter) return;
var newScope = scope.$new();
ctrl.template = response;
// Note: This will also link all children of ng-include that were contained in the original
// html. If that content contains controllers, ... they could pollute/change the scope.
// However, using ng-include on an element with additional content does not make sense...
// Note: We can't remove them in the cloneAttchFn of $transclude as that
// function is called before linking the content, which would apply child
// directives to non existing elements.
var clone = $transclude(newScope, function (clone) {
cleanupLastIncludeContent();
$animate.enter(clone, null, $element, afterAnimation);
});
currentScope = newScope;
currentElement = clone;
currentScope.$emit("$includeContentLoaded");
scope.$eval(onloadExp);
})
.error(function () {
if (thisChangeId === changeCounter)
cleanupLastIncludeContent();
});
scope.$emit("$includeContentRequested");
} else {
cleanupLastIncludeContent();
ctrl.template = null;
}
},
);
};
},
};
},
];
// This directive is called during the $transclude call of the first `ngInclude` directive.
// It will replace and compile the content of the element with the loaded template.
// We need this directive so that the element content is already filled when
// the link function of another directive on the same element as ngInclude
// is called.
var 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);
},
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngInit
* @restrict AC
*
* @description
* The `ngInit` directive allows you to evaluate an expression in the
* current scope.
*
* <div class="alert alert-error">
* The only appropriate use of `ngInit` for aliasing special properties of
* {@link api/ng.directive:ngRepeat `ngRepeat`}, as seen in the demo below. Besides this case, you
* should use {@link guide/controller controllers} rather than `ngInit`
* to initialize values on a scope.
* </div>
*
* @priority 450
*
* @element ANY
* @param {expression} ngInit {@link guide/expression Expression} to eval.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.list = [['a', 'b'], ['c', 'd']];
}
</script>
<div ng-controller="Ctrl">
<div ng-repeat="innerList in list" ng-init="outerIndex = $index">
<div ng-repeat="value in innerList" ng-init="innerIndex = $index">
<span class="example-init">list[ {{outerIndex}} ][ {{innerIndex}} ] = {{value}};</span>
</div>
</div>
</div>
</doc:source>
<doc:scenario>
it('should alias index positions', function() {
expect(element('.example-init').text())
.toBe('list[ 0 ][ 0 ] = a;' +
'list[ 0 ][ 1 ] = b;' +
'list[ 1 ][ 0 ] = c;' +
'list[ 1 ][ 1 ] = d;');
});
</doc:scenario>
</doc:example>
*/
var ngInitDirective = ngDirective({
priority: 450,
compile: function () {
return {
pre: function (scope, element, attrs) {
scope.$eval(attrs.ngInit);
},
};
},
});
/**
* @ngdoc directive
* @name ng.directive:ngNonBindable
* @restrict AC
* @priority 1000
*
* @description
* The `ngNonBindable` directive tells Angular not to compile or bind the contents of the current
* DOM element. This is useful if the element contains what appears to be Angular directives and
* bindings but which should be ignored by Angular. This could be the case if you have a site that
* displays snippets of code, for instance.
*
* @element ANY
*
* @example
* In this example there are two locations where a simple interpolation binding (`{{}}`) is present,
* but the one wrapped in `ngNonBindable` is left alone.
*
* @example
<doc:example>
<doc:source>
<div>Normal: {{1 + 2}}</div>
<div ng-non-bindable>Ignored: {{1 + 2}}</div>
</doc:source>
<doc:scenario>
it('should check ng-non-bindable', function() {
expect(using('.doc-example-live').binding('1 + 2')).toBe('3');
expect(using('.doc-example-live').element('div:last').text()).
toMatch(/1 \+ 2/);
});
</doc:scenario>
</doc:example>
*/
var ngNonBindableDirective = ngDirective({ terminal: true, priority: 1000 });
/**
* @ngdoc directive
* @name ng.directive:ngPluralize
* @restrict EA
*
* @description
* # Overview
* `ngPluralize` is a directive that displays messages according to en-US localization rules.
* These rules are bundled with angular.js, but can be overridden
* (see {@link guide/i18n Angular i18n} dev guide). You configure ngPluralize directive
* by specifying the mappings between
* {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
* plural categories} and the strings to be displayed.
*
* # Plural categories and explicit number rules
* There are two
* {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
* plural categories} in Angular's default en-US locale: "one" and "other".
*
* While a plural category may match many numbers (for example, in en-US locale, "other" can match
* any number that is not 1), an explicit number rule can only match one number. For example, the
* explicit number rule for "3" matches the number 3. There are examples of plural categories
* and explicit number rules throughout the rest of this documentation.
*
* # Configuring ngPluralize
* You configure ngPluralize by providing 2 attributes: `count` and `when`.
* You can also provide an optional attribute, `offset`.
*
* The value of the `count` attribute can be either a string or an {@link guide/expression
* Angular expression}; these are evaluated on the current scope for its bound value.
*
* The `when` attribute specifies the mappings between plural categories and the actual
* string to be displayed. The value of the attribute should be a JSON object.
*
* The following example shows how to configure ngPluralize:
*
* <pre>
* <ng-pluralize count="personCount"
when="{'0': 'Nobody is viewing.',
* 'one': '1 person is viewing.',
* 'other': '{} people are viewing.'}">
* </ng-pluralize>
*</pre>
*
* In the example, `"0: Nobody is viewing."` is an explicit number rule. If you did not
* specify this rule, 0 would be matched to the "other" category and "0 people are viewing"
* would be shown instead of "Nobody is viewing". You can specify an explicit number rule for
* other numbers, for example 12, so that instead of showing "12 people are viewing", you can
* show "a dozen people are viewing".
*
* You can use a set of closed braces (`{}`) as a placeholder for the number that you want substituted
* into pluralized strings. In the previous example, Angular will replace `{}` with
* <span ng-non-bindable>`{{personCount}}`</span>. The closed braces `{}` is a placeholder
* for <span ng-non-bindable>{{numberExpression}}</span>.
*
* # Configuring ngPluralize with offset
* The `offset` attribute allows further customization of pluralized text, which can result in
* a better user experience. For example, instead of the message "4 people are viewing this document",
* you might display "John, Kate and 2 others are viewing this document".
* The offset attribute allows you to offset a number by any desired value.
* Let's take a look at an example:
*
* <pre>
* <ng-pluralize count="personCount" offset=2
* when="{'0': 'Nobody is viewing.',
* '1': '{{person1}} is viewing.',
* '2': '{{person1}} and {{person2}} are viewing.',
* 'one': '{{person1}}, {{person2}} and one other person are viewing.',
* 'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
* </ng-pluralize>
* </pre>
*
* Notice that we are still using two plural categories(one, other), but we added
* three explicit number rules 0, 1 and 2.
* When one person, perhaps John, views the document, "John is viewing" will be shown.
* When three people view the document, no explicit number rule is found, so
* an offset of 2 is taken off 3, and Angular uses 1 to decide the plural category.
* In this case, plural category 'one' is matched and "John, Marry and one other person are viewing"
* is shown.
*
* Note that when you specify offsets, you must provide explicit number rules for
* numbers from 0 up to and including the offset. If you use an offset of 3, for example,
* you must provide explicit number rules for 0, 1, 2 and 3. You must also provide plural strings for
* plural categories "one" and "other".
*
* @param {string|expression} count The variable to be bounded to.
* @param {string} when The mapping between plural category to its corresponding strings.
* @param {number=} offset Offset to deduct from the total number.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.person1 = 'Igor';
$scope.person2 = 'Misko';
$scope.personCount = 1;
}
</script>
<div ng-controller="Ctrl">
Person 1:<input type="text" ng-model="person1" value="Igor" /><br/>
Person 2:<input type="text" ng-model="person2" value="Misko" /><br/>
Number of People:<input type="text" ng-model="personCount" value="1" /><br/>
<!--- Example with simple pluralization rules for en locale --->
Without Offset:
<ng-pluralize count="personCount"
when="{'0': 'Nobody is viewing.',
'one': '1 person is viewing.',
'other': '{} people are viewing.'}">
</ng-pluralize><br>
<!--- Example with offset --->
With Offset(2):
<ng-pluralize count="personCount" offset=2
when="{'0': 'Nobody is viewing.',
'1': '{{person1}} is viewing.',
'2': '{{person1}} and {{person2}} are viewing.',
'one': '{{person1}}, {{person2}} and one other person are viewing.',
'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
</ng-pluralize>
</div>
</doc:source>
<doc:scenario>
it('should show correct pluralized string', function() {
expect(element('.doc-example-live ng-pluralize:first').text()).
toBe('1 person is viewing.');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Igor is viewing.');
using('.doc-example-live').input('personCount').enter('0');
expect(element('.doc-example-live ng-pluralize:first').text()).
toBe('Nobody is viewing.');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Nobody is viewing.');
using('.doc-example-live').input('personCount').enter('2');
expect(element('.doc-example-live ng-pluralize:first').text()).
toBe('2 people are viewing.');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Igor and Misko are viewing.');
using('.doc-example-live').input('personCount').enter('3');
expect(element('.doc-example-live ng-pluralize:first').text()).
toBe('3 people are viewing.');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Igor, Misko and one other person are viewing.');
using('.doc-example-live').input('personCount').enter('4');
expect(element('.doc-example-live ng-pluralize:first').text()).
toBe('4 people are viewing.');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Igor, Misko and 2 other people are viewing.');
});
it('should show data-binded names', function() {
using('.doc-example-live').input('personCount').enter('4');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Igor, Misko and 2 other people are viewing.');
using('.doc-example-live').input('person1').enter('Di');
using('.doc-example-live').input('person2').enter('Vojta');
expect(element('.doc-example-live ng-pluralize:last').text()).
toBe('Di, Vojta and 2 other people are viewing.');
});
</doc:scenario>
</doc:example>
*/
var 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), // we have {{}} in attrs
offset = attr.offset || 0,
whens = scope.$eval(whenExp) || {},
whensExpFns = {},
startSymbol = $interpolate.startSymbol(),
endSymbol = $interpolate.endSymbol(),
isWhen = /^when(Minus)?(.+)$/;
forEach(attr, function (expression, attributeName) {
if (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 ngPluralizeWatch() {
var value = parseFloat(scope.$eval(numberExp));
if (!isNaN(value)) {
//if explicit number rule such as 1, 2, 3... is defined, just use it. Otherwise,
//check it against pluralization rules in $locale service
if (!(value in whens))
value = $locale.pluralCat(value - offset);
return whensExpFns[value](scope, element, true);
} else {
return "";
}
},
function ngPluralizeWatchAction(newVal) {
element.text(newVal);
},
);
},
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngRepeat
*
* @description
* The `ngRepeat` directive instantiates a template once per item from a collection. Each template
* instance gets its own scope, where the given loop variable is set to the current collection item,
* and `$index` is set to the item index or key.
*
* Special properties are exposed on the local scope of each template instance, including:
*
* | Variable | Type | Details |
* |-----------|-----------------|-----------------------------------------------------------------------------|
* | `$index` | {@type number} | iterator offset of the repeated element (0..length-1) |
* | `$first` | {@type boolean} | true if the repeated element is first in the iterator. |
* | `$middle` | {@type boolean} | true if the repeated element is between the first and last in the iterator. |
* | `$last` | {@type boolean} | true if the repeated element is last in the iterator. |
* | `$even` | {@type boolean} | true if the iterator position `$index` is even (otherwise false). |
* | `$odd` | {@type boolean} | true if the iterator position `$index` is odd (otherwise false). |
*
*
* # Special repeat start and end points
* To repeat a series of elements instead of just one parent element, ngRepeat (as well as other ng directives) supports extending
* the range of the repeater by defining explicit start and end points by using **ng-repeat-start** and **ng-repeat-end** respectively.
* The **ng-repeat-start** directive works the same as **ng-repeat**, but will repeat all the HTML code (including the tag it's defined on)
* up to and including the ending HTML tag where **ng-repeat-end** is placed.
*
* The example below makes use of this feature:
* <pre>
* <header ng-repeat-start="item in items">
* Header {{ item }}
* </header>
* <div class="body">
* Body {{ item }}
* </div>
* <footer ng-repeat-end>
* Footer {{ item }}
* </footer>
* </pre>
*
* And with an input of {@type ['A','B']} for the items variable in the example above, the output will evaluate to:
* <pre>
* <header>
* Header A
* </header>
* <div class="body">
* Body A
* </div>
* <footer>
* Footer A
* </footer>
* <header>
* Header B
* </header>
* <div class="body">
* Body B
* </div>
* <footer>
* Footer B
* </footer>
* </pre>
*
* The custom start and end points for ngRepeat also support all other HTML directive syntax flavors provided in AngularJS (such
* as **data-ng-repeat-start**, **x-ng-repeat-start** and **ng:repeat-start**).
*
* @animations
* enter - when a new item is added to the list or when an item is revealed after a filter
* leave - when an item is removed from the list or when an item is filtered out
* move - when an adjacent item is filtered out causing a reorder or when the item contents are reordered
*
* @element ANY
* @scope
* @priority 1000
* @param {repeat_expression} ngRepeat The expression indicating how to enumerate a collection. These
* formats are currently supported:
*
* * `variable in expression` – where variable is the user defined loop variable and `expression`
* is a scope expression giving the collection to enumerate.
*
* For example: `album in artist.albums`.
*
* * `(key, value) in expression` – where `key` and `value` can be any user defined identifiers,
* and `expression` is the scope expression giving the collection to enumerate.
*
* For example: `(name, age) in {'adam':10, 'amalie':12}`.
*
* * `variable in expression track by tracking_expression` – You can also provide an optional tracking function
* which can be used to associate the objects in the collection with the DOM elements. If no tracking function
* is specified the ng-repeat associates elements by identity in the collection. It is an error to have
* more than one tracking function to resolve to the same key. (This would mean that two distinct objects are
* mapped to the same DOM element, which is not possible.) Filters should be applied to the expression,
* before specifying a tracking expression.
*
* For example: `item in items` is equivalent to `item in items track by $id(item)'. This implies that the DOM elements
* will be associated by item identity in the array.
*
* For example: `item in items track by $id(item)`. A built in `$id()` function can be used to assign a unique
* `$$hashKey` property to each item in the array. This property is then used as a key to associated DOM elements
* with the corresponding item in the array by identity. Moving the same object in array would move the DOM
* element in the same way in the DOM.
*
* For example: `item in items track by item.id` is a typical pattern when the items come from the database. In this
* case the object identity does not matter. Two objects are considered equivalent as long as their `id`
* property is same.
*
* For example: `item in items | filter:searchText track by item.id` is a pattern that might be used to apply a filter
* to items in conjunction with a tracking expression.
*
* @example
* This example initializes the scope to a list of names and
* then uses `ngRepeat` to display every person:
<example animations="true">
<file name="index.html">
<div ng-init="friends = [
{name:'John', age:25, gender:'boy'},
{name:'Jessie', age:30, gender:'girl'},
{name:'Johanna', age:28, gender:'girl'},
{name:'Joy', age:15, gender:'girl'},
{name:'Mary', age:28, gender:'girl'},
{name:'Peter', age:95, gender:'boy'},
{name:'Sebastian', age:50, gender:'boy'},
{name:'Erika', age:27, gender:'girl'},
{name:'Patrick', age:40, gender:'boy'},
{name:'Samantha', age:60, gender:'girl'}
]">
I have {{friends.length}} friends. They are:
<input type="search" ng-model="q" placeholder="filter friends..." />
<ul class="example-animate-container">
<li class="animate-repeat" ng-repeat="friend in friends | filter:q">
[{{$index + 1}}] {{friend.name}} who is {{friend.age}} years old.
</li>
</ul>
</div>
</file>
<file name="animations.css">
.example-animate-container {
background:white;
border:1px solid black;
list-style:none;
margin:0;
padding:0 10px;
}
.animate-repeat {
line-height:40px;
list-style:none;
box-sizing:border-box;
}
.animate-repeat.ng-move,
.animate-repeat.ng-enter,
.animate-repeat.ng-leave {
-webkit-transition:all linear 0.5s;
transition:all linear 0.5s;
}
.animate-repeat.ng-leave.ng-leave-active,
.animate-repeat.ng-move,
.animate-repeat.ng-enter {
opacity:0;
max-height:0;
}
.animate-repeat.ng-leave,
.animate-repeat.ng-move.ng-move-active,
.animate-repeat.ng-enter.ng-enter-active {
opacity:1;
max-height:40px;
}
</file>
<file name="scenario.js">
it('should render initial data set', function() {
var r = using('.doc-example-live').repeater('ul li');
expect(r.count()).toBe(10);
expect(r.row(0)).toEqual(["1","John","25"]);
expect(r.row(1)).toEqual(["2","Jessie","30"]);
expect(r.row(9)).toEqual(["10","Samantha","60"]);
expect(binding('friends.length')).toBe("10");
});
it('should update repeater when filter predicate changes', function() {
var r = using('.doc-example-live').repeater('ul li');
expect(r.count()).toBe(10);
input('q').enter('ma');
expect(r.count()).toBe(2);
expect(r.row(0)).toEqual(["1","Mary","28"]);
expect(r.row(1)).toEqual(["2","Samantha","60"]);
});
</file>
</example>
*/
var ngRepeatDirective = [
"$parse",
"$animate",
function ($parse, $animate) {
var NG_REMOVED = "$$NG_REMOVED";
var ngRepeatMinErr = minErr("ngRepeat");
return {
transclude: "element",
priority: 1000,
terminal: true,
$$tlb: true,
link: function ($scope, $element, $attr, ctrl, $transclude) {
var expression = $attr.ngRepeat;
var match = expression.match(
/^\s*(.+)\s+in\s+(.*?)\s*(\s+track\s+by\s+(.+)\s*)?$/,
),
trackByExp,
trackByExpGetter,
trackByIdExpFn,
trackByIdArrayFn,
trackByIdObjFn,
lhs,
rhs,
valueIdentifier,
keyIdentifier,
hashFnLocals = { $id: hashKey };
if (!match) {
throw ngRepeatMinErr(
"iexp",
"Expected expression in form of '_item_ in _collection_[ track by _id_]' but got '{0}'.",
expression,
);
}
lhs = match[1];
rhs = match[2];
trackByExp = match[4];
if (trackByExp) {
trackByExpGetter = $parse(trackByExp);
trackByIdExpFn = function (key, value, index) {
// assign key, value, and $index to the locals so that they can be used in hash functions
if (keyIdentifier) hashFnLocals[keyIdentifier] = key;
hashFnLocals[valueIdentifier] = value;
hashFnLocals.$index = index;
return trackByExpGetter($scope, hashFnLocals);
};
} else {
trackByIdArrayFn = function (key, value) {
return hashKey(value);
};
trackByIdObjFn = function (key) {
return key;
};
}
match = lhs.match(/^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/);
if (!match) {
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];
// Store a list of elements from previous run. This is a hash where key is the item from the
// iterator, and the value is objects with following properties.
// - scope: bound scope
// - element: previous element.
// - index: position
var lastBlockMap = {};
//watch props
$scope.$watchCollection(rhs, function ngRepeatAction(collection) {
var index,
length,
previousNode = $element[0], // current position of the node
nextNode,
// Same as lastBlockMap but it has the current state. It will become the
// lastBlockMap on the next iteration.
nextBlockMap = {},
arrayLength,
childScope,
key,
value, // key/value of iteration
trackById,
trackByIdFn,
collectionKeys,
block, // last object information {scope, element, id}
nextBlockOrder = [],
elementsToRemove;
if (isArrayLike(collection)) {
collectionKeys = collection;
trackByIdFn = trackByIdExpFn || trackByIdArrayFn;
} else {
trackByIdFn = trackByIdExpFn || trackByIdObjFn;
// if object, extract keys, sort them and use to determine order of iteration over obj props
collectionKeys = [];
for (key in collection) {
if (collection.hasOwnProperty(key) && key.charAt(0) != "$") {
collectionKeys.push(key);
}
}
collectionKeys.sort();
}
arrayLength = collectionKeys.length;
// locate existing items
length = nextBlockOrder.length = collectionKeys.length;
for (index = 0; index < length; index++) {
key =
collection === collectionKeys ? index : collectionKeys[index];
value = collection[key];
trackById = trackByIdFn(key, value, index);
assertNotHasOwnProperty(trackById, "`track by` id");
if (lastBlockMap.hasOwnProperty(trackById)) {
block = lastBlockMap[trackById];
delete lastBlockMap[trackById];
nextBlockMap[trackById] = block;
nextBlockOrder[index] = block;
} else if (nextBlockMap.hasOwnProperty(trackById)) {
// restore lastBlockMap
forEach(nextBlockOrder, function (block) {
if (block && block.scope) lastBlockMap[block.id] = block;
});
// This is a duplicate and we need to throw an error
throw ngRepeatMinErr(
"dupes",
"Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}",
expression,
trackById,
);
} else {
// new never before seen block
nextBlockOrder[index] = { id: trackById };
nextBlockMap[trackById] = false;
}
}
// remove existing items
for (key in lastBlockMap) {
// lastBlockMap is our own object so we don't need to use special hasOwnPropertyFn
if (lastBlockMap.hasOwnProperty(key)) {
block = lastBlockMap[key];
elementsToRemove = getBlockElements(block.clone);
$animate.leave(elementsToRemove);
forEach(elementsToRemove, function (element) {
element[NG_REMOVED] = true;
});
block.scope.$destroy();
}
}
// we are not using forEach for perf reasons (trying to avoid #call)
for (
index = 0, length = collectionKeys.length;
index < length;
index++
) {
key =
collection === collectionKeys ? index : collectionKeys[index];
value = collection[key];
block = nextBlockOrder[index];
if (nextBlockOrder[index - 1])
previousNode = getBlockEnd(nextBlockOrder[index - 1]);
if (block.scope) {
// if we have already seen this object, then we need to reuse the
// associated scope/element
childScope = block.scope;
nextNode = previousNode;
do {
nextNode = nextNode.nextSibling;
} while (nextNode && nextNode[NG_REMOVED]);
if (getBlockStart(block) != nextNode) {
// existing item which got moved
$animate.move(
getBlockElements(block.clone),
null,
jqLite(previousNode),
);
}
previousNode = getBlockEnd(block);
} else {
// new item which we don't know about
childScope = $scope.$new();
}
childScope[valueIdentifier] = value;
if (keyIdentifier) childScope[keyIdentifier] = key;
childScope.$index = index;
childScope.$first = index === 0;
childScope.$last = index === arrayLength - 1;
childScope.$middle = !(childScope.$first || childScope.$last);
// jshint bitwise: false
childScope.$odd = !(childScope.$even = (index & 1) === 0);
// jshint bitwise: true
if (!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;
// Note: We only need the first/last node of the cloned nodes.
// However, we need to keep the reference to the jqlite wrapper as it might be changed later
// by a directive with templateUrl when it's template arrives.
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];
}
},
];
/**
* @ngdoc directive
* @name ng.directive:ngShow
*
* @description
* The `ngShow` directive shows or hides the given HTML element based on the expression
* provided to the ngShow attribute. The element is shown or hidden by removing or adding
* the `ng-hide` CSS class onto the element. The `.ng-hide` CSS class is predefined
* in AngularJS and sets the display style to none (using an !important flag).
* For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}).
*
* <pre>
* <!-- when $scope.myValue is truthy (element is visible) -->
* <div ng-show="myValue"></div>
*
* <!-- when $scope.myValue is falsy (element is hidden) -->
* <div ng-show="myValue" class="ng-hide"></div>
* </pre>
*
* When the ngShow expression evaluates to false then the ng-hide CSS class is added to the class attribute
* on the element causing it to become hidden. When true, the ng-hide CSS class is removed
* from the element causing the element not to appear hidden.
*
* ## Why is !important used?
*
* You may be wondering why !important is used for the .ng-hide CSS class. This is because the `.ng-hide` selector
* can be easily overridden by heavier selectors. For example, something as simple
* as changing the display style on a HTML list item would make hidden elements appear visible.
* This also becomes a bigger issue when dealing with CSS frameworks.
*
* By using !important, the show and hide behavior will work as expected despite any clash between CSS selector
* specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the
* styling to change how to hide an element then it is just a matter of using !important in their own CSS code.
*
* ### Overriding .ng-hide
*
* If you wish to change the hide behavior with ngShow/ngHide then this can be achieved by
* restating the styles for the .ng-hide class in CSS:
* <pre>
* .ng-hide {
* //!annotate CSS Specificity|Not to worry, this will override the AngularJS default...
* display:block!important;
*
* //this is just another form of hiding an element
* position:absolute;
* top:-9999px;
* left:-9999px;
* }
* </pre>
*
* Just remember to include the important flag so the CSS override will function.
*
* ## A note about animations with ngShow
*
* Animations in ngShow/ngHide work with the show and hide events that are triggered when the directive expression
* is true and false. This system works like the animation system present with ngClass except that
* you must also include the !important flag to override the display property
* so that you can perform an animation when the element is hidden during the time of the animation.
*
* <pre>
* //
* //a working example can be found at the bottom of this page
* //
* .my-element.ng-hide-add, .my-element.ng-hide-remove {
* transition:0.5s linear all;
* display:block!important;
* }
*
* .my-element.ng-hide-add { ... }
* .my-element.ng-hide-add.ng-hide-add-active { ... }
* .my-element.ng-hide-remove { ... }
* .my-element.ng-hide-remove.ng-hide-remove-active { ... }
* </pre>
*
* @animations
* addClass: .ng-hide - happens after the ngShow expression evaluates to a truthy value and the just before contents are set to visible
* removeClass: .ng-hide - happens after the ngShow expression evaluates to a non truthy value and just before the contents are set to hidden
*
* @element ANY
* @param {expression} ngShow If the {@link guide/expression expression} is truthy
* then the element is shown or hidden respectively.
*
* @example
<example animations="true">
<file name="index.html">
Click me: <input type="checkbox" ng-model="checked"><br/>
<div>
Show:
<div class="check-element animate-show" ng-show="checked">
<span class="icon-thumbs-up"></span> I show up when your checkbox is checked.
</div>
</div>
<div>
Hide:
<div class="check-element animate-show" ng-hide="checked">
<span class="icon-thumbs-down"></span> I hide when your checkbox is checked.
</div>
</div>
</file>
<file name="animations.css">
.animate-show {
-webkit-transition:all linear 0.5s;
transition:all linear 0.5s;
line-height:20px;
opacity:1;
padding:10px;
border:1px solid black;
background:white;
}
.animate-show.ng-hide-add,
.animate-show.ng-hide-remove {
display:block!important;
}
.animate-show.ng-hide {
line-height:0;
opacity:0;
padding:0 10px;
}
.check-element {
padding:10px;
border:1px solid black;
background:white;
}
</file>
<file name="scenario.js">
it('should check ng-show / ng-hide', function() {
expect(element('.doc-example-live span:first:hidden').count()).toEqual(1);
expect(element('.doc-example-live span:last:visible').count()).toEqual(1);
input('checked').check();
expect(element('.doc-example-live span:first:visible').count()).toEqual(1);
expect(element('.doc-example-live span:last:hidden').count()).toEqual(1);
});
</file>
</example>
*/
var ngShowDirective = [
"$animate",
function ($animate) {
return function (scope, element, attr) {
scope.$watch(attr.ngShow, function ngShowWatchAction(value) {
$animate[toBoolean(value) ? "removeClass" : "addClass"](
element,
"ng-hide",
);
});
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngHide
*
* @description
* The `ngHide` directive shows or hides the given HTML element based on the expression
* provided to the ngHide attribute. The element is shown or hidden by removing or adding
* the `ng-hide` CSS class onto the element. The `.ng-hide` CSS class is predefined
* in AngularJS and sets the display style to none (using an !important flag).
* For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}).
*
* <pre>
* <!-- when $scope.myValue is truthy (element is hidden) -->
* <div ng-hide="myValue"></div>
*
* <!-- when $scope.myValue is falsy (element is visible) -->
* <div ng-hide="myValue" class="ng-hide"></div>
* </pre>
*
* When the ngHide expression evaluates to true then the .ng-hide CSS class is added to the class attribute
* on the element causing it to become hidden. When false, the ng-hide CSS class is removed
* from the element causing the element not to appear hidden.
*
* ## Why is !important used?
*
* You may be wondering why !important is used for the .ng-hide CSS class. This is because the `.ng-hide` selector
* can be easily overridden by heavier selectors. For example, something as simple
* as changing the display style on a HTML list item would make hidden elements appear visible.
* This also becomes a bigger issue when dealing with CSS frameworks.
*
* By using !important, the show and hide behavior will work as expected despite any clash between CSS selector
* specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the
* styling to change how to hide an element then it is just a matter of using !important in their own CSS code.
*
* ### Overriding .ng-hide
*
* If you wish to change the hide behavior with ngShow/ngHide then this can be achieved by
* restating the styles for the .ng-hide class in CSS:
* <pre>
* .ng-hide {
* //!annotate CSS Specificity|Not to worry, this will override the AngularJS default...
* display:block!important;
*
* //this is just another form of hiding an element
* position:absolute;
* top:-9999px;
* left:-9999px;
* }
* </pre>
*
* Just remember to include the important flag so the CSS override will function.
*
* ## A note about animations with ngHide
*
* Animations in ngShow/ngHide work with the show and hide events that are triggered when the directive expression
* is true and false. This system works like the animation system present with ngClass, except that
* you must also include the !important flag to override the display property so
* that you can perform an animation when the element is hidden during the time of the animation.
*
* <pre>
* //
* //a working example can be found at the bottom of this page
* //
* .my-element.ng-hide-add, .my-element.ng-hide-remove {
* transition:0.5s linear all;
* display:block!important;
* }
*
* .my-element.ng-hide-add { ... }
* .my-element.ng-hide-add.ng-hide-add-active { ... }
* .my-element.ng-hide-remove { ... }
* .my-element.ng-hide-remove.ng-hide-remove-active { ... }
* </pre>
*
* @animations
* removeClass: .ng-hide - happens after the ngHide expression evaluates to a truthy value and just before the contents are set to hidden
* addClass: .ng-hide - happens after the ngHide expression evaluates to a non truthy value and just before the contents are set to visible
*
* @element ANY
* @param {expression} ngHide If the {@link guide/expression expression} is truthy then
* the element is shown or hidden respectively.
*
* @example
<example animations="true">
<file name="index.html">
Click me: <input type="checkbox" ng-model="checked"><br/>
<div>
Show:
<div class="check-element animate-hide" ng-show="checked">
<span class="icon-thumbs-up"></span> I show up when your checkbox is checked.
</div>
</div>
<div>
Hide:
<div class="check-element animate-hide" ng-hide="checked">
<span class="icon-thumbs-down"></span> I hide when your checkbox is checked.
</div>
</div>
</file>
<file name="animations.css">
.animate-hide {
-webkit-transition:all linear 0.5s;
transition:all linear 0.5s;
line-height:20px;
opacity:1;
padding:10px;
border:1px solid black;
background:white;
}
.animate-hide.ng-hide-add,
.animate-hide.ng-hide-remove {
display:block!important;
}
.animate-hide.ng-hide {
line-height:0;
opacity:0;
padding:0 10px;
}
.check-element {
padding:10px;
border:1px solid black;
background:white;
}
</file>
<file name="scenario.js">
it('should check ng-show / ng-hide', function() {
expect(element('.doc-example-live .check-element:first:hidden').count()).toEqual(1);
expect(element('.doc-example-live .check-element:last:visible').count()).toEqual(1);
input('checked').check();
expect(element('.doc-example-live .check-element:first:visible').count()).toEqual(1);
expect(element('.doc-example-live .check-element:last:hidden').count()).toEqual(1);
});
</file>
</example>
*/
var ngHideDirective = [
"$animate",
function ($animate) {
return function (scope, element, attr) {
scope.$watch(attr.ngHide, function ngHideWatchAction(value) {
$animate[toBoolean(value) ? "addClass" : "removeClass"](
element,
"ng-hide",
);
});
};
},
];
/**
* @ngdoc directive
* @name ng.directive:ngStyle
* @restrict AC
*
* @description
* The `ngStyle` directive allows you to set CSS style on an HTML element conditionally.
*
* @element ANY
* @param {expression} ngStyle {@link guide/expression Expression} which evals to an
* object whose keys are CSS style names and values are corresponding values for those CSS
* keys.
*
* @example
<example>
<file name="index.html">
<input type="button" value="set" ng-click="myStyle={color:'red'}">
<input type="button" value="clear" ng-click="myStyle={}">
<br/>
<span ng-style="myStyle">Sample Text</span>
<pre>myStyle={{myStyle}}</pre>
</file>
<file name="style.css">
span {
color: black;
}
</file>
<file name="scenario.js">
it('should check ng-style', function() {
expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
element('.doc-example-live :button[value=set]').click();
expect(element('.doc-example-live span').css('color')).toBe('rgb(255, 0, 0)');
element('.doc-example-live :button[value=clear]').click();
expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
});
</file>
</example>
*/
var ngStyleDirective = ngDirective(function (scope, element, attr) {
scope.$watch(
attr.ngStyle,
function ngStyleWatchAction(newStyles, oldStyles) {
if (oldStyles && newStyles !== oldStyles) {
forEach(oldStyles, function (val, style) {
element.css(style, "");
});
}
if (newStyles) element.css(newStyles);
},
true,
);
});
/**
* @ngdoc directive
* @name ng.directive:ngSwitch
* @restrict EA
*
* @description
* The `ngSwitch` directive is used to conditionally swap DOM structure on your template based on a scope expression.
* Elements within `ngSwitch` but without `ngSwitchWhen` or `ngSwitchDefault` directives will be preserved at the location
* as specified in the template.
*
* The directive itself works similar to ngInclude, however, instead of downloading template code (or loading it
* from the template cache), `ngSwitch` simply choses one of the nested elements and makes it visible based on which element
* matches the value obtained from the evaluated expression. In other words, you define a container element
* (where you place the directive), place an expression on the **`on="..."` attribute**
* (or the **`ng-switch="..."` attribute**), define any inner elements inside of the directive and place
* a when attribute per element. The when attribute is used to inform ngSwitch which element to display when the on
* expression is evaluated. If a matching expression is not found via a when attribute then an element with the default
* attribute is displayed.
*
* <div class="alert alert-info">
* Be aware that the attribute values to match against cannot be expressions. They are interpreted
* as literal string values to match against.
* For example, **`ng-switch-when="someVal"`** will match against the string `"someVal"` not against the
* value of the expression `$scope.someVal`.
* </div>
* @animations
* enter - happens after the ngSwitch contents change and the matched child element is placed inside the container
* leave - happens just after the ngSwitch contents change and just before the former contents are removed from the DOM
*
* @usage
* <ANY ng-switch="expression">
* <ANY ng-switch-when="matchValue1">...</ANY>
* <ANY ng-switch-when="matchValue2">...</ANY>
* <ANY ng-switch-default>...</ANY>
* </ANY>
*
*
* @scope
* @priority 800
* @param {*} ngSwitch|on expression to match against <tt>ng-switch-when</tt>.
* @paramDescription
* On child elements add:
*
* * `ngSwitchWhen`: the case statement to match against. If match then this
* case will be displayed. If the same match appears multiple times, all the
* elements will be displayed.
* * `ngSwitchDefault`: the default case when no other case match. If there
* are multiple default cases, all of them will be displayed when no other
* case match.
*
*
* @example
<example animations="true">
<file name="index.html">
<div ng-controller="Ctrl">
<select ng-model="selection" ng-options="item for item in items">
</select>
<tt>selection={{selection}}</tt>
<hr/>
<div class="animate-switch-container"
ng-switch on="selection">
<div class="animate-switch" ng-switch-when="settings">Settings Div</div>
<div class="animate-switch" ng-switch-when="home">Home Span</div>
<div class="animate-switch" ng-switch-default>default</div>
</div>
</div>
</file>
<file name="script.js">
function Ctrl($scope) {
$scope.items = ['settings', 'home', 'other'];
$scope.selection = $scope.items[0];
}
</file>
<file name="animations.css">
.animate-switch-container {
position:relative;
background:white;
border:1px solid black;
height:40px;
overflow:hidden;
}
.animate-switch {
padding:10px;
}
.animate-switch.ng-animate {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
position:absolute;
top:0;
left:0;
right:0;
bottom:0;
}
.animate-switch.ng-leave.ng-leave-active,
.animate-switch.ng-enter {
top:-50px;
}
.animate-switch.ng-leave,
.animate-switch.ng-enter.ng-enter-active {
top:0;
}
</file>
<file name="scenario.js">
it('should start in settings', function() {
expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Settings Div/);
});
it('should change to home', function() {
select('selection').option('home');
expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Home Span/);
});
it('should select default', function() {
select('selection').option('other');
expect(element('.doc-example-live [ng-switch]').text()).toMatch(/default/);
});
</file>
</example>
*/
var ngSwitchDirective = [
"$animate",
function ($animate) {
return {
restrict: "EA",
require: "ngSwitch",
// asks for $scope to fool the BC controller module
controller: [
"$scope",
function ngSwitchController() {
this.cases = {};
},
],
link: function (scope, element, attr, ngSwitchController) {
var watchExpr = attr.ngSwitch || attr.on,
selectedTranscludes,
selectedElements,
selectedScopes = [];
scope.$watch(watchExpr, function ngSwitchWatchAction(value) {
for (var i = 0, ii = selectedScopes.length; i < ii; i++) {
selectedScopes[i].$destroy();
$animate.leave(selectedElements[i]);
}
selectedElements = [];
selectedScopes = [];
if (
(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);
},
);
});
}
});
},
};
},
];
var 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,
});
};
},
});
var 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 });
},
});
/**
* @ngdoc directive
* @name ng.directive:ngTransclude
* @restrict AC
*
* @description
* Directive that marks the insertion point for the transcluded DOM of the nearest parent directive that uses transclusion.
*
* Any existing content of the element that this directive is placed on will be removed before the transcluded content is inserted.
*
* @element ANY
*
* @example
<doc:example module="transclude">
<doc:source>
<script>
function Ctrl($scope) {
$scope.title = 'Lorem Ipsum';
$scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
}
angular.module('transclude', [])
.directive('pane', function(){
return {
restrict: 'E',
transclude: true,
scope: { title:'@' },
template: '<div style="border: 1px solid black;">' +
'<div style="background-color: gray">{{title}}</div>' +
'<div ng-transclude></div>' +
'</div>'
};
});
</script>
<div ng-controller="Ctrl">
<input ng-model="title"><br>
<textarea ng-model="text"></textarea> <br/>
<pane title="{{title}}">{{text}}</pane>
</div>
</doc:source>
<doc:scenario>
it('should have transcluded', function() {
input('title').enter('TITLE');
input('text').enter('TEXT');
expect(binding('title')).toEqual('TITLE');
expect(binding('text')).toEqual('TEXT');
});
</doc:scenario>
</doc:example>
*
*/
var 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),
);
}
// remember the transclusion fn but call it during linking so that we don't process transclusion before directives on
// the parent element even when the transclusion replaces the current element. (we can't use priority here because
// that applies only to compile fns and not controllers
this.$transclude = $transclude;
},
],
link: function ($scope, $element, $attrs, controller) {
controller.$transclude(function (clone) {
$element.empty();
$element.append(clone);
});
},
});
/**
* @ngdoc directive
* @name ng.directive:script
* @restrict E
*
* @description
* Load content of a script tag, with type `text/ng-template`, into `$templateCache`, so that the
* template can be used by `ngInclude`, `ngView` or directive templates.
*
* @param {'text/ng-template'} type must be set to `'text/ng-template'`
*
* @example
<doc:example>
<doc:source>
<script type="text/ng-template" id="/tpl.html">
Content of the template.
</script>
<a ng-click="currentTpl='/tpl.html'" id="tpl-link">Load inlined template</a>
<div id="tpl-content" ng-include src="currentTpl"></div>
</doc:source>
<doc:scenario>
it('should load template defined inside script tag', function() {
element('#tpl-link').click();
expect(element('#tpl-content').text()).toMatch(/Content of the template/);
});
</doc:scenario>
</doc:example>
*/
var scriptDirective = [
"$templateCache",
function ($templateCache) {
return {
restrict: "E",
terminal: true,
compile: function (element, attr) {
if (attr.type == "text/ng-template") {
var templateUrl = attr.id,
// IE is not consistent, in scripts we have to read .text but in other nodes we have to read .textContent
text = element[0].text;
$templateCache.put(templateUrl, text);
}
},
};
},
];
var ngOptionsMinErr = minErr("ngOptions");
/**
* @ngdoc directive
* @name ng.directive:select
* @restrict E
*
* @description
* HTML `SELECT` element with angular data-binding.
*
* # `ngOptions`
*
* The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
* elements for the `<select>` element using the array or object obtained by evaluating the
* `ngOptions` comprehension_expression.
*
* When an item in the `<select>` menu is selected, the array element or object property
* represented by the selected option will be bound to the model identified by the `ngModel`
* directive.
*
* Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
* be nested into the `<select>` element. This element will then represent the `null` or "not selected"
* option. See example below for demonstration.
*
* Note: `ngOptions` provides iterator facility for `<option>` element which should be used instead
* of {@link ng.directive:ngRepeat ngRepeat} when you want the
* `select` model to be bound to a non-string value. This is because an option element can only
* be bound to string values at present.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required The control is considered valid only if value is entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {comprehension_expression=} ngOptions in one of the following forms:
*
* * for array data sources:
* * `label` **`for`** `value` **`in`** `array`
* * `select` **`as`** `label` **`for`** `value` **`in`** `array`
* * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
* * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
* * for object data sources:
* * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
* * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
* * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
* * `select` **`as`** `label` **`group by`** `group`
* **`for` `(`**`key`**`,`** `value`**`) in`** `object`
*
* Where:
*
* * `array` / `object`: an expression which evaluates to an array / object to iterate over.
* * `value`: local variable which will refer to each item in the `array` or each property value
* of `object` during iteration.
* * `key`: local variable which will refer to a property name in `object` during iteration.
* * `label`: The result of this expression will be the label for `<option>` element. The
* `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
* * `select`: The result of this expression will be bound to the model of the parent `<select>`
* element. If not specified, `select` expression will default to `value`.
* * `group`: The result of this expression will be used to group options using the `<optgroup>`
* DOM element.
* * `trackexpr`: Used when working with an array of objects. The result of this expression will be
* used to identify the objects in the array. The `trackexpr` will most likely refer to the
* `value` variable (e.g. `value.propertyName`).
*
* @example
<doc:example>
<doc:source>
<script>
function MyCntrl($scope) {
$scope.colors = [
{name:'black', shade:'dark'},
{name:'white', shade:'light'},
{name:'red', shade:'dark'},
{name:'blue', shade:'dark'},
{name:'yellow', shade:'light'}
];
$scope.color = $scope.colors[2]; // red
}
</script>
<div ng-controller="MyCntrl">
<ul>
<li ng-repeat="color in colors">
Name: <input ng-model="color.name">
[<a href ng-click="colors.splice($index, 1)">X</a>]
</li>
<li>
[<a href ng-click="colors.push({})">add</a>]
</li>
</ul>
<hr/>
Color (null not allowed):
<select ng-model="color" ng-options="c.name for c in colors"></select><br>
Color (null allowed):
<span class="nullable">
<select ng-model="color" ng-options="c.name for c in colors">
<option value="">-- choose color --</option>
</select>
</span><br/>
Color grouped by shade:
<select ng-model="color" ng-options="c.name group by c.shade for c in colors">
</select><br/>
Select <a href ng-click="color={name:'not in list'}">bogus</a>.<br>
<hr/>
Currently selected: {{ {selected_color:color} }}
<div style="border:solid 1px black; height:20px"
ng-style="{'background-color':color.name}">
</div>
</div>
</doc:source>
<doc:scenario>
it('should check ng-options', function() {
expect(binding('{selected_color:color}')).toMatch('red');
select('color').option('0');
expect(binding('{selected_color:color}')).toMatch('black');
using('.nullable').select('color').option('');
expect(binding('{selected_color:color}')).toMatch('null');
});
</doc:scenario>
</doc:example>
*/
var ngOptionsDirective = valueFn({ terminal: true });
// jshint maxlen: false
var selectDirective = [
"$compile",
"$parse",
function ($compile, $parse) {
//0000111110000000000022220000000000000000000000333300000000000000444444444444444000000000555555555555555000000066666666666666600000000000000007777000000000000000000088888
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 };
// jshint maxlen: 100
return {
restrict: "E",
require: ["select", "?ngModel"],
controller: [
"$element",
"$scope",
"$attrs",
function ($element, $scope, $attrs) {
var self = this,
optionsMap = {},
ngModelCtrl = nullModelCtrl,
nullOption,
unknownOption;
self.databound = $attrs.ngModel;
self.init = function (ngModelCtrl_, nullOption_, unknownOption_) {
ngModelCtrl = ngModelCtrl_;
nullOption = nullOption_;
unknownOption = unknownOption_;
};
self.addOption = function (value) {
assertNotHasOwnProperty(value, '"option value"');
optionsMap[value] = true;
if (ngModelCtrl.$viewValue == value) {
$element.val(value);
if (unknownOption.parent()) unknownOption.remove();
}
};
self.removeOption = function (value) {
if (this.hasOption(value)) {
delete optionsMap[value];
if (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", true); // needed for IE
};
self.hasOption = function (value) {
return optionsMap.hasOwnProperty(value);
};
$scope.$on("$destroy", function () {
// disable unknown option so that we don't do work when the whole select is being destroyed
self.renderUnknownOption = noop;
});
},
],
link: function (scope, element, attr, ctrls) {
// if ngModel is not defined, we don't need to do anything
if (!ctrls[1]) return;
var selectCtrl = ctrls[0],
ngModelCtrl = ctrls[1],
multiple = attr.multiple,
optionsExp = attr.ngOptions,
nullOption = false, // if false, user will not be able to select it (used by ngOptions)
emptyOption,
// we can't just jqLite('<option>') since jqLite is not smart enough
// to create it in <select> and IE barfs otherwise.
optionTemplate = jqLite(document.createElement("option")),
optGroupTemplate = jqLite(document.createElement("optgroup")),
unknownOption = optionTemplate.clone();
// find "null" option
for (
var i = 0, children = element.children(), ii = children.length;
i < ii;
i++
) {
if (children[i].value === "") {
emptyOption = nullOption = children.eq(i);
break;
}
}
selectCtrl.init(ngModelCtrl, nullOption, unknownOption);
// required validator
if (multiple && (attr.required || attr.ngRequired)) {
var requiredValidator = function (value) {
ngModelCtrl.$setValidity(
"required",
!attr.required || (value && value.length),
);
return value;
};
ngModelCtrl.$parsers.push(requiredValidator);
ngModelCtrl.$formatters.unshift(requiredValidator);
attr.$observe("required", function () {
requiredValidator(ngModelCtrl.$viewValue);
});
}
if (optionsExp) setupAsOptions(scope, element, ngModelCtrl);
else if (multiple) setupAsMultiple(scope, element, ngModelCtrl);
else setupAsSingle(scope, element, ngModelCtrl, selectCtrl);
////////////////////////////
function setupAsSingle(
scope,
selectElement,
ngModelCtrl,
selectCtrl,
) {
ngModelCtrl.$render = function () {
var viewValue = ngModelCtrl.$viewValue;
if (selectCtrl.hasOption(viewValue)) {
if (unknownOption.parent()) unknownOption.remove();
selectElement.val(viewValue);
if (viewValue === "") emptyOption.prop("selected", true); // to make IE9 happy
} else {
if (isUndefined(viewValue) && emptyOption) {
selectElement.val("");
} else {
selectCtrl.renderUnknownOption(viewValue);
}
}
};
selectElement.on("change", function () {
scope.$apply(function () {
if (unknownOption.parent()) unknownOption.remove();
ngModelCtrl.$setViewValue(selectElement.val());
});
});
}
function setupAsMultiple(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));
});
};
// we have to do it on each watch since ngModel watches reference, but
// we need to work of an array, so we need to see if anything was inserted/removed
scope.$watch(function selectMultipleWatch() {
if (!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) {
if (option.selected) {
array.push(option.value);
}
});
ctrl.$setViewValue(array);
});
});
}
function setupAsOptions(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]),
track = match[8],
trackFn = track ? $parse(match[8]) : null,
// This is an array of array of existing option groups in DOM.
// We try to reuse these if possible
// - optionGroupsCache[0] is the options with no option group
// - optionGroupsCache[?][0] is the parent: either the SELECT or OPTGROUP element
optionGroupsCache = [[{ element: selectElement, label: "" }]];
if (nullOption) {
// compile the element since there might be bindings in it
$compile(nullOption)(scope);
// remove the class, which is added automatically because we recompile the element and it
// becomes the compilation root
nullOption.removeClass("ng-scope");
// we need to remove it before calling selectElement.empty() because otherwise IE will
// remove the label from the element. wtf?
nullOption.remove();
}
// clear contents, we'll add what's needed based on the model
selectElement.empty();
selectElement.on("change", function () {
scope.$apply(function () {
var optionGroup,
collection = valuesFn(scope) || [],
locals = {},
key,
value,
optionElement,
index,
groupIndex,
length,
groupLength,
trackIndex;
if (multiple) {
value = [];
for (
groupIndex = 0, groupLength = optionGroupsCache.length;
groupIndex < groupLength;
groupIndex++
) {
// list of options for that group. (first item has the parent)
optionGroup = optionGroupsCache[groupIndex];
for (
index = 1, length = optionGroup.length;
index < length;
index++
) {
if (
(optionElement = optionGroup[index].element)[0].selected
) {
key = optionElement.val();
if (keyName) locals[keyName] = key;
if (trackFn) {
for (
trackIndex = 0;
trackIndex < collection.length;
trackIndex++
) {
locals[valueName] = collection[trackIndex];
if (trackFn(scope, locals) == key) break;
}
} else {
locals[valueName] = collection[key];
}
value.push(valueFn(scope, locals));
}
}
}
} else {
key = selectElement.val();
if (key == "?") {
value = undefined;
} else if (key === "") {
value = null;
} else {
if (trackFn) {
for (
trackIndex = 0;
trackIndex < collection.length;
trackIndex++
) {
locals[valueName] = collection[trackIndex];
if (trackFn(scope, locals) == key) {
value = valueFn(scope, locals);
break;
}
}
} else {
locals[valueName] = collection[key];
if (keyName) locals[keyName] = key;
value = valueFn(scope, locals);
}
}
}
ctrl.$setViewValue(value);
});
});
ctrl.$render = render;
// TODO(vojta): can't we optimize this ?
scope.$watch(render);
function render() {
// Temporary location for the option groups before we render them
var optionGroups = { "": [] },
optionGroupNames = [""],
optionGroupName,
optionGroup,
option,
existingParent,
existingOptions,
existingOption,
modelValue = ctrl.$modelValue,
values = valuesFn(scope) || [],
keys = keyName ? sortedKeys(values) : values,
key,
groupLength,
length,
groupIndex,
index,
locals = {},
selected,
selectedSet = false, // nothing is selected yet
lastElement,
element,
label;
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);
}
}
// We now build up the list of options we need (we merge later)
for (index = 0; (length = keys.length), index < length; index++) {
key = index;
if (keyName) {
key = keys[index];
if (key.charAt(0) === "$") continue;
locals[keyName] = key;
}
locals[valueName] = values[key];
optionGroupName = groupByFn(scope, locals) || "";
if (!(optionGroup = optionGroups[optionGroupName])) {
optionGroup = optionGroups[optionGroupName] = [];
optionGroupNames.push(optionGroupName);
}
if (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; // see if at least one item is selected
}
label = displayFn(scope, locals); // what will be seen by the user
// doing displayFn(scope, locals) || '' overwrites zero values
label = isDefined(label) ? label : "";
optionGroup.push({
// either the index into array or key from object
id: trackFn
? trackFn(scope, locals)
: keyName
? keys[index]
: index,
label: label,
selected: selected, // determine if we should be selected
});
}
if (!multiple) {
if (nullOption || modelValue === null) {
// insert null option if we have a placeholder, or the model is null
optionGroups[""].unshift({
id: "",
label: "",
selected: !selectedSet,
});
} else if (!selectedSet) {
// option could not be found, we have to insert the undefined item
optionGroups[""].unshift({
id: "?",
label: "",
selected: true,
});
}
}
// Now we need to update the list of DOM nodes to match the optionGroups we computed above
for (
groupIndex = 0, groupLength = optionGroupNames.length;
groupIndex < groupLength;
groupIndex++
) {
// current option group name or '' if no group
optionGroupName = optionGroupNames[groupIndex];
// list of options for that group. (first item has the parent)
optionGroup = optionGroups[optionGroupName];
if (optionGroupsCache.length <= groupIndex) {
// we need to grow the optionGroups
existingParent = {
element: optGroupTemplate
.clone()
.attr("label", optionGroupName),
label: optionGroup.label,
};
existingOptions = [existingParent];
optionGroupsCache.push(existingOptions);
selectElement.append(existingParent.element);
} else {
existingOptions = optionGroupsCache[groupIndex];
existingParent = existingOptions[0]; // either SELECT (no group) or OPTGROUP element
// update the OPTGROUP label if not the same.
if (existingParent.label != optionGroupName) {
existingParent.element.attr(
"label",
(existingParent.label = optionGroupName),
);
}
}
lastElement = null; // start at the beginning
for (
index = 0, length = optionGroup.length;
index < length;
index++
) {
option = optionGroup[index];
if ((existingOption = existingOptions[index + 1])) {
// reuse elements
lastElement = existingOption.element;
if (existingOption.label !== option.label) {
lastElement.text((existingOption.label = option.label));
}
if (existingOption.id !== option.id) {
lastElement.val((existingOption.id = option.id));
}
// lastElement.prop('selected') provided by jQuery has side-effects
if (lastElement[0].selected !== option.selected) {
lastElement.prop(
"selected",
(existingOption.selected = option.selected),
);
}
} else {
// grow elements
// if it's a null option
if (option.id === "" && nullOption) {
// put back the pre-compiled element
element = nullOption;
} else {
// jQuery(v1.4.2) Bug: We should be able to chain the method calls, but
// in this version of jQuery on some browser the .text() returns a string
// rather then the element.
(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,
}),
);
if (lastElement) {
lastElement.after(element);
} else {
existingParent.element.append(element);
}
lastElement = element;
}
}
// remove any excessive OPTIONs in a group
index++; // increment since the existingOptions[0] is parent element not OPTION
while (existingOptions.length > index) {
existingOptions.pop().element.remove();
}
}
// remove any excessive OPTGROUPs from select
while (optionGroupsCache.length > groupIndex) {
optionGroupsCache.pop()[0].element.remove();
}
}
}
},
};
},
];
var 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(), true);
if (!interpolateFn) {
attr.$set("value", element.text());
}
}
return function (scope, element, attr) {
var selectCtrlName = "$selectController",
parent = element.parent(),
selectCtrl =
parent.data(selectCtrlName) ||
parent.parent().data(selectCtrlName); // in case we are in optgroup
if (selectCtrl && selectCtrl.databound) {
// For some reason Opera defaults to true and if not overridden this messes up the repeater.
// We don't want the view to drive the initialization of the model anyway.
element.prop("selected", false);
} else {
selectCtrl = nullSelectCtrl;
}
if (interpolateFn) {
scope.$watch(
interpolateFn,
function interpolateWatchAction(newVal, oldVal) {
attr.$set("value", newVal);
if (newVal !== oldVal) selectCtrl.removeOption(oldVal);
selectCtrl.addOption(newVal);
},
);
} else {
selectCtrl.addOption(attr.value);
}
element.on("$destroy", function () {
selectCtrl.removeOption(attr.value);
});
};
},
};
},
];
var styleDirective = valueFn({
restrict: "E",
terminal: true,
});
//try to bind to jquery now so that one can write angular.element().read()
//but we will rebind on bootstrap again.
bindJQuery();
publishExternalAPI(angular);
jqLite(document).ready(function () {
angularInit(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>',
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/backbone-1.1.0.js | JavaScript | // Backbone.js 1.1.0
// (c) 2010-2011 Jeremy Ashkenas, DocumentCloud Inc.
// (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Backbone may be freely distributed under the MIT license.
// For all details and documentation:
// http://backbonejs.org
(function () {
// Initial Setup
// -------------
// Save a reference to the global object (`window` in the browser, `exports`
// on the server).
var root = this;
// Save the previous value of the `Backbone` variable, so that it can be
// restored later on, if `noConflict` is used.
var previousBackbone = root.Backbone;
// Create local references to array methods we'll want to use later.
var array = [];
var push = array.push;
var slice = array.slice;
var splice = array.splice;
// The top-level namespace. All public Backbone classes and modules will
// be attached to this. Exported for both the browser and the server.
var Backbone;
if (typeof exports !== "undefined") {
Backbone = exports;
} else {
Backbone = root.Backbone = {};
}
// Current version of the library. Keep in sync with `package.json`.
Backbone.VERSION = "1.1.0";
// Require Underscore, if we're on the server, and it's not already present.
var _ = root._;
if (!_ && typeof require !== "undefined") _ = require("underscore");
// For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
// the `$` variable.
Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
// Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
// to its previous owner. Returns a reference to this Backbone object.
Backbone.noConflict = function () {
root.Backbone = previousBackbone;
return this;
};
// Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
// will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and
// set a `X-Http-Method-Override` header.
Backbone.emulateHTTP = false;
// Turn on `emulateJSON` to support legacy servers that can't deal with direct
// `application/json` requests ... will encode the body as
// `application/x-www-form-urlencoded` instead and will send the model in a
// form param named `model`.
Backbone.emulateJSON = false;
// Backbone.Events
// ---------------
// A module that can be mixed in to *any object* in order to provide it with
// custom events. You may bind with `on` or remove with `off` callback
// functions to an event; `trigger`-ing an event fires all callbacks in
// succession.
//
// var object = {};
// _.extend(object, Backbone.Events);
// object.on('expand', function(){ alert('expanded'); });
// object.trigger('expand');
//
var Events = (Backbone.Events = {
// Bind an event to a `callback` function. Passing `"all"` will bind
// the callback to all events fired.
on: function (name, callback, context) {
if (!eventsApi(this, "on", name, [callback, context]) || !callback)
return this;
this._events || (this._events = {});
var events = this._events[name] || (this._events[name] = []);
events.push({
callback: callback,
context: context,
ctx: context || this,
});
return this;
},
// Bind an event to only be triggered a single time. After the first time
// the callback is invoked, it will be removed.
once: function (name, callback, context) {
if (!eventsApi(this, "once", name, [callback, context]) || !callback)
return this;
var self = this;
var once = _.once(function () {
self.off(name, once);
callback.apply(this, arguments);
});
once._callback = callback;
return this.on(name, once, context);
},
// Remove one or many callbacks. If `context` is null, removes all
// callbacks with that function. If `callback` is null, removes all
// callbacks for the event. If `name` is null, removes all bound
// callbacks for all events.
off: function (name, callback, context) {
var retain, ev, events, names, i, l, j, k;
if (!this._events || !eventsApi(this, "off", name, [callback, context]))
return this;
if (!name && !callback && !context) {
this._events = {};
return this;
}
names = name ? [name] : _.keys(this._events);
for (i = 0, l = names.length; i < l; i++) {
name = names[i];
if ((events = this._events[name])) {
this._events[name] = retain = [];
if (callback || context) {
for (j = 0, k = events.length; j < k; j++) {
ev = events[j];
if (
(callback &&
callback !== ev.callback &&
callback !== ev.callback._callback) ||
(context && context !== ev.context)
) {
retain.push(ev);
}
}
}
if (!retain.length) delete this._events[name];
}
}
return this;
},
// Trigger one or many events, firing all bound callbacks. Callbacks are
// passed the same arguments as `trigger` is, apart from the event name
// (unless you're listening on `"all"`, which will cause your callback to
// receive the true name of the event as the first argument).
trigger: function (name) {
if (!this._events) return this;
var args = slice.call(arguments, 1);
if (!eventsApi(this, "trigger", name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(events, args);
if (allEvents) triggerEvents(allEvents, arguments);
return this;
},
// Tell this object to stop listening to either specific events ... or
// to every object it's currently listening to.
stopListening: function (obj, name, callback) {
var listeningTo = this._listeningTo;
if (!listeningTo) return this;
var remove = !name && !callback;
if (!callback && typeof name === "object") callback = this;
if (obj) (listeningTo = {})[obj._listenId] = obj;
for (var id in listeningTo) {
obj = listeningTo[id];
obj.off(name, callback, this);
if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
}
return this;
},
});
// Regular expression used to split event strings.
var eventSplitter = /\s+/;
// Implement fancy features of the Events API such as multiple event
// names `"change blur"` and jQuery-style event maps `{change: action}`
// in terms of the existing API.
var eventsApi = function (obj, action, name, rest) {
if (!name) return true;
// Handle event maps.
if (typeof name === "object") {
for (var key in name) {
obj[action].apply(obj, [key, name[key]].concat(rest));
}
return false;
}
// Handle space separated event names.
if (eventSplitter.test(name)) {
var names = name.split(eventSplitter);
for (var i = 0, l = names.length; i < l; i++) {
obj[action].apply(obj, [names[i]].concat(rest));
}
return false;
}
return true;
};
// A difficult-to-believe, but optimized internal dispatch function for
// triggering events. Tries to keep the usual cases speedy (most internal
// Backbone events have 3 arguments).
var triggerEvents = function (events, args) {
var ev,
i = -1,
l = events.length,
a1 = args[0],
a2 = args[1],
a3 = args[2];
switch (args.length) {
case 0:
while (++i < l) (ev = events[i]).callback.call(ev.ctx);
return;
case 1:
while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1);
return;
case 2:
while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2);
return;
case 3:
while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
return;
default:
while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
}
};
var listenMethods = { listenTo: "on", listenToOnce: "once" };
// Inversion-of-control versions of `on` and `once`. Tell *this* object to
// listen to an event in another object ... keeping track of what it's
// listening to.
_.each(listenMethods, function (implementation, method) {
Events[method] = function (obj, name, callback) {
var listeningTo = this._listeningTo || (this._listeningTo = {});
var id = obj._listenId || (obj._listenId = _.uniqueId("l"));
listeningTo[id] = obj;
if (!callback && typeof name === "object") callback = this;
obj[implementation](name, callback, this);
return this;
};
});
// Aliases for backwards compatibility.
Events.bind = Events.on;
Events.unbind = Events.off;
// Allow the `Backbone` object to serve as a global event bus, for folks who
// want global "pubsub" in a convenient place.
_.extend(Backbone, Events);
// Backbone.Model
// --------------
// Backbone **Models** are the basic data object in the framework --
// frequently representing a row in a table in a database on your server.
// A discrete chunk of data and a bunch of useful, related methods for
// performing computations and transformations on that data.
// Create a new model with the specified attributes. A client id (`cid`)
// is automatically generated and assigned for you.
var Model = (Backbone.Model = function (attributes, options) {
var attrs = attributes || {};
options || (options = {});
this.cid = _.uniqueId("c");
this.attributes = {};
if (options.collection) this.collection = options.collection;
if (options.parse) attrs = this.parse(attrs, options) || {};
attrs = _.defaults({}, attrs, _.result(this, "defaults"));
this.set(attrs, options);
this.changed = {};
this.initialize.apply(this, arguments);
});
// Attach all inheritable methods to the Model prototype.
_.extend(Model.prototype, Events, {
// A hash of attributes whose current and previous value differ.
changed: null,
// The value returned during the last failed validation.
validationError: null,
// The default name for the JSON `id` attribute is `"id"`. MongoDB and
// CouchDB users may want to set this to `"_id"`.
idAttribute: "id",
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function () {},
// Return a copy of the model's `attributes` object.
toJSON: function (options) {
return _.clone(this.attributes);
},
// Proxy `Backbone.sync` by default -- but override this if you need
// custom syncing semantics for *this* particular model.
sync: function () {
return Backbone.sync.apply(this, arguments);
},
// Get the value of an attribute.
get: function (attr) {
return this.attributes[attr];
},
// Get the HTML-escaped value of an attribute.
escape: function (attr) {
return _.escape(this.get(attr));
},
// Returns `true` if the attribute contains a value that is not null
// or undefined.
has: function (attr) {
return this.get(attr) != null;
},
// Set a hash of model attributes on the object, firing `"change"`. This is
// the core primitive operation of a model, updating the data and notifying
// anyone who needs to know about the change in state. The heart of the beast.
set: function (key, val, options) {
var attr, attrs, unset, changes, silent, changing, prev, current;
if (key == null) return this;
// Handle both `"key", value` and `{key: value}` -style arguments.
if (typeof key === "object") {
attrs = key;
options = val;
} else {
(attrs = {})[key] = val;
}
options || (options = {});
// Run validation.
if (!this._validate(attrs, options)) return false;
// Extract attributes and options.
unset = options.unset;
silent = options.silent;
changes = [];
changing = this._changing;
this._changing = true;
if (!changing) {
this._previousAttributes = _.clone(this.attributes);
this.changed = {};
}
(current = this.attributes), (prev = this._previousAttributes);
// Check for changes of `id`.
if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
// For each `set` attribute, update or delete the current value.
for (attr in attrs) {
val = attrs[attr];
if (!_.isEqual(current[attr], val)) changes.push(attr);
if (!_.isEqual(prev[attr], val)) {
this.changed[attr] = val;
} else {
delete this.changed[attr];
}
unset ? delete current[attr] : (current[attr] = val);
}
// Trigger all relevant attribute changes.
if (!silent) {
if (changes.length) this._pending = true;
for (var i = 0, l = changes.length; i < l; i++) {
this.trigger(
"change:" + changes[i],
this,
current[changes[i]],
options,
);
}
}
// You might be wondering why there's a `while` loop here. Changes can
// be recursively nested within `"change"` events.
if (changing) return this;
if (!silent) {
while (this._pending) {
this._pending = false;
this.trigger("change", this, options);
}
}
this._pending = false;
this._changing = false;
return this;
},
// Remove an attribute from the model, firing `"change"`. `unset` is a noop
// if the attribute doesn't exist.
unset: function (attr, options) {
return this.set(attr, void 0, _.extend({}, options, { unset: true }));
},
// Clear all attributes on the model, firing `"change"`.
clear: function (options) {
var attrs = {};
for (var key in this.attributes) attrs[key] = void 0;
return this.set(attrs, _.extend({}, options, { unset: true }));
},
// Determine if the model has changed since the last `"change"` event.
// If you specify an attribute name, determine if that attribute has changed.
hasChanged: function (attr) {
if (attr == null) return !_.isEmpty(this.changed);
return _.has(this.changed, attr);
},
// Return an object containing all the attributes that have changed, or
// false if there are no changed attributes. Useful for determining what
// parts of a view need to be updated and/or what attributes need to be
// persisted to the server. Unset attributes will be set to undefined.
// You can also pass an attributes object to diff against the model,
// determining if there *would be* a change.
changedAttributes: function (diff) {
if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
var val,
changed = false;
var old = this._changing ? this._previousAttributes : this.attributes;
for (var attr in diff) {
if (_.isEqual(old[attr], (val = diff[attr]))) continue;
(changed || (changed = {}))[attr] = val;
}
return changed;
},
// Get the previous value of an attribute, recorded at the time the last
// `"change"` event was fired.
previous: function (attr) {
if (attr == null || !this._previousAttributes) return null;
return this._previousAttributes[attr];
},
// Get all of the attributes of the model at the time of the previous
// `"change"` event.
previousAttributes: function () {
return _.clone(this._previousAttributes);
},
// Fetch the model from the server. If the server's representation of the
// model differs from its current attributes, they will be overridden,
// triggering a `"change"` event.
fetch: function (options) {
options = options ? _.clone(options) : {};
if (options.parse === void 0) options.parse = true;
var model = this;
var success = options.success;
options.success = function (resp) {
if (!model.set(model.parse(resp, options), options)) return false;
if (success) success(model, resp, options);
model.trigger("sync", model, resp, options);
};
wrapError(this, options);
return this.sync("read", this, options);
},
// Set a hash of model attributes, and sync the model to the server.
// If the server returns an attributes hash that differs, the model's
// state will be `set` again.
save: function (key, val, options) {
var attrs,
method,
xhr,
attributes = this.attributes;
// Handle both `"key", value` and `{key: value}` -style arguments.
if (key == null || typeof key === "object") {
attrs = key;
options = val;
} else {
(attrs = {})[key] = val;
}
options = _.extend({ validate: true }, options);
// If we're not waiting and attributes exist, save acts as
// `set(attr).save(null, opts)` with validation. Otherwise, check if
// the model will be valid when the attributes, if any, are set.
if (attrs && !options.wait) {
if (!this.set(attrs, options)) return false;
} else {
if (!this._validate(attrs, options)) return false;
}
// Set temporary attributes if `{wait: true}`.
if (attrs && options.wait) {
this.attributes = _.extend({}, attributes, attrs);
}
// After a successful server-side save, the client is (optionally)
// updated with the server-side state.
if (options.parse === void 0) options.parse = true;
var model = this;
var success = options.success;
options.success = function (resp) {
// Ensure attributes are restored during synchronous saves.
model.attributes = attributes;
var serverAttrs = model.parse(resp, options);
if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
return false;
}
if (success) success(model, resp, options);
model.trigger("sync", model, resp, options);
};
wrapError(this, options);
method = this.isNew() ? "create" : options.patch ? "patch" : "update";
if (method === "patch") options.attrs = attrs;
xhr = this.sync(method, this, options);
// Restore attributes.
if (attrs && options.wait) this.attributes = attributes;
return xhr;
},
// Destroy this model on the server if it was already persisted.
// Optimistically removes the model from its collection, if it has one.
// If `wait: true` is passed, waits for the server to respond before removal.
destroy: function (options) {
options = options ? _.clone(options) : {};
var model = this;
var success = options.success;
var destroy = function () {
model.trigger("destroy", model, model.collection, options);
};
options.success = function (resp) {
if (options.wait || model.isNew()) destroy();
if (success) success(model, resp, options);
if (!model.isNew()) model.trigger("sync", model, resp, options);
};
if (this.isNew()) {
options.success();
return false;
}
wrapError(this, options);
var xhr = this.sync("delete", this, options);
if (!options.wait) destroy();
return xhr;
},
// Default URL for the model's representation on the server -- if you're
// using Backbone's restful methods, override this to change the endpoint
// that will be called.
url: function () {
var base =
_.result(this, "urlRoot") ||
_.result(this.collection, "url") ||
urlError();
if (this.isNew()) return base;
return (
base +
(base.charAt(base.length - 1) === "/" ? "" : "/") +
encodeURIComponent(this.id)
);
},
// **parse** converts a response into the hash of attributes to be `set` on
// the model. The default implementation is just to pass the response along.
parse: function (resp, options) {
return resp;
},
// Create a new model with identical attributes to this one.
clone: function () {
return new this.constructor(this.attributes);
},
// A model is new if it has never been saved to the server, and lacks an id.
isNew: function () {
return this.id == null;
},
// Check if the model is currently in a valid state.
isValid: function (options) {
return this._validate({}, _.extend(options || {}, { validate: true }));
},
// Run validation against the next complete set of model attributes,
// returning `true` if all is well. Otherwise, fire an `"invalid"` event.
_validate: function (attrs, options) {
if (!options.validate || !this.validate) return true;
attrs = _.extend({}, this.attributes, attrs);
var error = (this.validationError =
this.validate(attrs, options) || null);
if (!error) return true;
this.trigger(
"invalid",
this,
error,
_.extend(options, { validationError: error }),
);
return false;
},
});
// Underscore methods that we want to implement on the Model.
var modelMethods = ["keys", "values", "pairs", "invert", "pick", "omit"];
// Mix in each Underscore method as a proxy to `Model#attributes`.
_.each(modelMethods, function (method) {
Model.prototype[method] = function () {
var args = slice.call(arguments);
args.unshift(this.attributes);
return _[method].apply(_, args);
};
});
// Backbone.Collection
// -------------------
// If models tend to represent a single row of data, a Backbone Collection is
// more analagous to a table full of data ... or a small slice or page of that
// table, or a collection of rows that belong together for a particular reason
// -- all of the messages in this particular folder, all of the documents
// belonging to this particular author, and so on. Collections maintain
// indexes of their models, both in order, and for lookup by `id`.
// Create a new **Collection**, perhaps to contain a specific type of `model`.
// If a `comparator` is specified, the Collection will maintain
// its models in sort order, as they're added and removed.
var Collection = (Backbone.Collection = function (models, options) {
options || (options = {});
if (options.model) this.model = options.model;
if (options.comparator !== void 0) this.comparator = options.comparator;
this._reset();
this.initialize.apply(this, arguments);
if (models) this.reset(models, _.extend({ silent: true }, options));
});
// Default options for `Collection#set`.
var setOptions = { add: true, remove: true, merge: true };
var addOptions = { add: true, remove: false };
// Define the Collection's inheritable methods.
_.extend(Collection.prototype, Events, {
// The default model for a collection is just a **Backbone.Model**.
// This should be overridden in most cases.
model: Model,
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function () {},
// The JSON representation of a Collection is an array of the
// models' attributes.
toJSON: function (options) {
return this.map(function (model) {
return model.toJSON(options);
});
},
// Proxy `Backbone.sync` by default.
sync: function () {
return Backbone.sync.apply(this, arguments);
},
// Add a model, or list of models to the set.
add: function (models, options) {
return this.set(models, _.extend({ merge: false }, options, addOptions));
},
// Remove a model, or a list of models from the set.
remove: function (models, options) {
var singular = !_.isArray(models);
models = singular ? [models] : _.clone(models);
options || (options = {});
var i, l, index, model;
for (i = 0, l = models.length; i < l; i++) {
model = models[i] = this.get(models[i]);
if (!model) continue;
delete this._byId[model.id];
delete this._byId[model.cid];
index = this.indexOf(model);
this.models.splice(index, 1);
this.length--;
if (!options.silent) {
options.index = index;
model.trigger("remove", model, this, options);
}
this._removeReference(model);
}
return singular ? models[0] : models;
},
// Update a collection by `set`-ing a new list of models, adding new ones,
// removing models that are no longer present, and merging models that
// already exist in the collection, as necessary. Similar to **Model#set**,
// the core operation for updating the data contained by the collection.
set: function (models, options) {
options = _.defaults({}, options, setOptions);
if (options.parse) models = this.parse(models, options);
var singular = !_.isArray(models);
models = singular ? (models ? [models] : []) : _.clone(models);
var i, l, id, model, attrs, existing, sort;
var at = options.at;
var targetModel = this.model;
var sortable = this.comparator && at == null && options.sort !== false;
var sortAttr = _.isString(this.comparator) ? this.comparator : null;
var toAdd = [],
toRemove = [],
modelMap = {};
var add = options.add,
merge = options.merge,
remove = options.remove;
var order = !sortable && add && remove ? [] : false;
// Turn bare objects into model references, and prevent invalid models
// from being added.
for (i = 0, l = models.length; i < l; i++) {
attrs = models[i];
if (attrs instanceof Model) {
id = model = attrs;
} else {
id = attrs[targetModel.prototype.idAttribute];
}
// If a duplicate is found, prevent it from being added and
// optionally merge it into the existing model.
if ((existing = this.get(id))) {
if (remove) modelMap[existing.cid] = true;
if (merge) {
attrs = attrs === model ? model.attributes : attrs;
if (options.parse) attrs = existing.parse(attrs, options);
existing.set(attrs, options);
if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
}
models[i] = existing;
// If this is a new, valid model, push it to the `toAdd` list.
} else if (add) {
model = models[i] = this._prepareModel(attrs, options);
if (!model) continue;
toAdd.push(model);
// Listen to added models' events, and index models for lookup by
// `id` and by `cid`.
model.on("all", this._onModelEvent, this);
this._byId[model.cid] = model;
if (model.id != null) this._byId[model.id] = model;
}
if (order) order.push(existing || model);
}
// Remove nonexistent models if appropriate.
if (remove) {
for (i = 0, l = this.length; i < l; ++i) {
if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
}
if (toRemove.length) this.remove(toRemove, options);
}
// See if sorting is needed, update `length` and splice in new models.
if (toAdd.length || (order && order.length)) {
if (sortable) sort = true;
this.length += toAdd.length;
if (at != null) {
for (i = 0, l = toAdd.length; i < l; i++) {
this.models.splice(at + i, 0, toAdd[i]);
}
} else {
if (order) this.models.length = 0;
var orderedModels = order || toAdd;
for (i = 0, l = orderedModels.length; i < l; i++) {
this.models.push(orderedModels[i]);
}
}
}
// Silently sort the collection if appropriate.
if (sort) this.sort({ silent: true });
// Unless silenced, it's time to fire all appropriate add/sort events.
if (!options.silent) {
for (i = 0, l = toAdd.length; i < l; i++) {
(model = toAdd[i]).trigger("add", model, this, options);
}
if (sort || (order && order.length))
this.trigger("sort", this, options);
}
// Return the added (or merged) model (or models).
return singular ? models[0] : models;
},
// When you have more items than you want to add or remove individually,
// you can reset the entire set with a new list of models, without firing
// any granular `add` or `remove` events. Fires `reset` when finished.
// Useful for bulk operations and optimizations.
reset: function (models, options) {
options || (options = {});
for (var i = 0, l = this.models.length; i < l; i++) {
this._removeReference(this.models[i]);
}
options.previousModels = this.models;
this._reset();
models = this.add(models, _.extend({ silent: true }, options));
if (!options.silent) this.trigger("reset", this, options);
return models;
},
// Add a model to the end of the collection.
push: function (model, options) {
return this.add(model, _.extend({ at: this.length }, options));
},
// Remove a model from the end of the collection.
pop: function (options) {
var model = this.at(this.length - 1);
this.remove(model, options);
return model;
},
// Add a model to the beginning of the collection.
unshift: function (model, options) {
return this.add(model, _.extend({ at: 0 }, options));
},
// Remove a model from the beginning of the collection.
shift: function (options) {
var model = this.at(0);
this.remove(model, options);
return model;
},
// Slice out a sub-array of models from the collection.
slice: function () {
return slice.apply(this.models, arguments);
},
// Get a model from the set by id.
get: function (obj) {
if (obj == null) return void 0;
return this._byId[obj.id] || this._byId[obj.cid] || this._byId[obj];
},
// Get the model at the given index.
at: function (index) {
return this.models[index];
},
// Return models with matching attributes. Useful for simple cases of
// `filter`.
where: function (attrs, first) {
if (_.isEmpty(attrs)) return first ? void 0 : [];
return this[first ? "find" : "filter"](function (model) {
for (var key in attrs) {
if (attrs[key] !== model.get(key)) return false;
}
return true;
});
},
// Return the first model with matching attributes. Useful for simple cases
// of `find`.
findWhere: function (attrs) {
return this.where(attrs, true);
},
// Force the collection to re-sort itself. You don't need to call this under
// normal circumstances, as the set will maintain sort order as each item
// is added.
sort: function (options) {
if (!this.comparator)
throw new Error("Cannot sort a set without a comparator");
options || (options = {});
// Run sort based on type of `comparator`.
if (_.isString(this.comparator) || this.comparator.length === 1) {
this.models = this.sortBy(this.comparator, this);
} else {
this.models.sort(_.bind(this.comparator, this));
}
if (!options.silent) this.trigger("sort", this, options);
return this;
},
// Pluck an attribute from each model in the collection.
pluck: function (attr) {
return _.invoke(this.models, "get", attr);
},
// Fetch the default set of models for this collection, resetting the
// collection when they arrive. If `reset: true` is passed, the response
// data will be passed through the `reset` method instead of `set`.
fetch: function (options) {
options = options ? _.clone(options) : {};
if (options.parse === void 0) options.parse = true;
var success = options.success;
var collection = this;
options.success = function (resp) {
var method = options.reset ? "reset" : "set";
collection[method](resp, options);
if (success) success(collection, resp, options);
collection.trigger("sync", collection, resp, options);
};
wrapError(this, options);
return this.sync("read", this, options);
},
// Create a new instance of a model in this collection. Add the model to the
// collection immediately, unless `wait: true` is passed, in which case we
// wait for the server to agree.
create: function (model, options) {
options = options ? _.clone(options) : {};
if (!(model = this._prepareModel(model, options))) return false;
if (!options.wait) this.add(model, options);
var collection = this;
var success = options.success;
options.success = function (model, resp, options) {
if (options.wait) collection.add(model, options);
if (success) success(model, resp, options);
};
model.save(null, options);
return model;
},
// **parse** converts a response into a list of models to be added to the
// collection. The default implementation is just to pass it through.
parse: function (resp, options) {
return resp;
},
// Create a new collection with an identical list of models as this one.
clone: function () {
return new this.constructor(this.models);
},
// Private method to reset all internal state. Called when the collection
// is first initialized or reset.
_reset: function () {
this.length = 0;
this.models = [];
this._byId = {};
},
// Prepare a hash of attributes (or other model) to be added to this
// collection.
_prepareModel: function (attrs, options) {
if (attrs instanceof Model) {
if (!attrs.collection) attrs.collection = this;
return attrs;
}
options = options ? _.clone(options) : {};
options.collection = this;
var model = new this.model(attrs, options);
if (!model.validationError) return model;
this.trigger("invalid", this, model.validationError, options);
return false;
},
// Internal method to sever a model's ties to a collection.
_removeReference: function (model) {
if (this === model.collection) delete model.collection;
model.off("all", this._onModelEvent, this);
},
// Internal method called every time a model in the set fires an event.
// Sets need to update their indexes when models change ids. All other
// events simply proxy through. "add" and "remove" events that originate
// in other collections are ignored.
_onModelEvent: function (event, model, collection, options) {
if ((event === "add" || event === "remove") && collection !== this)
return;
if (event === "destroy") this.remove(model, options);
if (model && event === "change:" + model.idAttribute) {
delete this._byId[model.previous(model.idAttribute)];
if (model.id != null) this._byId[model.id] = model;
}
this.trigger.apply(this, arguments);
},
});
// Underscore methods that we want to implement on the Collection.
// 90% of the core usefulness of Backbone Collections is actually implemented
// right here:
var methods = [
"forEach",
"each",
"map",
"collect",
"reduce",
"foldl",
"inject",
"reduceRight",
"foldr",
"find",
"detect",
"filter",
"select",
"reject",
"every",
"all",
"some",
"any",
"include",
"contains",
"invoke",
"max",
"min",
"toArray",
"size",
"first",
"head",
"take",
"initial",
"rest",
"tail",
"drop",
"last",
"without",
"difference",
"indexOf",
"shuffle",
"lastIndexOf",
"isEmpty",
"chain",
];
// Mix in each Underscore method as a proxy to `Collection#models`.
_.each(methods, function (method) {
Collection.prototype[method] = function () {
var args = slice.call(arguments);
args.unshift(this.models);
return _[method].apply(_, args);
};
});
// Underscore methods that take a property name as an argument.
var attributeMethods = ["groupBy", "countBy", "sortBy"];
// Use attributes instead of properties.
_.each(attributeMethods, function (method) {
Collection.prototype[method] = function (value, context) {
var iterator = _.isFunction(value)
? value
: function (model) {
return model.get(value);
};
return _[method](this.models, iterator, context);
};
});
// Backbone.View
// -------------
// Backbone Views are almost more convention than they are actual code. A View
// is simply a JavaScript object that represents a logical chunk of UI in the
// DOM. This might be a single item, an entire list, a sidebar or panel, or
// even the surrounding frame which wraps your whole app. Defining a chunk of
// UI as a **View** allows you to define your DOM events declaratively, without
// having to worry about render order ... and makes it easy for the view to
// react to specific changes in the state of your models.
// Creating a Backbone.View creates its initial element outside of the DOM,
// if an existing element is not provided...
var View = (Backbone.View = function (options) {
this.cid = _.uniqueId("view");
options || (options = {});
_.extend(this, _.pick(options, viewOptions));
this._ensureElement();
this.initialize.apply(this, arguments);
this.delegateEvents();
});
// Cached regex to split keys for `delegate`.
var delegateEventSplitter = /^(\S+)\s*(.*)$/;
// List of view options to be merged as properties.
var viewOptions = [
"model",
"collection",
"el",
"id",
"attributes",
"className",
"tagName",
"events",
];
// Set up all inheritable **Backbone.View** properties and methods.
_.extend(View.prototype, Events, {
// The default `tagName` of a View's element is `"div"`.
tagName: "div",
// jQuery delegate for element lookup, scoped to DOM elements within the
// current view. This should be preferred to global lookups where possible.
$: function (selector) {
return this.$el.find(selector);
},
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function () {},
// **render** is the core function that your view should override, in order
// to populate its element (`this.el`), with the appropriate HTML. The
// convention is for **render** to always return `this`.
render: function () {
return this;
},
// Remove this view by taking the element out of the DOM, and removing any
// applicable Backbone.Events listeners.
remove: function () {
this.$el.remove();
this.stopListening();
return this;
},
// Change the view's element (`this.el` property), including event
// re-delegation.
setElement: function (element, delegate) {
if (this.$el) this.undelegateEvents();
this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
this.el = this.$el[0];
if (delegate !== false) this.delegateEvents();
return this;
},
// Set callbacks, where `this.events` is a hash of
//
// *{"event selector": "callback"}*
//
// {
// 'mousedown .title': 'edit',
// 'click .button': 'save',
// 'click .open': function(e) { ... }
// }
//
// pairs. Callbacks will be bound to the view, with `this` set properly.
// Uses event delegation for efficiency.
// Omitting the selector binds the event to `this.el`.
// This only works for delegate-able events: not `focus`, `blur`, and
// not `change`, `submit`, and `reset` in Internet Explorer.
delegateEvents: function (events) {
if (!(events || (events = _.result(this, "events")))) return this;
this.undelegateEvents();
for (var key in events) {
var method = events[key];
if (!_.isFunction(method)) method = this[events[key]];
if (!method) continue;
var match = key.match(delegateEventSplitter);
var eventName = match[1],
selector = match[2];
method = _.bind(method, this);
eventName += ".delegateEvents" + this.cid;
if (selector === "") {
this.$el.on(eventName, method);
} else {
this.$el.on(eventName, selector, method);
}
}
return this;
},
// Clears all callbacks previously bound to the view with `delegateEvents`.
// You usually don't need to use this, but may wish to if you have multiple
// Backbone views attached to the same DOM element.
undelegateEvents: function () {
this.$el.off(".delegateEvents" + this.cid);
return this;
},
// Ensure that the View has a DOM element to render into.
// If `this.el` is a string, pass it through `$()`, take the first
// matching element, and re-assign it to `el`. Otherwise, create
// an element from the `id`, `className` and `tagName` properties.
_ensureElement: function () {
if (!this.el) {
var attrs = _.extend({}, _.result(this, "attributes"));
if (this.id) attrs.id = _.result(this, "id");
if (this.className) attrs["class"] = _.result(this, "className");
var $el = Backbone.$("<" + _.result(this, "tagName") + ">").attr(attrs);
this.setElement($el, false);
} else {
this.setElement(_.result(this, "el"), false);
}
},
});
// Backbone.sync
// -------------
// Override this function to change the manner in which Backbone persists
// models to the server. You will be passed the type of request, and the
// model in question. By default, makes a RESTful Ajax request
// to the model's `url()`. Some possible customizations could be:
//
// * Use `setTimeout` to batch rapid-fire updates into a single request.
// * Send up the models as XML instead of JSON.
// * Persist models via WebSockets instead of Ajax.
//
// Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
// as `POST`, with a `_method` parameter containing the true HTTP method,
// as well as all requests with the body as `application/x-www-form-urlencoded`
// instead of `application/json` with the model in a param named `model`.
// Useful when interfacing with server-side languages like **PHP** that make
// it difficult to read the body of `PUT` requests.
Backbone.sync = function (method, model, options) {
var type = methodMap[method];
// Default options, unless specified.
_.defaults(options || (options = {}), {
emulateHTTP: Backbone.emulateHTTP,
emulateJSON: Backbone.emulateJSON,
});
// Default JSON-request options.
var params = { type: type, dataType: "json" };
// Ensure that we have a URL.
if (!options.url) {
params.url = _.result(model, "url") || urlError();
}
// Ensure that we have the appropriate request data.
if (
options.data == null &&
model &&
(method === "create" || method === "update" || method === "patch")
) {
params.contentType = "application/json";
params.data = JSON.stringify(options.attrs || model.toJSON(options));
}
// For older servers, emulate JSON by encoding the request into an HTML-form.
if (options.emulateJSON) {
params.contentType = "application/x-www-form-urlencoded";
params.data = params.data ? { model: params.data } : {};
}
// For older servers, emulate HTTP by mimicking the HTTP method with `_method`
// And an `X-HTTP-Method-Override` header.
if (
options.emulateHTTP &&
(type === "PUT" || type === "DELETE" || type === "PATCH")
) {
params.type = "POST";
if (options.emulateJSON) params.data._method = type;
var beforeSend = options.beforeSend;
options.beforeSend = function (xhr) {
xhr.setRequestHeader("X-HTTP-Method-Override", type);
if (beforeSend) return beforeSend.apply(this, arguments);
};
}
// Don't process data on a non-GET request.
if (params.type !== "GET" && !options.emulateJSON) {
params.processData = false;
}
// If we're sending a `PATCH` request, and we're in an old Internet Explorer
// that still has ActiveX enabled by default, override jQuery to use that
// for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
if (params.type === "PATCH" && noXhrPatch) {
params.xhr = function () {
return new ActiveXObject("Microsoft.XMLHTTP");
};
}
// Make the request, allowing the user to override any Ajax options.
var xhr = (options.xhr = Backbone.ajax(_.extend(params, options)));
model.trigger("request", model, xhr, options);
return xhr;
};
var noXhrPatch =
typeof window !== "undefined" &&
!!window.ActiveXObject &&
!(window.XMLHttpRequest && new XMLHttpRequest().dispatchEvent);
// Map from CRUD to HTTP for our default `Backbone.sync` implementation.
var methodMap = {
create: "POST",
update: "PUT",
patch: "PATCH",
delete: "DELETE",
read: "GET",
};
// Set the default implementation of `Backbone.ajax` to proxy through to `$`.
// Override this if you'd like to use a different library.
Backbone.ajax = function () {
return Backbone.$.ajax.apply(Backbone.$, arguments);
};
// Backbone.Router
// ---------------
// Routers map faux-URLs to actions, and fire events when routes are
// matched. Creating a new one sets its `routes` hash, if not set statically.
var Router = (Backbone.Router = function (options) {
options || (options = {});
if (options.routes) this.routes = options.routes;
this._bindRoutes();
this.initialize.apply(this, arguments);
});
// Cached regular expressions for matching named param parts and splatted
// parts of route strings.
var optionalParam = /\((.*?)\)/g;
var namedParam = /(\(\?)?:\w+/g;
var splatParam = /\*\w+/g;
var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
// Set up all inheritable **Backbone.Router** properties and methods.
_.extend(Router.prototype, Events, {
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function () {},
// Manually bind a single named route to a callback. For example:
//
// this.route('search/:query/p:num', 'search', function(query, num) {
// ...
// });
//
route: function (route, name, callback) {
if (!_.isRegExp(route)) route = this._routeToRegExp(route);
if (_.isFunction(name)) {
callback = name;
name = "";
}
if (!callback) callback = this[name];
var router = this;
Backbone.history.route(route, function (fragment) {
var args = router._extractParameters(route, fragment);
callback && callback.apply(router, args);
router.trigger.apply(router, ["route:" + name].concat(args));
router.trigger("route", name, args);
Backbone.history.trigger("route", router, name, args);
});
return this;
},
// Simple proxy to `Backbone.history` to save a fragment into the history.
navigate: function (fragment, options) {
Backbone.history.navigate(fragment, options);
return this;
},
// Bind all defined routes to `Backbone.history`. We have to reverse the
// order of the routes here to support behavior where the most general
// routes can be defined at the bottom of the route map.
_bindRoutes: function () {
if (!this.routes) return;
this.routes = _.result(this, "routes");
var route,
routes = _.keys(this.routes);
while ((route = routes.pop()) != null) {
this.route(route, this.routes[route]);
}
},
// Convert a route string into a regular expression, suitable for matching
// against the current location hash.
_routeToRegExp: function (route) {
route = route
.replace(escapeRegExp, "\\$&")
.replace(optionalParam, "(?:$1)?")
.replace(namedParam, function (match, optional) {
return optional ? match : "([^/]+)";
})
.replace(splatParam, "(.*?)");
return new RegExp("^" + route + "$");
},
// Given a route, and a URL fragment that it matches, return the array of
// extracted decoded parameters. Empty or unmatched parameters will be
// treated as `null` to normalize cross-browser behavior.
_extractParameters: function (route, fragment) {
var params = route.exec(fragment).slice(1);
return _.map(params, function (param) {
return param ? decodeURIComponent(param) : null;
});
},
});
// Backbone.History
// ----------------
// Handles cross-browser history management, based on either
// [pushState](http://diveintohtml5.info/history.html) and real URLs, or
// [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
// and URL fragments. If the browser supports neither (old IE, natch),
// falls back to polling.
var History = (Backbone.History = function () {
this.handlers = [];
_.bindAll(this, "checkUrl");
// Ensure that `History` can be used outside of the browser.
if (typeof window !== "undefined") {
this.location = window.location;
this.history = window.history;
}
});
// Cached regex for stripping a leading hash/slash and trailing space.
var routeStripper = /^[#\/]|\s+$/g;
// Cached regex for stripping leading and trailing slashes.
var rootStripper = /^\/+|\/+$/g;
// Cached regex for detecting MSIE.
var isExplorer = /msie [\w.]+/;
// Cached regex for removing a trailing slash.
var trailingSlash = /\/$/;
// Cached regex for stripping urls of hash and query.
var pathStripper = /[?#].*$/;
// Has the history handling already been started?
History.started = false;
// Set up all inheritable **Backbone.History** properties and methods.
_.extend(History.prototype, Events, {
// The default interval to poll for hash changes, if necessary, is
// twenty times a second.
interval: 50,
// Gets the true hash value. Cannot use location.hash directly due to bug
// in Firefox where location.hash will always be decoded.
getHash: function (window) {
var match = (window || this).location.href.match(/#(.*)$/);
return match ? match[1] : "";
},
// Get the cross-browser normalized URL fragment, either from the URL,
// the hash, or the override.
getFragment: function (fragment, forcePushState) {
if (fragment == null) {
if (this._hasPushState || !this._wantsHashChange || forcePushState) {
fragment = this.location.pathname;
var root = this.root.replace(trailingSlash, "");
if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
} else {
fragment = this.getHash();
}
}
return fragment.replace(routeStripper, "");
},
// Start the hash change handling, returning `true` if the current URL matches
// an existing route, and `false` otherwise.
start: function (options) {
if (History.started)
throw new Error("Backbone.history has already been started");
History.started = true;
// Figure out the initial configuration. Do we need an iframe?
// Is pushState desired ... is it available?
this.options = _.extend({ root: "/" }, this.options, options);
this.root = this.options.root;
this._wantsHashChange = this.options.hashChange !== false;
this._wantsPushState = !!this.options.pushState;
this._hasPushState = !!(
this.options.pushState &&
this.history &&
this.history.pushState
);
var fragment = this.getFragment();
var docMode = document.documentMode;
var oldIE =
isExplorer.exec(navigator.userAgent.toLowerCase()) &&
(!docMode || docMode <= 7);
// Normalize root to always include a leading and trailing slash.
this.root = ("/" + this.root + "/").replace(rootStripper, "/");
if (oldIE && this._wantsHashChange) {
this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />')
.hide()
.appendTo("body")[0].contentWindow;
this.navigate(fragment);
}
// Depending on whether we're using pushState or hashes, and whether
// 'onhashchange' is supported, determine how we check the URL state.
if (this._hasPushState) {
Backbone.$(window).on("popstate", this.checkUrl);
} else if (this._wantsHashChange && "onhashchange" in window && !oldIE) {
Backbone.$(window).on("hashchange", this.checkUrl);
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
// Determine if we need to change the base url, for a pushState link
// opened by a non-pushState browser.
this.fragment = fragment;
var loc = this.location;
var atRoot = loc.pathname.replace(/[^\/]$/, "$&/") === this.root;
// Transition from hashChange to pushState or vice versa if both are
// requested.
if (this._wantsHashChange && this._wantsPushState) {
// If we've started off with a route from a `pushState`-enabled
// browser, but we're currently in a browser that doesn't support it...
if (!this._hasPushState && !atRoot) {
this.fragment = this.getFragment(null, true);
this.location.replace(
this.root + this.location.search + "#" + this.fragment,
);
// Return immediately as browser will do redirect to new url
return true;
// Or if we've started out with a hash-based route, but we're currently
// in a browser where it could be `pushState`-based instead...
} else if (this._hasPushState && atRoot && loc.hash) {
this.fragment = this.getHash().replace(routeStripper, "");
this.history.replaceState(
{},
document.title,
this.root + this.fragment + loc.search,
);
}
}
if (!this.options.silent) return this.loadUrl();
},
// Disable Backbone.history, perhaps temporarily. Not useful in a real app,
// but possibly useful for unit testing Routers.
stop: function () {
Backbone.$(window)
.off("popstate", this.checkUrl)
.off("hashchange", this.checkUrl);
clearInterval(this._checkUrlInterval);
History.started = false;
},
// Add a route to be tested when the fragment changes. Routes added later
// may override previous routes.
route: function (route, callback) {
this.handlers.unshift({ route: route, callback: callback });
},
// Checks the current URL to see if it has changed, and if it has,
// calls `loadUrl`, normalizing across the hidden iframe.
checkUrl: function (e) {
var current = this.getFragment();
if (current === this.fragment && this.iframe) {
current = this.getFragment(this.getHash(this.iframe));
}
if (current === this.fragment) return false;
if (this.iframe) this.navigate(current);
this.loadUrl();
},
// Attempt to load the current URL fragment. If a route succeeds with a
// match, returns `true`. If no defined routes matches the fragment,
// returns `false`.
loadUrl: function (fragment) {
fragment = this.fragment = this.getFragment(fragment);
return _.any(this.handlers, function (handler) {
if (handler.route.test(fragment)) {
handler.callback(fragment);
return true;
}
});
},
// Save a fragment into the hash history, or replace the URL state if the
// 'replace' option is passed. You are responsible for properly URL-encoding
// the fragment in advance.
//
// The options object can contain `trigger: true` if you wish to have the
// route callback be fired (not usually desirable), or `replace: true`, if
// you wish to modify the current URL without adding an entry to the history.
navigate: function (fragment, options) {
if (!History.started) return false;
if (!options || options === true) options = { trigger: !!options };
var url = this.root + (fragment = this.getFragment(fragment || ""));
// Strip the fragment of the query and hash for matching.
fragment = fragment.replace(pathStripper, "");
if (this.fragment === fragment) return;
this.fragment = fragment;
// Don't include a trailing slash on the root.
if (fragment === "" && url !== "/") url = url.slice(0, -1);
// If pushState is available, we use it to set the fragment as a real URL.
if (this._hasPushState) {
this.history[options.replace ? "replaceState" : "pushState"](
{},
document.title,
url,
);
// If hash changes haven't been explicitly disabled, update the hash
// fragment to store history.
} else if (this._wantsHashChange) {
this._updateHash(this.location, fragment, options.replace);
if (
this.iframe &&
fragment !== this.getFragment(this.getHash(this.iframe))
) {
// Opening and closing the iframe tricks IE7 and earlier to push a
// history entry on hash-tag change. When replace is true, we don't
// want this.
if (!options.replace) this.iframe.document.open().close();
this._updateHash(this.iframe.location, fragment, options.replace);
}
// If you've told us that you explicitly don't want fallback hashchange-
// based history, then `navigate` becomes a page refresh.
} else {
return this.location.assign(url);
}
if (options.trigger) return this.loadUrl(fragment);
},
// Update the hash location, either replacing the current entry, or adding
// a new one to the browser history.
_updateHash: function (location, fragment, replace) {
if (replace) {
var href = location.href.replace(/(javascript:|#).*$/, "");
location.replace(href + "#" + fragment);
} else {
// Some browsers require that `hash` contains a leading #.
location.hash = "#" + fragment;
}
},
});
// Create the default Backbone.history.
Backbone.history = new History();
// Helpers
// -------
// Helper function to correctly set up the prototype chain, for subclasses.
// Similar to `goog.inherits`, but uses a hash of prototype properties and
// class properties to be extended.
var extend = function (protoProps, staticProps) {
var parent = this;
var child;
// The constructor function for the new subclass is either defined by you
// (the "constructor" property in your `extend` definition), or defaulted
// by us to simply call the parent's constructor.
if (protoProps && _.has(protoProps, "constructor")) {
child = protoProps.constructor;
} else {
child = function () {
return parent.apply(this, arguments);
};
}
// Add static properties to the constructor function, if supplied.
_.extend(child, parent, staticProps);
// Set the prototype chain to inherit from `parent`, without calling
// `parent`'s constructor function.
var Surrogate = function () {
this.constructor = child;
};
Surrogate.prototype = parent.prototype;
child.prototype = new Surrogate();
// Add prototype properties (instance properties) to the subclass,
// if supplied.
if (protoProps) _.extend(child.prototype, protoProps);
// Set a convenience property in case the parent's prototype is needed
// later.
child.__super__ = parent.prototype;
return child;
};
// Set up inheritance for the model, collection, router, view and history.
Model.extend =
Collection.extend =
Router.extend =
View.extend =
History.extend =
extend;
// Throw an error when a URL is needed, and none is supplied.
var urlError = function () {
throw new Error('A "url" property or function must be specified');
};
// Wrap an optional error callback with a fallback error event.
var wrapError = function (model, options) {
var error = options.error;
options.error = function (resp) {
if (error) error(model, resp, options);
model.trigger("error", model, resp, options);
};
};
}.call(this));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/jquery-1.9.1.js | JavaScript | /*!
* jQuery JavaScript Library v1.9.1
* http://jquery.com/
*
* Includes Sizzle.js
* http://sizzlejs.com/
*
* Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2013-2-4
*/
(function (window, undefined) {
// Can't do this because several apps including ASP.NET trace
// the stack via arguments.caller.callee and Firefox dies if
// you try to trace through "use strict" call chains. (#13335)
// Support: Firefox 18+
//"use strict";
var // The deferred used on DOM ready
readyList,
// A central reference to the root jQuery(document)
rootjQuery,
// Support: IE<9
// For `typeof node.method` instead of `node.method !== undefined`
core_strundefined = typeof undefined,
// Use the correct document accordingly with window argument (sandbox)
document = window.document,
location = window.location,
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
// Map over the $ in case of overwrite
_$ = window.$,
// [[Class]] -> type pairs
class2type = {},
// List of deleted data cache ids, so we can reuse them
core_deletedIds = [],
core_version = "1.9.1",
// Save a reference to some core methods
core_concat = core_deletedIds.concat,
core_push = core_deletedIds.push,
core_slice = core_deletedIds.slice,
core_indexOf = core_deletedIds.indexOf,
core_toString = class2type.toString,
core_hasOwn = class2type.hasOwnProperty,
core_trim = core_version.trim,
// Define a local copy of jQuery
jQuery = function (selector, context) {
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init(selector, context, rootjQuery);
},
// Used for matching numbers
core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
// Used for splitting on whitespace
core_rnotwhite = /\S+/g,
// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
// A simple way to check for HTML strings
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
// Strict HTML recognition (#11290: must start with <)
rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
// Match a standalone tag
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
// JSON RegExp
rvalidchars = /^[\],:{}\s]*$/,
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
rvalidtokens =
/"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
// Matches dashed string for camelizing
rmsPrefix = /^-ms-/,
rdashAlpha = /-([\da-z])/gi,
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function (all, letter) {
return letter.toUpperCase();
},
// The ready event handler
completed = function (event) {
// readyState === "complete" is good enough for us to call the dom ready in oldIE
if (
document.addEventListener ||
event.type === "load" ||
document.readyState === "complete"
) {
detach();
jQuery.ready();
}
},
// Clean-up method for dom ready events
detach = function () {
if (document.addEventListener) {
document.removeEventListener("DOMContentLoaded", completed, false);
window.removeEventListener("load", completed, false);
} else {
document.detachEvent("onreadystatechange", completed);
window.detachEvent("onload", completed);
}
};
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
jquery: core_version,
constructor: jQuery,
init: function (selector, context, rootjQuery) {
var match, elem;
// HANDLE: $(""), $(null), $(undefined), $(false)
if (!selector) {
return this;
}
// Handle HTML strings
if (typeof selector === "string") {
if (
selector.charAt(0) === "<" &&
selector.charAt(selector.length - 1) === ">" &&
selector.length >= 3
) {
// Assume that strings that start and end with <> are HTML and skip the regex check
match = [null, selector, null];
} else {
match = rquickExpr.exec(selector);
}
// Match html or make sure no context is specified for #id
if (match && (match[1] || !context)) {
// HANDLE: $(html) -> $(array)
if (match[1]) {
context = context instanceof jQuery ? context[0] : context;
// scripts is true for back-compat
jQuery.merge(
this,
jQuery.parseHTML(
match[1],
context && context.nodeType
? context.ownerDocument || context
: document,
true,
),
);
// HANDLE: $(html, props)
if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
for (match in context) {
// Properties of context are called as methods if possible
if (jQuery.isFunction(this[match])) {
this[match](context[match]);
// ...and otherwise set as attributes
} else {
this.attr(match, context[match]);
}
}
}
return this;
// HANDLE: $(#id)
} else {
elem = document.getElementById(match[2]);
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if (elem && elem.parentNode) {
// Handle the case where IE and Opera return items
// by name instead of ID
if (elem.id !== match[2]) {
return rootjQuery.find(selector);
}
// Otherwise, we inject the element directly into the jQuery object
this.length = 1;
this[0] = elem;
}
this.context = document;
this.selector = selector;
return this;
}
// HANDLE: $(expr, $(...))
} else if (!context || context.jquery) {
return (context || rootjQuery).find(selector);
// HANDLE: $(expr, context)
// (which is just equivalent to: $(context).find(expr)
} else {
return this.constructor(context).find(selector);
}
// HANDLE: $(DOMElement)
} else if (selector.nodeType) {
this.context = this[0] = selector;
this.length = 1;
return this;
// HANDLE: $(function)
// Shortcut for document ready
} else if (jQuery.isFunction(selector)) {
return rootjQuery.ready(selector);
}
if (selector.selector !== undefined) {
this.selector = selector.selector;
this.context = selector.context;
}
return jQuery.makeArray(selector, this);
},
// Start with an empty selector
selector: "",
// The default length of a jQuery object is 0
length: 0,
// The number of elements contained in the matched element set
size: function () {
return this.length;
},
toArray: function () {
return core_slice.call(this);
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function (num) {
return num == null
? // Return a 'clean' array
this.toArray()
: // Return just the object
num < 0
? this[this.length + num]
: this[num];
},
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function (elems) {
// Build a new jQuery matched element set
var ret = jQuery.merge(this.constructor(), elems);
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
// Return the newly-formed element set
return ret;
},
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function (callback, args) {
return jQuery.each(this, callback, args);
},
ready: function (fn) {
// Add the callback
jQuery.ready.promise().done(fn);
return this;
},
slice: function () {
return this.pushStack(core_slice.apply(this, arguments));
},
first: function () {
return this.eq(0);
},
last: function () {
return this.eq(-1);
},
eq: function (i) {
var len = this.length,
j = +i + (i < 0 ? len : 0);
return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
},
map: function (callback) {
return this.pushStack(
jQuery.map(this, function (elem, i) {
return callback.call(elem, i, elem);
}),
);
},
end: function () {
return this.prevObject || this.constructor(null);
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: core_push,
sort: [].sort,
splice: [].splice,
};
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;
jQuery.extend = jQuery.fn.extend = function () {
var src,
copyIsArray,
copy,
name,
options,
clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false;
// Handle a deep copy situation
if (typeof target === "boolean") {
deep = target;
target = arguments[1] || {};
// skip the boolean and the target
i = 2;
}
// Handle case when target is a string or something (possible in deep copy)
if (typeof target !== "object" && !jQuery.isFunction(target)) {
target = {};
}
// extend jQuery itself if only one argument is passed
if (length === i) {
target = this;
--i;
}
for (; i < length; i++) {
// Only deal with non-null/undefined values
if ((options = arguments[i]) != null) {
// Extend the base object
for (name in options) {
src = target[name];
copy = options[name];
// Prevent never-ending loop
if (target === copy) {
continue;
}
// Recurse if we're merging plain objects or arrays
if (
deep &&
copy &&
(jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))
) {
if (copyIsArray) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : [];
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[name] = jQuery.extend(deep, clone, copy);
// Don't bring in undefined values
} else if (copy !== undefined) {
target[name] = copy;
}
}
}
}
// Return the modified object
return target;
};
jQuery.extend({
noConflict: function (deep) {
if (window.$ === jQuery) {
window.$ = _$;
}
if (deep && window.jQuery === jQuery) {
window.jQuery = _jQuery;
}
return jQuery;
},
// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,
// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,
// Hold (or release) the ready event
holdReady: function (hold) {
if (hold) {
jQuery.readyWait++;
} else {
jQuery.ready(true);
}
},
// Handle when the DOM is ready
ready: function (wait) {
// Abort if there are pending holds or we're already ready
if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
return;
}
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
if (!document.body) {
return setTimeout(jQuery.ready);
}
// Remember that the DOM is ready
jQuery.isReady = true;
// If a normal DOM Ready event fired, decrement, and wait if need be
if (wait !== true && --jQuery.readyWait > 0) {
return;
}
// If there are functions bound, to execute
readyList.resolveWith(document, [jQuery]);
// Trigger any bound ready events
if (jQuery.fn.trigger) {
jQuery(document).trigger("ready").off("ready");
}
},
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function (obj) {
return jQuery.type(obj) === "function";
},
isArray:
Array.isArray ||
function (obj) {
return jQuery.type(obj) === "array";
},
isWindow: function (obj) {
return obj != null && obj == obj.window;
},
isNumeric: function (obj) {
return !isNaN(parseFloat(obj)) && isFinite(obj);
},
type: function (obj) {
if (obj == null) {
return String(obj);
}
return typeof obj === "object" || typeof obj === "function"
? class2type[core_toString.call(obj)] || "object"
: typeof obj;
},
isPlainObject: function (obj) {
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if (
!obj ||
jQuery.type(obj) !== "object" ||
obj.nodeType ||
jQuery.isWindow(obj)
) {
return false;
}
try {
// Not own constructor property must be Object
if (
obj.constructor &&
!core_hasOwn.call(obj, "constructor") &&
!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")
) {
return false;
}
} catch (e) {
// IE8,9 Will throw exceptions on certain host objects #9897
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for (key in obj) {
}
return key === undefined || core_hasOwn.call(obj, key);
},
isEmptyObject: function (obj) {
var name;
for (name in obj) {
return false;
}
return true;
},
error: function (msg) {
throw new Error(msg);
},
// data: string of html
// context (optional): If specified, the fragment will be created in this context, defaults to document
// keepScripts (optional): If true, will include scripts passed in the html string
parseHTML: function (data, context, keepScripts) {
if (!data || typeof data !== "string") {
return null;
}
if (typeof context === "boolean") {
keepScripts = context;
context = false;
}
context = context || document;
var parsed = rsingleTag.exec(data),
scripts = !keepScripts && [];
// Single tag
if (parsed) {
return [context.createElement(parsed[1])];
}
parsed = jQuery.buildFragment([data], context, scripts);
if (scripts) {
jQuery(scripts).remove();
}
return jQuery.merge([], parsed.childNodes);
},
parseJSON: function (data) {
// Attempt to parse using the native JSON parser first
if (window.JSON && window.JSON.parse) {
return window.JSON.parse(data);
}
if (data === null) {
return data;
}
if (typeof data === "string") {
// Make sure leading/trailing whitespace is removed (IE can't handle it)
data = jQuery.trim(data);
if (data) {
// Make sure the incoming data is actual JSON
// Logic borrowed from http://json.org/json2.js
if (
rvalidchars.test(
data
.replace(rvalidescape, "@")
.replace(rvalidtokens, "]")
.replace(rvalidbraces, ""),
)
) {
return new Function("return " + data)();
}
}
}
jQuery.error("Invalid JSON: " + data);
},
// Cross-browser xml parsing
parseXML: function (data) {
var xml, tmp;
if (!data || typeof data !== "string") {
return null;
}
try {
if (window.DOMParser) {
// Standard
tmp = new DOMParser();
xml = tmp.parseFromString(data, "text/xml");
} else {
// IE
xml = new ActiveXObject("Microsoft.XMLDOM");
xml.async = "false";
xml.loadXML(data);
}
} catch (e) {
xml = undefined;
}
if (
!xml ||
!xml.documentElement ||
xml.getElementsByTagName("parsererror").length
) {
jQuery.error("Invalid XML: " + data);
}
return xml;
},
noop: function () {},
// Evaluates a script in a global context
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
globalEval: function (data) {
if (data && jQuery.trim(data)) {
// We use execScript on Internet Explorer
// We use an anonymous function so that context is window
// rather than jQuery in Firefox
(
window.execScript ||
function (data) {
window["eval"].call(window, data);
}
)(data);
}
},
// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function (string) {
return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
},
nodeName: function (elem, name) {
return (
elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase()
);
},
// args is for internal usage only
each: function (obj, callback, args) {
var value,
i = 0,
length = obj.length,
isArray = isArraylike(obj);
if (args) {
if (isArray) {
for (; i < length; i++) {
value = callback.apply(obj[i], args);
if (value === false) {
break;
}
}
} else {
for (i in obj) {
value = callback.apply(obj[i], args);
if (value === false) {
break;
}
}
}
// A special, fast, case for the most common use of each
} else {
if (isArray) {
for (; i < length; i++) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
} else {
for (i in obj) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
}
}
return obj;
},
// Use native String.trim function wherever possible
trim:
core_trim && !core_trim.call("\uFEFF\xA0")
? function (text) {
return text == null ? "" : core_trim.call(text);
}
: // Otherwise use our own trimming functionality
function (text) {
return text == null ? "" : (text + "").replace(rtrim, "");
},
// results is for internal usage only
makeArray: function (arr, results) {
var ret = results || [];
if (arr != null) {
if (isArraylike(Object(arr))) {
jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
} else {
core_push.call(ret, arr);
}
}
return ret;
},
inArray: function (elem, arr, i) {
var len;
if (arr) {
if (core_indexOf) {
return core_indexOf.call(arr, elem, i);
}
len = arr.length;
i = i ? (i < 0 ? Math.max(0, len + i) : i) : 0;
for (; i < len; i++) {
// Skip accessing in sparse arrays
if (i in arr && arr[i] === elem) {
return i;
}
}
}
return -1;
},
merge: function (first, second) {
var l = second.length,
i = first.length,
j = 0;
if (typeof l === "number") {
for (; j < l; j++) {
first[i++] = second[j];
}
} else {
while (second[j] !== undefined) {
first[i++] = second[j++];
}
}
first.length = i;
return first;
},
grep: function (elems, callback, inv) {
var retVal,
ret = [],
i = 0,
length = elems.length;
inv = !!inv;
// Go through the array, only saving the items
// that pass the validator function
for (; i < length; i++) {
retVal = !!callback(elems[i], i);
if (inv !== retVal) {
ret.push(elems[i]);
}
}
return ret;
},
// arg is for internal usage only
map: function (elems, callback, arg) {
var value,
i = 0,
length = elems.length,
isArray = isArraylike(elems),
ret = [];
// Go through the array, translating each of the items to their
if (isArray) {
for (; i < length; i++) {
value = callback(elems[i], i, arg);
if (value != null) {
ret[ret.length] = value;
}
}
// Go through every key on the object,
} else {
for (i in elems) {
value = callback(elems[i], i, arg);
if (value != null) {
ret[ret.length] = value;
}
}
}
// Flatten any nested arrays
return core_concat.apply([], ret);
},
// A global GUID counter for objects
guid: 1,
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function (fn, context) {
var args, proxy, tmp;
if (typeof context === "string") {
tmp = fn[context];
context = fn;
fn = tmp;
}
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if (!jQuery.isFunction(fn)) {
return undefined;
}
// Simulated bind
args = core_slice.call(arguments, 2);
proxy = function () {
return fn.apply(
context || this,
args.concat(core_slice.call(arguments)),
);
};
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
return proxy;
},
// Multifunctional method to get and set values of a collection
// The value/s can optionally be executed if it's a function
access: function (elems, fn, key, value, chainable, emptyGet, raw) {
var i = 0,
length = elems.length,
bulk = key == null;
// Sets many values
if (jQuery.type(key) === "object") {
chainable = true;
for (i in key) {
jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);
}
// Sets one value
} else if (value !== undefined) {
chainable = true;
if (!jQuery.isFunction(value)) {
raw = true;
}
if (bulk) {
// Bulk operations run against the entire set
if (raw) {
fn.call(elems, value);
fn = null;
// ...except when executing function values
} else {
bulk = fn;
fn = function (elem, key, value) {
return bulk.call(jQuery(elem), value);
};
}
}
if (fn) {
for (; i < length; i++) {
fn(
elems[i],
key,
raw ? value : value.call(elems[i], i, fn(elems[i], key)),
);
}
}
}
return chainable
? elems
: // Gets
bulk
? fn.call(elems)
: length
? fn(elems[0], key)
: emptyGet;
},
now: function () {
return new Date().getTime();
},
});
jQuery.ready.promise = function (obj) {
if (!readyList) {
readyList = jQuery.Deferred();
// Catch cases where $(document).ready() is called after the browser event has already occurred.
// we once tried to use readyState "interactive" here, but it caused issues like the one
// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
if (document.readyState === "complete") {
// Handle it asynchronously to allow scripts the opportunity to delay ready
setTimeout(jQuery.ready);
// Standards-based browsers support DOMContentLoaded
} else if (document.addEventListener) {
// Use the handy event callback
document.addEventListener("DOMContentLoaded", completed, false);
// A fallback to window.onload, that will always work
window.addEventListener("load", completed, false);
// If IE event model is used
} else {
// Ensure firing before onload, maybe late but safe also for iframes
document.attachEvent("onreadystatechange", completed);
// A fallback to window.onload, that will always work
window.attachEvent("onload", completed);
// If IE and not a frame
// continually check to see if the document is ready
var top = false;
try {
top = window.frameElement == null && document.documentElement;
} catch (e) {}
if (top && top.doScroll) {
(function doScrollCheck() {
if (!jQuery.isReady) {
try {
// Use the trick by Diego Perini
// http://javascript.nwbox.com/IEContentLoaded/
top.doScroll("left");
} catch (e) {
return setTimeout(doScrollCheck, 50);
}
// detach all dom ready events
detach();
// and execute any waiting functions
jQuery.ready();
}
})();
}
}
}
return readyList.promise(obj);
};
// Populate the class2type map
jQuery.each(
"Boolean Number String Function Array Date RegExp Object Error".split(" "),
function (i, name) {
class2type["[object " + name + "]"] = name.toLowerCase();
},
);
function isArraylike(obj) {
var length = obj.length,
type = jQuery.type(obj);
if (jQuery.isWindow(obj)) {
return false;
}
if (obj.nodeType === 1 && length) {
return true;
}
return (
type === "array" ||
(type !== "function" &&
(length === 0 ||
(typeof length === "number" && length > 0 && length - 1 in obj)))
);
}
// All jQuery objects should point back to these
rootjQuery = jQuery(document);
// String to Object options format cache
var optionsCache = {};
// Convert String-formatted options into Object-formatted ones and store in cache
function createOptions(options) {
var object = (optionsCache[options] = {});
jQuery.each(options.match(core_rnotwhite) || [], function (_, flag) {
object[flag] = true;
});
return object;
}
/*
* Create a callback list using the following parameters:
*
* options: an optional list of space-separated options that will change how
* the callback list behaves or a more traditional option object
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible options:
*
* once: will ensure the callback list can only be fired once (like a Deferred)
*
* memory: will keep track of previous values and will call any callback added
* after the list has been fired right away with the latest "memorized"
* values (like a Deferred)
*
* unique: will ensure a callback can only be added once (no duplicate in the list)
*
* stopOnFalse: interrupt callings when a callback returns false
*
*/
jQuery.Callbacks = function (options) {
// Convert options from String-formatted to Object-formatted if needed
// (we check in cache first)
options =
typeof options === "string"
? optionsCache[options] || createOptions(options)
: jQuery.extend({}, options);
var // Flag to know if list is currently firing
firing,
// Last fire value (for non-forgettable lists)
memory,
// Flag to know if list was already fired
fired,
// End of the loop when firing
firingLength,
// Index of currently firing callback (modified by remove if needed)
firingIndex,
// First callback to fire (used internally by add and fireWith)
firingStart,
// Actual callback list
list = [],
// Stack of fire calls for repeatable lists
stack = !options.once && [],
// Fire callbacks
fire = function (data) {
memory = options.memory && data;
fired = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
firing = true;
for (; list && firingIndex < firingLength; firingIndex++) {
if (
list[firingIndex].apply(data[0], data[1]) === false &&
options.stopOnFalse
) {
memory = false; // To prevent further calls using add
break;
}
}
firing = false;
if (list) {
if (stack) {
if (stack.length) {
fire(stack.shift());
}
} else if (memory) {
list = [];
} else {
self.disable();
}
}
},
// Actual Callbacks object
self = {
// Add a callback or a collection of callbacks to the list
add: function () {
if (list) {
// First, we save the current length
var start = list.length;
(function add(args) {
jQuery.each(args, function (_, arg) {
var type = jQuery.type(arg);
if (type === "function") {
if (!options.unique || !self.has(arg)) {
list.push(arg);
}
} else if (arg && arg.length && type !== "string") {
// Inspect recursively
add(arg);
}
});
})(arguments);
// Do we need to add the callbacks to the
// current firing batch?
if (firing) {
firingLength = list.length;
// With memory, if we're not firing then
// we should call right away
} else if (memory) {
firingStart = start;
fire(memory);
}
}
return this;
},
// Remove a callback from the list
remove: function () {
if (list) {
jQuery.each(arguments, function (_, arg) {
var index;
while ((index = jQuery.inArray(arg, list, index)) > -1) {
list.splice(index, 1);
// Handle firing indexes
if (firing) {
if (index <= firingLength) {
firingLength--;
}
if (index <= firingIndex) {
firingIndex--;
}
}
}
});
}
return this;
},
// Check if a given callback is in the list.
// If no argument is given, return whether or not list has callbacks attached.
has: function (fn) {
return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);
},
// Remove all callbacks from the list
empty: function () {
list = [];
return this;
},
// Have the list do nothing anymore
disable: function () {
list = stack = memory = undefined;
return this;
},
// Is it disabled?
disabled: function () {
return !list;
},
// Lock the list in its current state
lock: function () {
stack = undefined;
if (!memory) {
self.disable();
}
return this;
},
// Is it locked?
locked: function () {
return !stack;
},
// Call all callbacks with the given context and arguments
fireWith: function (context, args) {
args = args || [];
args = [context, args.slice ? args.slice() : args];
if (list && (!fired || stack)) {
if (firing) {
stack.push(args);
} else {
fire(args);
}
}
return this;
},
// Call all the callbacks with the given arguments
fire: function () {
self.fireWith(this, arguments);
return this;
},
// To know if the callbacks have already been called at least once
fired: function () {
return !!fired;
},
};
return self;
};
jQuery.extend({
Deferred: function (func) {
var tuples = [
// action, add listener, listener list, final state
["resolve", "done", jQuery.Callbacks("once memory"), "resolved"],
["reject", "fail", jQuery.Callbacks("once memory"), "rejected"],
["notify", "progress", jQuery.Callbacks("memory")],
],
state = "pending",
promise = {
state: function () {
return state;
},
always: function () {
deferred.done(arguments).fail(arguments);
return this;
},
then: function (/* fnDone, fnFail, fnProgress */) {
var fns = arguments;
return jQuery
.Deferred(function (newDefer) {
jQuery.each(tuples, function (i, tuple) {
var action = tuple[0],
fn = jQuery.isFunction(fns[i]) && fns[i];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
deferred[tuple[1]](function () {
var returned = fn && fn.apply(this, arguments);
if (returned && jQuery.isFunction(returned.promise)) {
returned
.promise()
.done(newDefer.resolve)
.fail(newDefer.reject)
.progress(newDefer.notify);
} else {
newDefer[action + "With"](
this === promise ? newDefer.promise() : this,
fn ? [returned] : arguments,
);
}
});
});
fns = null;
})
.promise();
},
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
promise: function (obj) {
return obj != null ? jQuery.extend(obj, promise) : promise;
},
},
deferred = {};
// Keep pipe for back-compat
promise.pipe = promise.then;
// Add list-specific methods
jQuery.each(tuples, function (i, tuple) {
var list = tuple[2],
stateString = tuple[3];
// promise[ done | fail | progress ] = list.add
promise[tuple[1]] = list.add;
// Handle state
if (stateString) {
list.add(
function () {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
},
tuples[i ^ 1][2].disable,
tuples[2][2].lock,
);
}
// deferred[ resolve | reject | notify ]
deferred[tuple[0]] = function () {
deferred[tuple[0] + "With"](
this === deferred ? promise : this,
arguments,
);
return this;
};
deferred[tuple[0] + "With"] = list.fireWith;
});
// Make the deferred a promise
promise.promise(deferred);
// Call given func if any
if (func) {
func.call(deferred, deferred);
}
// All done!
return deferred;
},
// Deferred helper
when: function (subordinate /* , ..., subordinateN */) {
var i = 0,
resolveValues = core_slice.call(arguments),
length = resolveValues.length,
// the count of uncompleted subordinates
remaining =
length !== 1 ||
(subordinate && jQuery.isFunction(subordinate.promise))
? length
: 0,
// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
// Update function for both resolve and progress values
updateFunc = function (i, contexts, values) {
return function (value) {
contexts[i] = this;
values[i] =
arguments.length > 1 ? core_slice.call(arguments) : value;
if (values === progressValues) {
deferred.notifyWith(contexts, values);
} else if (!--remaining) {
deferred.resolveWith(contexts, values);
}
};
},
progressValues,
progressContexts,
resolveContexts;
// add listeners to Deferred subordinates; treat others as resolved
if (length > 1) {
progressValues = new Array(length);
progressContexts = new Array(length);
resolveContexts = new Array(length);
for (; i < length; i++) {
if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
resolveValues[i]
.promise()
.done(updateFunc(i, resolveContexts, resolveValues))
.fail(deferred.reject)
.progress(updateFunc(i, progressContexts, progressValues));
} else {
--remaining;
}
}
}
// if we're not waiting on anything, resolve the master
if (!remaining) {
deferred.resolveWith(resolveContexts, resolveValues);
}
return deferred.promise();
},
});
jQuery.support = (function () {
var support,
all,
a,
input,
select,
fragment,
opt,
eventName,
isSupported,
i,
div = document.createElement("div");
// Setup
div.setAttribute("className", "t");
div.innerHTML =
" <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
// Support tests won't run in some limited or non-browser environments
all = div.getElementsByTagName("*");
a = div.getElementsByTagName("a")[0];
if (!all || !a || !all.length) {
return {};
}
// First batch of tests
select = document.createElement("select");
opt = select.appendChild(document.createElement("option"));
input = div.getElementsByTagName("input")[0];
a.style.cssText = "top:1px;float:left;opacity:.5";
support = {
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
getSetAttribute: div.className !== "t",
// IE strips leading whitespace when .innerHTML is used
leadingWhitespace: div.firstChild.nodeType === 3,
// Make sure that tbody elements aren't automatically inserted
// IE will insert them into empty tables
tbody: !div.getElementsByTagName("tbody").length,
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
htmlSerialize: !!div.getElementsByTagName("link").length,
// Get the style information from getAttribute
// (IE uses .cssText instead)
style: /top/.test(a.getAttribute("style")),
// Make sure that URLs aren't manipulated
// (IE normalizes it by default)
hrefNormalized: a.getAttribute("href") === "/a",
// Make sure that element opacity exists
// (IE uses filter instead)
// Use a regex to work around a WebKit issue. See #5145
opacity: /^0.5/.test(a.style.opacity),
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
cssFloat: !!a.style.cssFloat,
// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
checkOn: !!input.value,
// Make sure that a selected-by-default option has a working selected property.
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
optSelected: opt.selected,
// Tests for enctype support on a form (#6743)
enctype: !!document.createElement("form").enctype,
// Makes sure cloning an html5 element does not cause problems
// Where outerHTML is undefined, this still works
html5Clone:
document.createElement("nav").cloneNode(true).outerHTML !==
"<:nav></:nav>",
// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
boxModel: document.compatMode === "CSS1Compat",
// Will be defined later
deleteExpando: true,
noCloneEvent: true,
inlineBlockNeedsLayout: false,
shrinkWrapBlocks: false,
reliableMarginRight: true,
boxSizingReliable: true,
pixelPosition: false,
};
// Make sure checked status is properly cloned
input.checked = true;
support.noCloneChecked = input.cloneNode(true).checked;
// Make sure that the options inside disabled selects aren't marked as disabled
// (WebKit marks them as disabled)
select.disabled = true;
support.optDisabled = !opt.disabled;
// Support: IE<9
try {
delete div.test;
} catch (e) {
support.deleteExpando = false;
}
// Check if we can trust getAttribute("value")
input = document.createElement("input");
input.setAttribute("value", "");
support.input = input.getAttribute("value") === "";
// Check if an input maintains its value after becoming a radio
input.value = "t";
input.setAttribute("type", "radio");
support.radioValue = input.value === "t";
// #11217 - WebKit loses check when the name is after the checked attribute
input.setAttribute("checked", "t");
input.setAttribute("name", "t");
fragment = document.createDocumentFragment();
fragment.appendChild(input);
// Check if a disconnected checkbox will retain its checked
// value of true after appended to the DOM (IE6/7)
support.appendChecked = input.checked;
// WebKit doesn't clone checked state correctly in fragments
support.checkClone = fragment
.cloneNode(true)
.cloneNode(true).lastChild.checked;
// Support: IE<9
// Opera does not clone events (and typeof div.attachEvent === undefined).
// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
if (div.attachEvent) {
div.attachEvent("onclick", function () {
support.noCloneEvent = false;
});
div.cloneNode(true).click();
}
// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
for (i in { submit: true, change: true, focusin: true }) {
div.setAttribute((eventName = "on" + i), "t");
support[i + "Bubbles"] =
eventName in window || div.attributes[eventName].expando === false;
}
div.style.backgroundClip = "content-box";
div.cloneNode(true).style.backgroundClip = "";
support.clearCloneStyle = div.style.backgroundClip === "content-box";
// Run tests that need a body at doc ready
jQuery(function () {
var container,
marginDiv,
tds,
divReset =
"padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
body = document.getElementsByTagName("body")[0];
if (!body) {
// Return for frameset docs that don't have a body
return;
}
container = document.createElement("div");
container.style.cssText =
"border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
body.appendChild(container).appendChild(div);
// Support: IE8
// Check if table cells still have offsetWidth/Height when they are set
// to display:none and there are still other visible table cells in a
// table row; if so, offsetWidth/Height are not reliable for use when
// determining if an element has been hidden directly using
// display:none (it is still safe to use offsets if a parent element is
// hidden; don safety goggles and see bug #4512 for more information).
div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
tds = div.getElementsByTagName("td");
tds[0].style.cssText = "padding:0;margin:0;border:0;display:none";
isSupported = tds[0].offsetHeight === 0;
tds[0].style.display = "";
tds[1].style.display = "none";
// Support: IE8
// Check if empty table cells still have offsetWidth/Height
support.reliableHiddenOffsets = isSupported && tds[0].offsetHeight === 0;
// Check box-sizing and margin behavior
div.innerHTML = "";
div.style.cssText =
"box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
support.boxSizing = div.offsetWidth === 4;
support.doesNotIncludeMarginInBodyOffset = body.offsetTop !== 1;
// Use window.getComputedStyle because jsdom on node.js will break without it.
if (window.getComputedStyle) {
support.pixelPosition =
(window.getComputedStyle(div, null) || {}).top !== "1%";
support.boxSizingReliable =
(window.getComputedStyle(div, null) || { width: "4px" }).width ===
"4px";
// Check if div with explicit width and no margin-right incorrectly
// gets computed margin-right based on width of container. (#3333)
// Fails in WebKit before Feb 2011 nightlies
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
marginDiv = div.appendChild(document.createElement("div"));
marginDiv.style.cssText = div.style.cssText = divReset;
marginDiv.style.marginRight = marginDiv.style.width = "0";
div.style.width = "1px";
support.reliableMarginRight = !parseFloat(
(window.getComputedStyle(marginDiv, null) || {}).marginRight,
);
}
if (typeof div.style.zoom !== core_strundefined) {
// Support: IE<8
// Check if natively block-level elements act like inline-block
// elements when setting their display to 'inline' and giving
// them layout
div.innerHTML = "";
div.style.cssText =
divReset + "width:1px;padding:1px;display:inline;zoom:1";
support.inlineBlockNeedsLayout = div.offsetWidth === 3;
// Support: IE6
// Check if elements with layout shrink-wrap their children
div.style.display = "block";
div.innerHTML = "<div></div>";
div.firstChild.style.width = "5px";
support.shrinkWrapBlocks = div.offsetWidth !== 3;
if (support.inlineBlockNeedsLayout) {
// Prevent IE 6 from affecting layout for positioned elements #11048
// Prevent IE from shrinking the body in IE 7 mode #12869
// Support: IE<8
body.style.zoom = 1;
}
}
body.removeChild(container);
// Null elements to avoid leaks in IE
container = div = tds = marginDiv = null;
});
// Null elements to avoid leaks in IE
all = select = fragment = opt = a = input = null;
return support;
})();
var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
rmultiDash = /([A-Z])/g;
function internalData(elem, name, data, pvt /* Internal Use Only */) {
if (!jQuery.acceptData(elem)) {
return;
}
var thisCache,
ret,
internalKey = jQuery.expando,
getByName = typeof name === "string",
// We have to handle DOM nodes and JS objects differently because IE6-7
// can't GC object references properly across the DOM-JS boundary
isNode = elem.nodeType,
// Only DOM nodes need the global jQuery cache; JS object data is
// attached directly to the object so GC can occur automatically
cache = isNode ? jQuery.cache : elem,
// Only defining an ID for JS objects if its cache already exists allows
// the code to shortcut on the same path as a DOM node with no cache
id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;
// Avoid doing any more work than we need to when trying to get data on an
// object that has no data at all
if (
(!id || !cache[id] || (!pvt && !cache[id].data)) &&
getByName &&
data === undefined
) {
return;
}
if (!id) {
// Only DOM nodes need a new unique ID for each element since their data
// ends up in the global cache
if (isNode) {
elem[internalKey] = id = core_deletedIds.pop() || jQuery.guid++;
} else {
id = internalKey;
}
}
if (!cache[id]) {
cache[id] = {};
// Avoids exposing jQuery metadata on plain JS objects when the object
// is serialized using JSON.stringify
if (!isNode) {
cache[id].toJSON = jQuery.noop;
}
}
// An object can be passed to jQuery.data instead of a key/value pair; this gets
// shallow copied over onto the existing cache
if (typeof name === "object" || typeof name === "function") {
if (pvt) {
cache[id] = jQuery.extend(cache[id], name);
} else {
cache[id].data = jQuery.extend(cache[id].data, name);
}
}
thisCache = cache[id];
// jQuery data() is stored in a separate object inside the object's internal data
// cache in order to avoid key collisions between internal data and user-defined
// data.
if (!pvt) {
if (!thisCache.data) {
thisCache.data = {};
}
thisCache = thisCache.data;
}
if (data !== undefined) {
thisCache[jQuery.camelCase(name)] = data;
}
// Check for both converted-to-camel and non-converted data property names
// If a data property was specified
if (getByName) {
// First Try to find as-is property data
ret = thisCache[name];
// Test for null|undefined property data
if (ret == null) {
// Try to find the camelCased property
ret = thisCache[jQuery.camelCase(name)];
}
} else {
ret = thisCache;
}
return ret;
}
function internalRemoveData(elem, name, pvt) {
if (!jQuery.acceptData(elem)) {
return;
}
var i,
l,
thisCache,
isNode = elem.nodeType,
// See jQuery.data for more information
cache = isNode ? jQuery.cache : elem,
id = isNode ? elem[jQuery.expando] : jQuery.expando;
// If there is already no cache entry for this object, there is no
// purpose in continuing
if (!cache[id]) {
return;
}
if (name) {
thisCache = pvt ? cache[id] : cache[id].data;
if (thisCache) {
// Support array or space separated string names for data keys
if (!jQuery.isArray(name)) {
// try the string as a key before any manipulation
if (name in thisCache) {
name = [name];
} else {
// split the camel cased version by spaces unless a key with the spaces exists
name = jQuery.camelCase(name);
if (name in thisCache) {
name = [name];
} else {
name = name.split(" ");
}
}
} else {
// If "name" is an array of keys...
// When data is initially created, via ("key", "val") signature,
// keys will be converted to camelCase.
// Since there is no way to tell _how_ a key was added, remove
// both plain key and camelCase key. #12786
// This will only penalize the array argument path.
name = name.concat(jQuery.map(name, jQuery.camelCase));
}
for (i = 0, l = name.length; i < l; i++) {
delete thisCache[name[i]];
}
// If there is no data left in the cache, we want to continue
// and let the cache object itself get destroyed
if (!(pvt ? isEmptyDataObject : jQuery.isEmptyObject)(thisCache)) {
return;
}
}
}
// See jQuery.data for more information
if (!pvt) {
delete cache[id].data;
// Don't destroy the parent cache unless the internal data object
// had been the only thing left in it
if (!isEmptyDataObject(cache[id])) {
return;
}
}
// Destroy the cache
if (isNode) {
jQuery.cleanData([elem], true);
// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
} else if (jQuery.support.deleteExpando || cache != cache.window) {
delete cache[id];
// When all else fails, null
} else {
cache[id] = null;
}
}
jQuery.extend({
cache: {},
// Unique for each copy of jQuery on the page
// Non-digits removed to match rinlinejQuery
expando: "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
noData: {
embed: true,
// Ban all objects except for Flash (which handle expandos)
object: "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
applet: true,
},
hasData: function (elem) {
elem = elem.nodeType
? jQuery.cache[elem[jQuery.expando]]
: elem[jQuery.expando];
return !!elem && !isEmptyDataObject(elem);
},
data: function (elem, name, data) {
return internalData(elem, name, data);
},
removeData: function (elem, name) {
return internalRemoveData(elem, name);
},
// For internal use only.
_data: function (elem, name, data) {
return internalData(elem, name, data, true);
},
_removeData: function (elem, name) {
return internalRemoveData(elem, name, true);
},
// A method for determining if a DOM node can handle the data expando
acceptData: function (elem) {
// Do not set data on non-element because it will not be cleared (#8335).
if (elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9) {
return false;
}
var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];
// nodes accept data unless otherwise specified; rejection can be conditional
return (
!noData || (noData !== true && elem.getAttribute("classid") === noData)
);
},
});
jQuery.fn.extend({
data: function (key, value) {
var attrs,
name,
elem = this[0],
i = 0,
data = null;
// Gets all values
if (key === undefined) {
if (this.length) {
data = jQuery.data(elem);
if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) {
attrs = elem.attributes;
for (; i < attrs.length; i++) {
name = attrs[i].name;
if (!name.indexOf("data-")) {
name = jQuery.camelCase(name.slice(5));
dataAttr(elem, name, data[name]);
}
}
jQuery._data(elem, "parsedAttrs", true);
}
}
return data;
}
// Sets multiple values
if (typeof key === "object") {
return this.each(function () {
jQuery.data(this, key);
});
}
return jQuery.access(
this,
function (value) {
if (value === undefined) {
// Try to fetch any internally stored data first
return elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;
}
this.each(function () {
jQuery.data(this, key, value);
});
},
null,
value,
arguments.length > 1,
null,
true,
);
},
removeData: function (key) {
return this.each(function () {
jQuery.removeData(this, key);
});
},
});
function dataAttr(elem, key, data) {
// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if (data === undefined && elem.nodeType === 1) {
var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
data = elem.getAttribute(name);
if (typeof data === "string") {
try {
data =
data === "true"
? true
: data === "false"
? false
: data === "null"
? null
: // Only convert to a number if it doesn't change the string
+data + "" === data
? +data
: rbrace.test(data)
? jQuery.parseJSON(data)
: data;
} catch (e) {}
// Make sure we set the data so it isn't changed later
jQuery.data(elem, key, data);
} else {
data = undefined;
}
}
return data;
}
// checks a cache object for emptiness
function isEmptyDataObject(obj) {
var name;
for (name in obj) {
// if the public data object is empty, the private is still empty
if (name === "data" && jQuery.isEmptyObject(obj[name])) {
continue;
}
if (name !== "toJSON") {
return false;
}
}
return true;
}
jQuery.extend({
queue: function (elem, type, data) {
var queue;
if (elem) {
type = (type || "fx") + "queue";
queue = jQuery._data(elem, type);
// Speed up dequeue by getting out quickly if this is just a lookup
if (data) {
if (!queue || jQuery.isArray(data)) {
queue = jQuery._data(elem, type, jQuery.makeArray(data));
} else {
queue.push(data);
}
}
return queue || [];
}
},
dequeue: function (elem, type) {
type = type || "fx";
var queue = jQuery.queue(elem, type),
startLength = queue.length,
fn = queue.shift(),
hooks = jQuery._queueHooks(elem, type),
next = function () {
jQuery.dequeue(elem, type);
};
// If the fx queue is dequeued, always remove the progress sentinel
if (fn === "inprogress") {
fn = queue.shift();
startLength--;
}
hooks.cur = fn;
if (fn) {
// Add a progress sentinel to prevent the fx queue from being
// automatically dequeued
if (type === "fx") {
queue.unshift("inprogress");
}
// clear up the last queue stop function
delete hooks.stop;
fn.call(elem, next, hooks);
}
if (!startLength && hooks) {
hooks.empty.fire();
}
},
// not intended for public consumption - generates a queueHooks object, or returns the current one
_queueHooks: function (elem, type) {
var key = type + "queueHooks";
return (
jQuery._data(elem, key) ||
jQuery._data(elem, key, {
empty: jQuery.Callbacks("once memory").add(function () {
jQuery._removeData(elem, type + "queue");
jQuery._removeData(elem, key);
}),
})
);
},
});
jQuery.fn.extend({
queue: function (type, data) {
var setter = 2;
if (typeof type !== "string") {
data = type;
type = "fx";
setter--;
}
if (arguments.length < setter) {
return jQuery.queue(this[0], type);
}
return data === undefined
? this
: this.each(function () {
var queue = jQuery.queue(this, type, data);
// ensure a hooks for this queue
jQuery._queueHooks(this, type);
if (type === "fx" && queue[0] !== "inprogress") {
jQuery.dequeue(this, type);
}
});
},
dequeue: function (type) {
return this.each(function () {
jQuery.dequeue(this, type);
});
},
// Based off of the plugin by Clint Helfers, with permission.
// http://blindsignals.com/index.php/2009/07/jquery-delay/
delay: function (time, type) {
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
type = type || "fx";
return this.queue(type, function (next, hooks) {
var timeout = setTimeout(next, time);
hooks.stop = function () {
clearTimeout(timeout);
};
});
},
clearQueue: function (type) {
return this.queue(type || "fx", []);
},
// Get a promise resolved when queues of a certain type
// are emptied (fx is the type by default)
promise: function (type, obj) {
var tmp,
count = 1,
defer = jQuery.Deferred(),
elements = this,
i = this.length,
resolve = function () {
if (!--count) {
defer.resolveWith(elements, [elements]);
}
};
if (typeof type !== "string") {
obj = type;
type = undefined;
}
type = type || "fx";
while (i--) {
tmp = jQuery._data(elements[i], type + "queueHooks");
if (tmp && tmp.empty) {
count++;
tmp.empty.add(resolve);
}
}
resolve();
return defer.promise(obj);
},
});
var nodeHook,
boolHook,
rclass = /[\t\r\n]/g,
rreturn = /\r/g,
rfocusable = /^(?:input|select|textarea|button|object)$/i,
rclickable = /^(?:a|area)$/i,
rboolean =
/^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
ruseDefault = /^(?:checked|selected)$/i,
getSetAttribute = jQuery.support.getSetAttribute,
getSetInput = jQuery.support.input;
jQuery.fn.extend({
attr: function (name, value) {
return jQuery.access(
this,
jQuery.attr,
name,
value,
arguments.length > 1,
);
},
removeAttr: function (name) {
return this.each(function () {
jQuery.removeAttr(this, name);
});
},
prop: function (name, value) {
return jQuery.access(
this,
jQuery.prop,
name,
value,
arguments.length > 1,
);
},
removeProp: function (name) {
name = jQuery.propFix[name] || name;
return this.each(function () {
// try/catch handles cases where IE balks (such as removing a property on window)
try {
this[name] = undefined;
delete this[name];
} catch (e) {}
});
},
addClass: function (value) {
var classes,
elem,
cur,
clazz,
j,
i = 0,
len = this.length,
proceed = typeof value === "string" && value;
if (jQuery.isFunction(value)) {
return this.each(function (j) {
jQuery(this).addClass(value.call(this, j, this.className));
});
}
if (proceed) {
// The disjunction here is for better compressibility (see removeClass)
classes = (value || "").match(core_rnotwhite) || [];
for (; i < len; i++) {
elem = this[i];
cur =
elem.nodeType === 1 &&
(elem.className
? (" " + elem.className + " ").replace(rclass, " ")
: " ");
if (cur) {
j = 0;
while ((clazz = classes[j++])) {
if (cur.indexOf(" " + clazz + " ") < 0) {
cur += clazz + " ";
}
}
elem.className = jQuery.trim(cur);
}
}
}
return this;
},
removeClass: function (value) {
var classes,
elem,
cur,
clazz,
j,
i = 0,
len = this.length,
proceed =
arguments.length === 0 || (typeof value === "string" && value);
if (jQuery.isFunction(value)) {
return this.each(function (j) {
jQuery(this).removeClass(value.call(this, j, this.className));
});
}
if (proceed) {
classes = (value || "").match(core_rnotwhite) || [];
for (; i < len; i++) {
elem = this[i];
// This expression is here for better compressibility (see addClass)
cur =
elem.nodeType === 1 &&
(elem.className
? (" " + elem.className + " ").replace(rclass, " ")
: "");
if (cur) {
j = 0;
while ((clazz = classes[j++])) {
// Remove *all* instances
while (cur.indexOf(" " + clazz + " ") >= 0) {
cur = cur.replace(" " + clazz + " ", " ");
}
}
elem.className = value ? jQuery.trim(cur) : "";
}
}
}
return this;
},
toggleClass: function (value, stateVal) {
var type = typeof value,
isBool = typeof stateVal === "boolean";
if (jQuery.isFunction(value)) {
return this.each(function (i) {
jQuery(this).toggleClass(
value.call(this, i, this.className, stateVal),
stateVal,
);
});
}
return this.each(function () {
if (type === "string") {
// toggle individual class names
var className,
i = 0,
self = jQuery(this),
state = stateVal,
classNames = value.match(core_rnotwhite) || [];
while ((className = classNames[i++])) {
// check each className given, space separated list
state = isBool ? state : !self.hasClass(className);
self[state ? "addClass" : "removeClass"](className);
}
// Toggle whole class name
} else if (type === core_strundefined || type === "boolean") {
if (this.className) {
// store className if set
jQuery._data(this, "__className__", this.className);
}
// If the element has a class name or if we're passed "false",
// then remove the whole classname (if there was one, the above saved it).
// Otherwise bring back whatever was previously saved (if anything),
// falling back to the empty string if nothing was stored.
this.className =
this.className || value === false
? ""
: jQuery._data(this, "__className__") || "";
}
});
},
hasClass: function (selector) {
var className = " " + selector + " ",
i = 0,
l = this.length;
for (; i < l; i++) {
if (
this[i].nodeType === 1 &&
(" " + this[i].className + " ")
.replace(rclass, " ")
.indexOf(className) >= 0
) {
return true;
}
}
return false;
},
val: function (value) {
var ret,
hooks,
isFunction,
elem = this[0];
if (!arguments.length) {
if (elem) {
hooks =
jQuery.valHooks[elem.type] ||
jQuery.valHooks[elem.nodeName.toLowerCase()];
if (
hooks &&
"get" in hooks &&
(ret = hooks.get(elem, "value")) !== undefined
) {
return ret;
}
ret = elem.value;
return typeof ret === "string"
? // handle most common string cases
ret.replace(rreturn, "")
: // handle cases where value is null/undef or number
ret == null
? ""
: ret;
}
return;
}
isFunction = jQuery.isFunction(value);
return this.each(function (i) {
var val,
self = jQuery(this);
if (this.nodeType !== 1) {
return;
}
if (isFunction) {
val = value.call(this, i, self.val());
} else {
val = value;
}
// Treat null/undefined as ""; convert numbers to string
if (val == null) {
val = "";
} else if (typeof val === "number") {
val += "";
} else if (jQuery.isArray(val)) {
val = jQuery.map(val, function (value) {
return value == null ? "" : value + "";
});
}
hooks =
jQuery.valHooks[this.type] ||
jQuery.valHooks[this.nodeName.toLowerCase()];
// If set returns undefined, fall back to normal setting
if (
!hooks ||
!("set" in hooks) ||
hooks.set(this, val, "value") === undefined
) {
this.value = val;
}
});
},
});
jQuery.extend({
valHooks: {
option: {
get: function (elem) {
// attributes.value is undefined in Blackberry 4.7 but
// uses .value. See #6932
var val = elem.attributes.value;
return !val || val.specified ? elem.value : elem.text;
},
},
select: {
get: function (elem) {
var value,
option,
options = elem.options,
index = elem.selectedIndex,
one = elem.type === "select-one" || index < 0,
values = one ? null : [],
max = one ? index + 1 : options.length,
i = index < 0 ? max : one ? index : 0;
// Loop through all the selected options
for (; i < max; i++) {
option = options[i];
// oldIE doesn't update selected after form reset (#2551)
if (
(option.selected || i === index) &&
// Don't return options that are disabled or in a disabled optgroup
(jQuery.support.optDisabled
? !option.disabled
: option.getAttribute("disabled") === null) &&
(!option.parentNode.disabled ||
!jQuery.nodeName(option.parentNode, "optgroup"))
) {
// Get the specific value for the option
value = jQuery(option).val();
// We don't need an array for one selects
if (one) {
return value;
}
// Multi-Selects return an array
values.push(value);
}
}
return values;
},
set: function (elem, value) {
var values = jQuery.makeArray(value);
jQuery(elem)
.find("option")
.each(function () {
this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;
});
if (!values.length) {
elem.selectedIndex = -1;
}
return values;
},
},
},
attr: function (elem, name, value) {
var hooks,
notxml,
ret,
nType = elem.nodeType;
// don't get/set attributes on text, comment and attribute nodes
if (!elem || nType === 3 || nType === 8 || nType === 2) {
return;
}
// Fallback to prop when attributes are not supported
if (typeof elem.getAttribute === core_strundefined) {
return jQuery.prop(elem, name, value);
}
notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
// All attributes are lowercase
// Grab necessary hook if one is defined
if (notxml) {
name = name.toLowerCase();
hooks =
jQuery.attrHooks[name] || (rboolean.test(name) ? boolHook : nodeHook);
}
if (value !== undefined) {
if (value === null) {
jQuery.removeAttr(elem, name);
} else if (
hooks &&
notxml &&
"set" in hooks &&
(ret = hooks.set(elem, value, name)) !== undefined
) {
return ret;
} else {
elem.setAttribute(name, value + "");
return value;
}
} else if (
hooks &&
notxml &&
"get" in hooks &&
(ret = hooks.get(elem, name)) !== null
) {
return ret;
} else {
// In IE9+, Flash objects don't have .getAttribute (#12945)
// Support: IE9+
if (typeof elem.getAttribute !== core_strundefined) {
ret = elem.getAttribute(name);
}
// Non-existent attributes return null, we normalize to undefined
return ret == null ? undefined : ret;
}
},
removeAttr: function (elem, value) {
var name,
propName,
i = 0,
attrNames = value && value.match(core_rnotwhite);
if (attrNames && elem.nodeType === 1) {
while ((name = attrNames[i++])) {
propName = jQuery.propFix[name] || name;
// Boolean attributes get special treatment (#10870)
if (rboolean.test(name)) {
// Set corresponding property to false for boolean attributes
// Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
if (!getSetAttribute && ruseDefault.test(name)) {
elem[jQuery.camelCase("default-" + name)] = elem[
propName
] = false;
} else {
elem[propName] = false;
}
// See #9699 for explanation of this approach (setting first, then removal)
} else {
jQuery.attr(elem, name, "");
}
elem.removeAttribute(getSetAttribute ? name : propName);
}
}
},
attrHooks: {
type: {
set: function (elem, value) {
if (
!jQuery.support.radioValue &&
value === "radio" &&
jQuery.nodeName(elem, "input")
) {
// Setting the type on a radio button after the value resets the value in IE6-9
// Reset value to default in case type is set after value during creation
var val = elem.value;
elem.setAttribute("type", value);
if (val) {
elem.value = val;
}
return value;
}
},
},
},
propFix: {
tabindex: "tabIndex",
readonly: "readOnly",
for: "htmlFor",
class: "className",
maxlength: "maxLength",
cellspacing: "cellSpacing",
cellpadding: "cellPadding",
rowspan: "rowSpan",
colspan: "colSpan",
usemap: "useMap",
frameborder: "frameBorder",
contenteditable: "contentEditable",
},
prop: function (elem, name, value) {
var ret,
hooks,
notxml,
nType = elem.nodeType;
// don't get/set properties on text, comment and attribute nodes
if (!elem || nType === 3 || nType === 8 || nType === 2) {
return;
}
notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
if (notxml) {
// Fix name and attach hooks
name = jQuery.propFix[name] || name;
hooks = jQuery.propHooks[name];
}
if (value !== undefined) {
if (
hooks &&
"set" in hooks &&
(ret = hooks.set(elem, value, name)) !== undefined
) {
return ret;
} else {
return (elem[name] = value);
}
} else {
if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
return ret;
} else {
return elem[name];
}
}
},
propHooks: {
tabIndex: {
get: function (elem) {
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
var attributeNode = elem.getAttributeNode("tabindex");
return attributeNode && attributeNode.specified
? parseInt(attributeNode.value, 10)
: rfocusable.test(elem.nodeName) ||
(rclickable.test(elem.nodeName) && elem.href)
? 0
: undefined;
},
},
},
});
// Hook for boolean attributes
boolHook = {
get: function (elem, name) {
var // Use .prop to determine if this attribute is understood as boolean
prop = jQuery.prop(elem, name),
// Fetch it accordingly
attr = typeof prop === "boolean" && elem.getAttribute(name),
detail =
typeof prop === "boolean"
? getSetInput && getSetAttribute
? attr != null
: // oldIE fabricates an empty string for missing boolean attributes
// and conflates checked/selected into attroperties
ruseDefault.test(name)
? elem[jQuery.camelCase("default-" + name)]
: !!attr
: // fetch an attribute node for properties not recognized as boolean
elem.getAttributeNode(name);
return detail && detail.value !== false ? name.toLowerCase() : undefined;
},
set: function (elem, value, name) {
if (value === false) {
// Remove boolean attributes when set to false
jQuery.removeAttr(elem, name);
} else if ((getSetInput && getSetAttribute) || !ruseDefault.test(name)) {
// IE<8 needs the *property* name
elem.setAttribute(
(!getSetAttribute && jQuery.propFix[name]) || name,
name,
);
// Use defaultChecked and defaultSelected for oldIE
} else {
elem[jQuery.camelCase("default-" + name)] = elem[name] = true;
}
return name;
},
};
// fix oldIE value attroperty
if (!getSetInput || !getSetAttribute) {
jQuery.attrHooks.value = {
get: function (elem, name) {
var ret = elem.getAttributeNode(name);
return jQuery.nodeName(elem, "input")
? // Ignore the value *property* by using defaultValue
elem.defaultValue
: ret && ret.specified
? ret.value
: undefined;
},
set: function (elem, value, name) {
if (jQuery.nodeName(elem, "input")) {
// Does not return so that setAttribute is also used
elem.defaultValue = value;
} else {
// Use nodeHook if defined (#1954); otherwise setAttribute is fine
return nodeHook && nodeHook.set(elem, value, name);
}
},
};
}
// IE6/7 do not support getting/setting some attributes with get/setAttribute
if (!getSetAttribute) {
// Use this for any attribute in IE6/7
// This fixes almost every IE6/7 issue
nodeHook = jQuery.valHooks.button = {
get: function (elem, name) {
var ret = elem.getAttributeNode(name);
return ret &&
(name === "id" || name === "name" || name === "coords"
? ret.value !== ""
: ret.specified)
? ret.value
: undefined;
},
set: function (elem, value, name) {
// Set the existing or create a new attribute node
var ret = elem.getAttributeNode(name);
if (!ret) {
elem.setAttributeNode(
(ret = elem.ownerDocument.createAttribute(name)),
);
}
ret.value = value += "";
// Break association with cloned elements by also using setAttribute (#9646)
return name === "value" || value === elem.getAttribute(name)
? value
: undefined;
},
};
// Set contenteditable to false on removals(#10429)
// Setting to empty string throws an error as an invalid value
jQuery.attrHooks.contenteditable = {
get: nodeHook.get,
set: function (elem, value, name) {
nodeHook.set(elem, value === "" ? false : value, name);
},
};
// Set width and height to auto instead of 0 on empty string( Bug #8150 )
// This is for removals
jQuery.each(["width", "height"], function (i, name) {
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
set: function (elem, value) {
if (value === "") {
elem.setAttribute(name, "auto");
return value;
}
},
});
});
}
// Some attributes require a special call on IE
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
if (!jQuery.support.hrefNormalized) {
jQuery.each(["href", "src", "width", "height"], function (i, name) {
jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {
get: function (elem) {
var ret = elem.getAttribute(name, 2);
return ret == null ? undefined : ret;
},
});
});
// href/src property should get the full normalized URL (#10299/#12915)
jQuery.each(["href", "src"], function (i, name) {
jQuery.propHooks[name] = {
get: function (elem) {
return elem.getAttribute(name, 4);
},
};
});
}
if (!jQuery.support.style) {
jQuery.attrHooks.style = {
get: function (elem) {
// Return undefined in the case of empty string
// Note: IE uppercases css property names, but if we were to .toLowerCase()
// .cssText, that would destroy case senstitivity in URL's, like in "background"
return elem.style.cssText || undefined;
},
set: function (elem, value) {
return (elem.style.cssText = value + "");
},
};
}
// Safari mis-reports the default selected property of an option
// Accessing the parent's selectedIndex property fixes it
if (!jQuery.support.optSelected) {
jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {
get: function (elem) {
var parent = elem.parentNode;
if (parent) {
parent.selectedIndex;
// Make sure that it also works with optgroups, see #5701
if (parent.parentNode) {
parent.parentNode.selectedIndex;
}
}
return null;
},
});
}
// IE6/7 call enctype encoding
if (!jQuery.support.enctype) {
jQuery.propFix.enctype = "encoding";
}
// Radios and checkboxes getter/setter
if (!jQuery.support.checkOn) {
jQuery.each(["radio", "checkbox"], function () {
jQuery.valHooks[this] = {
get: function (elem) {
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
return elem.getAttribute("value") === null ? "on" : elem.value;
},
};
});
}
jQuery.each(["radio", "checkbox"], function () {
jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {
set: function (elem, value) {
if (jQuery.isArray(value)) {
return (elem.checked =
jQuery.inArray(jQuery(elem).val(), value) >= 0);
}
},
});
});
var rformElems = /^(?:input|select|textarea)$/i,
rkeyEvent = /^key/,
rmouseEvent = /^(?:mouse|contextmenu)|click/,
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
function returnTrue() {
return true;
}
function returnFalse() {
return false;
}
/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
jQuery.event = {
global: {},
add: function (elem, types, handler, data, selector) {
var tmp,
events,
t,
handleObjIn,
special,
eventHandle,
handleObj,
handlers,
type,
namespaces,
origType,
elemData = jQuery._data(elem);
// Don't attach events to noData or text/comment nodes (but allow plain objects)
if (!elemData) {
return;
}
// Caller can pass in an object of custom data in lieu of the handler
if (handler.handler) {
handleObjIn = handler;
handler = handleObjIn.handler;
selector = handleObjIn.selector;
}
// Make sure that the handler has a unique ID, used to find/remove it later
if (!handler.guid) {
handler.guid = jQuery.guid++;
}
// Init the element's event structure and main handler, if this is the first
if (!(events = elemData.events)) {
events = elemData.events = {};
}
if (!(eventHandle = elemData.handle)) {
eventHandle = elemData.handle = function (e) {
// Discard the second event of a jQuery.event.trigger() and
// when an event is called after a page has unloaded
return typeof jQuery !== core_strundefined &&
(!e || jQuery.event.triggered !== e.type)
? jQuery.event.dispatch.apply(eventHandle.elem, arguments)
: undefined;
};
// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
eventHandle.elem = elem;
}
// Handle multiple events separated by a space
// jQuery(...).bind("mouseover mouseout", fn);
types = (types || "").match(core_rnotwhite) || [""];
t = types.length;
while (t--) {
tmp = rtypenamespace.exec(types[t]) || [];
type = origType = tmp[1];
namespaces = (tmp[2] || "").split(".").sort();
// If event changes its type, use the special event handlers for the changed type
special = jQuery.event.special[type] || {};
// If selector defined, determine special event api type, otherwise given type
type = (selector ? special.delegateType : special.bindType) || type;
// Update special based on newly reset type
special = jQuery.event.special[type] || {};
// handleObj is passed to all event handlers
handleObj = jQuery.extend(
{
type: type,
origType: origType,
data: data,
handler: handler,
guid: handler.guid,
selector: selector,
needsContext:
selector && jQuery.expr.match.needsContext.test(selector),
namespace: namespaces.join("."),
},
handleObjIn,
);
// Init the event handler queue if we're the first
if (!(handlers = events[type])) {
handlers = events[type] = [];
handlers.delegateCount = 0;
// Only use addEventListener/attachEvent if the special events handler returns false
if (
!special.setup ||
special.setup.call(elem, data, namespaces, eventHandle) === false
) {
// Bind the global event handler to the element
if (elem.addEventListener) {
elem.addEventListener(type, eventHandle, false);
} else if (elem.attachEvent) {
elem.attachEvent("on" + type, eventHandle);
}
}
}
if (special.add) {
special.add.call(elem, handleObj);
if (!handleObj.handler.guid) {
handleObj.handler.guid = handler.guid;
}
}
// Add to the element's handler list, delegates in front
if (selector) {
handlers.splice(handlers.delegateCount++, 0, handleObj);
} else {
handlers.push(handleObj);
}
// Keep track of which events have ever been used, for event optimization
jQuery.event.global[type] = true;
}
// Nullify elem to prevent memory leaks in IE
elem = null;
},
// Detach an event or set of events from an element
remove: function (elem, types, handler, selector, mappedTypes) {
var j,
handleObj,
tmp,
origCount,
t,
events,
special,
handlers,
type,
namespaces,
origType,
elemData = jQuery.hasData(elem) && jQuery._data(elem);
if (!elemData || !(events = elemData.events)) {
return;
}
// Once for each type.namespace in types; type may be omitted
types = (types || "").match(core_rnotwhite) || [""];
t = types.length;
while (t--) {
tmp = rtypenamespace.exec(types[t]) || [];
type = origType = tmp[1];
namespaces = (tmp[2] || "").split(".").sort();
// Unbind all events (on this namespace, if provided) for the element
if (!type) {
for (type in events) {
jQuery.event.remove(elem, type + types[t], handler, selector, true);
}
continue;
}
special = jQuery.event.special[type] || {};
type = (selector ? special.delegateType : special.bindType) || type;
handlers = events[type] || [];
tmp =
tmp[2] &&
new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
// Remove matching events
origCount = j = handlers.length;
while (j--) {
handleObj = handlers[j];
if (
(mappedTypes || origType === handleObj.origType) &&
(!handler || handler.guid === handleObj.guid) &&
(!tmp || tmp.test(handleObj.namespace)) &&
(!selector ||
selector === handleObj.selector ||
(selector === "**" && handleObj.selector))
) {
handlers.splice(j, 1);
if (handleObj.selector) {
handlers.delegateCount--;
}
if (special.remove) {
special.remove.call(elem, handleObj);
}
}
}
// Remove generic event handler if we removed something and no more handlers exist
// (avoids potential for endless recursion during removal of special event handlers)
if (origCount && !handlers.length) {
if (
!special.teardown ||
special.teardown.call(elem, namespaces, elemData.handle) === false
) {
jQuery.removeEvent(elem, type, elemData.handle);
}
delete events[type];
}
}
// Remove the expando if it's no longer used
if (jQuery.isEmptyObject(events)) {
delete elemData.handle;
// removeData also checks for emptiness and clears the expando if empty
// so use it instead of delete
jQuery._removeData(elem, "events");
}
},
trigger: function (event, data, elem, onlyHandlers) {
var handle,
ontype,
cur,
bubbleType,
special,
tmp,
i,
eventPath = [elem || document],
type = core_hasOwn.call(event, "type") ? event.type : event,
namespaces = core_hasOwn.call(event, "namespace")
? event.namespace.split(".")
: [];
cur = tmp = elem = elem || document;
// Don't do events on text and comment nodes
if (elem.nodeType === 3 || elem.nodeType === 8) {
return;
}
// focus/blur morphs to focusin/out; ensure we're not firing them right now
if (rfocusMorph.test(type + jQuery.event.triggered)) {
return;
}
if (type.indexOf(".") >= 0) {
// Namespaced trigger; create a regexp to match event type in handle()
namespaces = type.split(".");
type = namespaces.shift();
namespaces.sort();
}
ontype = type.indexOf(":") < 0 && "on" + type;
// Caller can pass in a jQuery.Event object, Object, or just an event type string
event = event[jQuery.expando]
? event
: new jQuery.Event(type, typeof event === "object" && event);
event.isTrigger = true;
event.namespace = namespaces.join(".");
event.namespace_re = event.namespace
? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)")
: null;
// Clean up the event in case it is being reused
event.result = undefined;
if (!event.target) {
event.target = elem;
}
// Clone any incoming data and prepend the event, creating the handler arg list
data = data == null ? [event] : jQuery.makeArray(data, [event]);
// Allow special events to draw outside the lines
special = jQuery.event.special[type] || {};
if (
!onlyHandlers &&
special.trigger &&
special.trigger.apply(elem, data) === false
) {
return;
}
// Determine event propagation path in advance, per W3C events spec (#9951)
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
bubbleType = special.delegateType || type;
if (!rfocusMorph.test(bubbleType + type)) {
cur = cur.parentNode;
}
for (; cur; cur = cur.parentNode) {
eventPath.push(cur);
tmp = cur;
}
// Only add window if we got to document (e.g., not plain obj or detached DOM)
if (tmp === (elem.ownerDocument || document)) {
eventPath.push(tmp.defaultView || tmp.parentWindow || window);
}
}
// Fire handlers on the event path
i = 0;
while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
event.type = i > 1 ? bubbleType : special.bindType || type;
// jQuery handler
handle =
(jQuery._data(cur, "events") || {})[event.type] &&
jQuery._data(cur, "handle");
if (handle) {
handle.apply(cur, data);
}
// Native handler
handle = ontype && cur[ontype];
if (
handle &&
jQuery.acceptData(cur) &&
handle.apply &&
handle.apply(cur, data) === false
) {
event.preventDefault();
}
}
event.type = type;
// If nobody prevented the default action, do it now
if (!onlyHandlers && !event.isDefaultPrevented()) {
if (
(!special._default ||
special._default.apply(elem.ownerDocument, data) === false) &&
!(type === "click" && jQuery.nodeName(elem, "a")) &&
jQuery.acceptData(elem)
) {
// Call a native DOM method on the target with the same name name as the event.
// Can't use an .isFunction() check here because IE6/7 fails that test.
// Don't do default actions on window, that's where global variables be (#6170)
if (ontype && elem[type] && !jQuery.isWindow(elem)) {
// Don't re-trigger an onFOO event when we call its FOO() method
tmp = elem[ontype];
if (tmp) {
elem[ontype] = null;
}
// Prevent re-triggering of the same event, since we already bubbled it above
jQuery.event.triggered = type;
try {
elem[type]();
} catch (e) {
// IE<9 dies on focus/blur to hidden element (#1486,#12518)
// only reproducible on winXP IE8 native, not IE9 in IE8 mode
}
jQuery.event.triggered = undefined;
if (tmp) {
elem[ontype] = tmp;
}
}
}
}
return event.result;
},
dispatch: function (event) {
// Make a writable jQuery.Event from the native event object
event = jQuery.event.fix(event);
var i,
ret,
handleObj,
matched,
j,
handlerQueue = [],
args = core_slice.call(arguments),
handlers = (jQuery._data(this, "events") || {})[event.type] || [],
special = jQuery.event.special[event.type] || {};
// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[0] = event;
event.delegateTarget = this;
// Call the preDispatch hook for the mapped type, and let it bail if desired
if (
special.preDispatch &&
special.preDispatch.call(this, event) === false
) {
return;
}
// Determine handlers
handlerQueue = jQuery.event.handlers.call(this, event, handlers);
// Run delegates first; they may want to stop propagation beneath us
i = 0;
while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
event.currentTarget = matched.elem;
j = 0;
while (
(handleObj = matched.handlers[j++]) &&
!event.isImmediatePropagationStopped()
) {
// Triggered event must either 1) have no namespace, or
// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
if (
!event.namespace_re ||
event.namespace_re.test(handleObj.namespace)
) {
event.handleObj = handleObj;
event.data = handleObj.data;
ret = (
(jQuery.event.special[handleObj.origType] || {}).handle ||
handleObj.handler
).apply(matched.elem, args);
if (ret !== undefined) {
if ((event.result = ret) === false) {
event.preventDefault();
event.stopPropagation();
}
}
}
}
}
// Call the postDispatch hook for the mapped type
if (special.postDispatch) {
special.postDispatch.call(this, event);
}
return event.result;
},
handlers: function (event, handlers) {
var sel,
handleObj,
matches,
i,
handlerQueue = [],
delegateCount = handlers.delegateCount,
cur = event.target;
// Find delegate handlers
// Black-hole SVG <use> instance trees (#13180)
// Avoid non-left-click bubbling in Firefox (#3861)
if (
delegateCount &&
cur.nodeType &&
(!event.button || event.type !== "click")
) {
for (; cur != this; cur = cur.parentNode || this) {
// Don't check non-elements (#13208)
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
if (
cur.nodeType === 1 &&
(cur.disabled !== true || event.type !== "click")
) {
matches = [];
for (i = 0; i < delegateCount; i++) {
handleObj = handlers[i];
// Don't conflict with Object.prototype properties (#13203)
sel = handleObj.selector + " ";
if (matches[sel] === undefined) {
matches[sel] = handleObj.needsContext
? jQuery(sel, this).index(cur) >= 0
: jQuery.find(sel, this, null, [cur]).length;
}
if (matches[sel]) {
matches.push(handleObj);
}
}
if (matches.length) {
handlerQueue.push({ elem: cur, handlers: matches });
}
}
}
}
// Add the remaining (directly-bound) handlers
if (delegateCount < handlers.length) {
handlerQueue.push({
elem: this,
handlers: handlers.slice(delegateCount),
});
}
return handlerQueue;
},
fix: function (event) {
if (event[jQuery.expando]) {
return event;
}
// Create a writable copy of the event object and normalize some properties
var i,
prop,
copy,
type = event.type,
originalEvent = event,
fixHook = this.fixHooks[type];
if (!fixHook) {
this.fixHooks[type] = fixHook = rmouseEvent.test(type)
? this.mouseHooks
: rkeyEvent.test(type)
? this.keyHooks
: {};
}
copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
event = new jQuery.Event(originalEvent);
i = copy.length;
while (i--) {
prop = copy[i];
event[prop] = originalEvent[prop];
}
// Support: IE<9
// Fix target property (#1925)
if (!event.target) {
event.target = originalEvent.srcElement || document;
}
// Support: Chrome 23+, Safari?
// Target should not be a text node (#504, #13143)
if (event.target.nodeType === 3) {
event.target = event.target.parentNode;
}
// Support: IE<9
// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
event.metaKey = !!event.metaKey;
return fixHook.filter ? fixHook.filter(event, originalEvent) : event;
},
// Includes some event props shared by KeyEvent and MouseEvent
props:
"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(
" ",
),
fixHooks: {},
keyHooks: {
props: "char charCode key keyCode".split(" "),
filter: function (event, original) {
// Add which for key events
if (event.which == null) {
event.which =
original.charCode != null ? original.charCode : original.keyCode;
}
return event;
},
},
mouseHooks: {
props:
"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(
" ",
),
filter: function (event, original) {
var body,
eventDoc,
doc,
button = original.button,
fromElement = original.fromElement;
// Calculate pageX/Y if missing and clientX/Y available
if (event.pageX == null && original.clientX != null) {
eventDoc = event.target.ownerDocument || document;
doc = eventDoc.documentElement;
body = eventDoc.body;
event.pageX =
original.clientX +
((doc && doc.scrollLeft) || (body && body.scrollLeft) || 0) -
((doc && doc.clientLeft) || (body && body.clientLeft) || 0);
event.pageY =
original.clientY +
((doc && doc.scrollTop) || (body && body.scrollTop) || 0) -
((doc && doc.clientTop) || (body && body.clientTop) || 0);
}
// Add relatedTarget, if necessary
if (!event.relatedTarget && fromElement) {
event.relatedTarget =
fromElement === event.target ? original.toElement : fromElement;
}
// Add which for click: 1 === left; 2 === middle; 3 === right
// Note: button is not normalized, so don't use it
if (!event.which && button !== undefined) {
event.which = button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0;
}
return event;
},
},
special: {
load: {
// Prevent triggered image.load events from bubbling to window.load
noBubble: true,
},
click: {
// For checkbox, fire native event so checked state will be right
trigger: function () {
if (
jQuery.nodeName(this, "input") &&
this.type === "checkbox" &&
this.click
) {
this.click();
return false;
}
},
},
focus: {
// Fire native event if possible so blur/focus sequence is correct
trigger: function () {
if (this !== document.activeElement && this.focus) {
try {
this.focus();
return false;
} catch (e) {
// Support: IE<9
// If we error on focus to hidden element (#1486, #12518),
// let .trigger() run the handlers
}
}
},
delegateType: "focusin",
},
blur: {
trigger: function () {
if (this === document.activeElement && this.blur) {
this.blur();
return false;
}
},
delegateType: "focusout",
},
beforeunload: {
postDispatch: function (event) {
// Even when returnValue equals to undefined Firefox will still show alert
if (event.result !== undefined) {
event.originalEvent.returnValue = event.result;
}
},
},
},
simulate: function (type, elem, event, bubble) {
// Piggyback on a donor event to simulate a different one.
// Fake originalEvent to avoid donor's stopPropagation, but if the
// simulated event prevents default then we do the same on the donor.
var e = jQuery.extend(new jQuery.Event(), event, {
type: type,
isSimulated: true,
originalEvent: {},
});
if (bubble) {
jQuery.event.trigger(e, null, elem);
} else {
jQuery.event.dispatch.call(elem, e);
}
if (e.isDefaultPrevented()) {
event.preventDefault();
}
},
};
jQuery.removeEvent = document.removeEventListener
? function (elem, type, handle) {
if (elem.removeEventListener) {
elem.removeEventListener(type, handle, false);
}
}
: function (elem, type, handle) {
var name = "on" + type;
if (elem.detachEvent) {
// #8545, #7054, preventing memory leaks for custom events in IE6-8
// detachEvent needed property on element, by name of that event, to properly expose it to GC
if (typeof elem[name] === core_strundefined) {
elem[name] = null;
}
elem.detachEvent(name, handle);
}
};
jQuery.Event = function (src, props) {
// Allow instantiation without the 'new' keyword
if (!(this instanceof jQuery.Event)) {
return new jQuery.Event(src, props);
}
// Event object
if (src && src.type) {
this.originalEvent = src;
this.type = src.type;
// Events bubbling up the document may have been marked as prevented
// by a handler lower down the tree; reflect the correct value.
this.isDefaultPrevented =
src.defaultPrevented ||
src.returnValue === false ||
(src.getPreventDefault && src.getPreventDefault())
? returnTrue
: returnFalse;
// Event type
} else {
this.type = src;
}
// Put explicitly provided properties onto the event object
if (props) {
jQuery.extend(this, props);
}
// Create a timestamp if incoming event doesn't have one
this.timeStamp = (src && src.timeStamp) || jQuery.now();
// Mark it as fixed
this[jQuery.expando] = true;
};
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
preventDefault: function () {
var e = this.originalEvent;
this.isDefaultPrevented = returnTrue;
if (!e) {
return;
}
// If preventDefault exists, run it on the original event
if (e.preventDefault) {
e.preventDefault();
// Support: IE
// Otherwise set the returnValue property of the original event to false
} else {
e.returnValue = false;
}
},
stopPropagation: function () {
var e = this.originalEvent;
this.isPropagationStopped = returnTrue;
if (!e) {
return;
}
// If stopPropagation exists, run it on the original event
if (e.stopPropagation) {
e.stopPropagation();
}
// Support: IE
// Set the cancelBubble property of the original event to true
e.cancelBubble = true;
},
stopImmediatePropagation: function () {
this.isImmediatePropagationStopped = returnTrue;
this.stopPropagation();
},
};
// Create mouseenter/leave events using mouseover/out and event-time checks
jQuery.each(
{
mouseenter: "mouseover",
mouseleave: "mouseout",
},
function (orig, fix) {
jQuery.event.special[orig] = {
delegateType: fix,
bindType: fix,
handle: function (event) {
var ret,
target = this,
related = event.relatedTarget,
handleObj = event.handleObj;
// For mousenter/leave call the handler if related is outside the target.
// NB: No relatedTarget if the mouse left/entered the browser window
if (
!related ||
(related !== target && !jQuery.contains(target, related))
) {
event.type = handleObj.origType;
ret = handleObj.handler.apply(this, arguments);
event.type = fix;
}
return ret;
},
};
},
);
// IE submit delegation
if (!jQuery.support.submitBubbles) {
jQuery.event.special.submit = {
setup: function () {
// Only need this for delegated form submit events
if (jQuery.nodeName(this, "form")) {
return false;
}
// Lazy-add a submit handler when a descendant form may potentially be submitted
jQuery.event.add(this, "click._submit keypress._submit", function (e) {
// Node name check avoids a VML-related crash in IE (#9807)
var elem = e.target,
form =
jQuery.nodeName(elem, "input") || jQuery.nodeName(elem, "button")
? elem.form
: undefined;
if (form && !jQuery._data(form, "submitBubbles")) {
jQuery.event.add(form, "submit._submit", function (event) {
event._submit_bubble = true;
});
jQuery._data(form, "submitBubbles", true);
}
});
// return undefined since we don't need an event listener
},
postDispatch: function (event) {
// If form was submitted by the user, bubble the event up the tree
if (event._submit_bubble) {
delete event._submit_bubble;
if (this.parentNode && !event.isTrigger) {
jQuery.event.simulate("submit", this.parentNode, event, true);
}
}
},
teardown: function () {
// Only need this for delegated form submit events
if (jQuery.nodeName(this, "form")) {
return false;
}
// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
jQuery.event.remove(this, "._submit");
},
};
}
// IE change delegation and checkbox/radio fix
if (!jQuery.support.changeBubbles) {
jQuery.event.special.change = {
setup: function () {
if (rformElems.test(this.nodeName)) {
// IE doesn't fire change on a check/radio until blur; trigger it on click
// after a propertychange. Eat the blur-change in special.change.handle.
// This still fires onchange a second time for check/radio after blur.
if (this.type === "checkbox" || this.type === "radio") {
jQuery.event.add(this, "propertychange._change", function (event) {
if (event.originalEvent.propertyName === "checked") {
this._just_changed = true;
}
});
jQuery.event.add(this, "click._change", function (event) {
if (this._just_changed && !event.isTrigger) {
this._just_changed = false;
}
// Allow triggered, simulated change events (#11500)
jQuery.event.simulate("change", this, event, true);
});
}
return false;
}
// Delegated event; lazy-add a change handler on descendant inputs
jQuery.event.add(this, "beforeactivate._change", function (e) {
var elem = e.target;
if (
rformElems.test(elem.nodeName) &&
!jQuery._data(elem, "changeBubbles")
) {
jQuery.event.add(elem, "change._change", function (event) {
if (this.parentNode && !event.isSimulated && !event.isTrigger) {
jQuery.event.simulate("change", this.parentNode, event, true);
}
});
jQuery._data(elem, "changeBubbles", true);
}
});
},
handle: function (event) {
var elem = event.target;
// Swallow native change events from checkbox/radio, we already triggered them above
if (
this !== elem ||
event.isSimulated ||
event.isTrigger ||
(elem.type !== "radio" && elem.type !== "checkbox")
) {
return event.handleObj.handler.apply(this, arguments);
}
},
teardown: function () {
jQuery.event.remove(this, "._change");
return !rformElems.test(this.nodeName);
},
};
}
// Create "bubbling" focus and blur events
if (!jQuery.support.focusinBubbles) {
jQuery.each({ focus: "focusin", blur: "focusout" }, function (orig, fix) {
// Attach a single capturing handler while someone wants focusin/focusout
var attaches = 0,
handler = function (event) {
jQuery.event.simulate(
fix,
event.target,
jQuery.event.fix(event),
true,
);
};
jQuery.event.special[fix] = {
setup: function () {
if (attaches++ === 0) {
document.addEventListener(orig, handler, true);
}
},
teardown: function () {
if (--attaches === 0) {
document.removeEventListener(orig, handler, true);
}
},
};
});
}
jQuery.fn.extend({
on: function (types, selector, data, fn, /*INTERNAL*/ one) {
var type, origFn;
// Types can be a map of types/handlers
if (typeof types === "object") {
// ( types-Object, selector, data )
if (typeof selector !== "string") {
// ( types-Object, data )
data = data || selector;
selector = undefined;
}
for (type in types) {
this.on(type, selector, data, types[type], one);
}
return this;
}
if (data == null && fn == null) {
// ( types, fn )
fn = selector;
data = selector = undefined;
} else if (fn == null) {
if (typeof selector === "string") {
// ( types, selector, fn )
fn = data;
data = undefined;
} else {
// ( types, data, fn )
fn = data;
data = selector;
selector = undefined;
}
}
if (fn === false) {
fn = returnFalse;
} else if (!fn) {
return this;
}
if (one === 1) {
origFn = fn;
fn = function (event) {
// Can use an empty set, since event contains the info
jQuery().off(event);
return origFn.apply(this, arguments);
};
// Use same guid so caller can remove using origFn
fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
}
return this.each(function () {
jQuery.event.add(this, types, fn, data, selector);
});
},
one: function (types, selector, data, fn) {
return this.on(types, selector, data, fn, 1);
},
off: function (types, selector, fn) {
var handleObj, type;
if (types && types.preventDefault && types.handleObj) {
// ( event ) dispatched jQuery.Event
handleObj = types.handleObj;
jQuery(types.delegateTarget).off(
handleObj.namespace
? handleObj.origType + "." + handleObj.namespace
: handleObj.origType,
handleObj.selector,
handleObj.handler,
);
return this;
}
if (typeof types === "object") {
// ( types-object [, selector] )
for (type in types) {
this.off(type, selector, types[type]);
}
return this;
}
if (selector === false || typeof selector === "function") {
// ( types [, fn] )
fn = selector;
selector = undefined;
}
if (fn === false) {
fn = returnFalse;
}
return this.each(function () {
jQuery.event.remove(this, types, fn, selector);
});
},
bind: function (types, data, fn) {
return this.on(types, null, data, fn);
},
unbind: function (types, fn) {
return this.off(types, null, fn);
},
delegate: function (selector, types, data, fn) {
return this.on(types, selector, data, fn);
},
undelegate: function (selector, types, fn) {
// ( namespace ) or ( selector, types [, fn] )
return arguments.length === 1
? this.off(selector, "**")
: this.off(types, selector || "**", fn);
},
trigger: function (type, data) {
return this.each(function () {
jQuery.event.trigger(type, data, this);
});
},
triggerHandler: function (type, data) {
var elem = this[0];
if (elem) {
return jQuery.event.trigger(type, data, elem, true);
}
},
});
/*!
* Sizzle CSS Selector Engine
* Copyright 2012 jQuery Foundation and other contributors
* Released under the MIT license
* http://sizzlejs.com/
*/
(function (window, undefined) {
var i,
cachedruns,
Expr,
getText,
isXML,
compile,
hasDuplicate,
outermostContext,
// Local document vars
setDocument,
document,
docElem,
documentIsXML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
sortOrder,
// Instance-specific data
expando = "sizzle" + -new Date(),
preferredDoc = window.document,
support = {},
dirruns = 0,
done = 0,
classCache = createCache(),
tokenCache = createCache(),
compilerCache = createCache(),
// General-purpose constants
strundefined = typeof undefined,
MAX_NEGATIVE = 1 << 31,
// Array methods
arr = [],
pop = arr.pop,
push = arr.push,
slice = arr.slice,
// Use a stripped-down indexOf if we can't use a native one
indexOf =
arr.indexOf ||
function (elem) {
var i = 0,
len = this.length;
for (; i < len; i++) {
if (this[i] === elem) {
return i;
}
}
return -1;
},
// Regular expressions
// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]",
// http://www.w3.org/TR/css3-syntax/#characters
characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
// Loosely modeled on CSS identifier characters
// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
identifier = characterEncoding.replace("w", "w#"),
// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
operators = "([*^$|!~]?=)",
attributes =
"\\[" +
whitespace +
"*(" +
characterEncoding +
")" +
whitespace +
"*(?:" +
operators +
whitespace +
"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" +
identifier +
")|)|)" +
whitespace +
"*\\]",
// Prefer arguments quoted,
// then not containing pseudos/brackets,
// then attribute selectors/non-parenthetical expressions,
// then anything else
// These preferences are here to reduce the number of selectors
// needing tokenize in the PSEUDO preFilter
pseudos =
":(" +
characterEncoding +
")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" +
attributes.replace(3, 8) +
")*)|.*)\\)|)",
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rtrim = new RegExp(
"^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
"g",
),
rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
rcombinators = new RegExp(
"^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*",
),
rpseudo = new RegExp(pseudos),
ridentifier = new RegExp("^" + identifier + "$"),
matchExpr = {
ID: new RegExp("^#(" + characterEncoding + ")"),
CLASS: new RegExp("^\\.(" + characterEncoding + ")"),
NAME: new RegExp("^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]"),
TAG: new RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
ATTR: new RegExp("^" + attributes),
PSEUDO: new RegExp("^" + pseudos),
CHILD: new RegExp(
"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
whitespace +
"*(even|odd|(([+-]|)(\\d*)n|)" +
whitespace +
"*(?:([+-]|)" +
whitespace +
"*(\\d+)|))" +
whitespace +
"*\\)|)",
"i",
),
// For use in libraries implementing .is()
// We use this for POS matching in `select`
needsContext: new RegExp(
"^" +
whitespace +
"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
whitespace +
"*((?:-\\d)?\\d*)" +
whitespace +
"*\\)|)(?=[^-]|$)",
"i",
),
},
rsibling = /[\x20\t\r\n\f]*[+~]/,
rnative = /^[^{]+\{\s*\[native code/,
// Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
rinputs = /^(?:input|select|textarea|button)$/i,
rheader = /^h\d$/i,
rescape = /'|\\/g,
rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
funescape = function (_, escaped) {
var high = "0x" + escaped - 0x10000;
// NaN means non-codepoint
return high !== high
? escaped
: // BMP codepoint
high < 0
? String.fromCharCode(high + 0x10000)
: // Supplemental Plane codepoint (surrogate pair)
String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
};
// Use a stripped-down slice if we can't use a native one
try {
slice.call(preferredDoc.documentElement.childNodes, 0)[0].nodeType;
} catch (e) {
slice = function (i) {
var elem,
results = [];
while ((elem = this[i++])) {
results.push(elem);
}
return results;
};
}
/**
* For feature detection
* @param {Function} fn The function to test for native support
*/
function isNative(fn) {
return rnative.test(fn + "");
}
/**
* Create key-value caches of limited size
* @returns {Function(string, Object)} Returns the Object data after storing it on itself with
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
* deleting the oldest entry
*/
function createCache() {
var cache,
keys = [];
return (cache = function (key, value) {
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
if (keys.push((key += " ")) > Expr.cacheLength) {
// Only keep the most recent entries
delete cache[keys.shift()];
}
return (cache[key] = value);
});
}
/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
function markFunction(fn) {
fn[expando] = true;
return fn;
}
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/
function assert(fn) {
var div = document.createElement("div");
try {
return fn(div);
} catch (e) {
return false;
} finally {
// release memory in IE
div = null;
}
}
function Sizzle(selector, context, results, seed) {
var match,
elem,
m,
nodeType,
// QSA vars
i,
groups,
old,
nid,
newContext,
newSelector;
if (
(context ? context.ownerDocument || context : preferredDoc) !== document
) {
setDocument(context);
}
context = context || document;
results = results || [];
if (!selector || typeof selector !== "string") {
return results;
}
if ((nodeType = context.nodeType) !== 1 && nodeType !== 9) {
return [];
}
if (!documentIsXML && !seed) {
// Shortcuts
if ((match = rquickExpr.exec(selector))) {
// Speed-up: Sizzle("#ID")
if ((m = match[1])) {
if (nodeType === 9) {
elem = context.getElementById(m);
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if (elem && elem.parentNode) {
// Handle the case where IE, Opera, and Webkit return items
// by name instead of ID
if (elem.id === m) {
results.push(elem);
return results;
}
} else {
return results;
}
} else {
// Context is not a document
if (
context.ownerDocument &&
(elem = context.ownerDocument.getElementById(m)) &&
contains(context, elem) &&
elem.id === m
) {
results.push(elem);
return results;
}
}
// Speed-up: Sizzle("TAG")
} else if (match[2]) {
push.apply(
results,
slice.call(context.getElementsByTagName(selector), 0),
);
return results;
// Speed-up: Sizzle(".CLASS")
} else if (
(m = match[3]) &&
support.getByClassName &&
context.getElementsByClassName
) {
push.apply(
results,
slice.call(context.getElementsByClassName(m), 0),
);
return results;
}
}
// QSA path
if (support.qsa && !rbuggyQSA.test(selector)) {
old = true;
nid = expando;
newContext = context;
newSelector = nodeType === 9 && selector;
// qSA works strangely on Element-rooted queries
// We can work around this by specifying an extra ID on the root
// and working up from there (Thanks to Andrew Dupont for the technique)
// IE 8 doesn't work on object elements
if (nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
groups = tokenize(selector);
if ((old = context.getAttribute("id"))) {
nid = old.replace(rescape, "\\$&");
} else {
context.setAttribute("id", nid);
}
nid = "[id='" + nid + "'] ";
i = groups.length;
while (i--) {
groups[i] = nid + toSelector(groups[i]);
}
newContext =
(rsibling.test(selector) && context.parentNode) || context;
newSelector = groups.join(",");
}
if (newSelector) {
try {
push.apply(
results,
slice.call(newContext.querySelectorAll(newSelector), 0),
);
return results;
} catch (qsaError) {
} finally {
if (!old) {
context.removeAttribute("id");
}
}
}
}
}
// All others
return select(selector.replace(rtrim, "$1"), context, results, seed);
}
/**
* Detect xml
* @param {Element|Object} elem An element or a document
*/
isXML = Sizzle.isXML = function (elem) {
// documentElement is verified for cases where it doesn't yet exist
// (such as loading iframes in IE - #4833)
var documentElement =
elem && (elem.ownerDocument || elem).documentElement;
return documentElement ? documentElement.nodeName !== "HTML" : false;
};
/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
setDocument = Sizzle.setDocument = function (node) {
var doc = node ? node.ownerDocument || node : preferredDoc;
// If no document and documentElement is available, return
if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
return document;
}
// Set our document
document = doc;
docElem = doc.documentElement;
// Support tests
documentIsXML = isXML(doc);
// Check if getElementsByTagName("*") returns only elements
support.tagNameNoComments = assert(function (div) {
div.appendChild(doc.createComment(""));
return !div.getElementsByTagName("*").length;
});
// Check if attributes should be retrieved by attribute nodes
support.attributes = assert(function (div) {
div.innerHTML = "<select></select>";
var type = typeof div.lastChild.getAttribute("multiple");
// IE8 returns a string for some attributes even when not present
return type !== "boolean" && type !== "string";
});
// Check if getElementsByClassName can be trusted
support.getByClassName = assert(function (div) {
// Opera can't find a second classname (in 9.6)
div.innerHTML =
"<div class='hidden e'></div><div class='hidden'></div>";
if (
!div.getElementsByClassName ||
!div.getElementsByClassName("e").length
) {
return false;
}
// Safari 3.2 caches class attributes and doesn't catch changes
div.lastChild.className = "e";
return div.getElementsByClassName("e").length === 2;
});
// Check if getElementById returns elements by name
// Check if getElementsByName privileges form controls or returns elements by ID
support.getByName = assert(function (div) {
// Inject content
div.id = expando + 0;
div.innerHTML =
"<a name='" + expando + "'></a><div name='" + expando + "'></div>";
docElem.insertBefore(div, docElem.firstChild);
// Test
var pass =
doc.getElementsByName &&
// buggy browsers will return fewer than the correct 2
doc.getElementsByName(expando).length ===
2 +
// buggy browsers will return more than the correct 0
doc.getElementsByName(expando + 0).length;
support.getIdNotName = !doc.getElementById(expando);
// Cleanup
docElem.removeChild(div);
return pass;
});
// IE6/7 return modified attributes
Expr.attrHandle = assert(function (div) {
div.innerHTML = "<a href='#'></a>";
return (
div.firstChild &&
typeof div.firstChild.getAttribute !== strundefined &&
div.firstChild.getAttribute("href") === "#"
);
})
? {}
: {
href: function (elem) {
return elem.getAttribute("href", 2);
},
type: function (elem) {
return elem.getAttribute("type");
},
};
// ID find and filter
if (support.getIdNotName) {
Expr.find["ID"] = function (id, context) {
if (
typeof context.getElementById !== strundefined &&
!documentIsXML
) {
var m = context.getElementById(id);
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
return m && m.parentNode ? [m] : [];
}
};
Expr.filter["ID"] = function (id) {
var attrId = id.replace(runescape, funescape);
return function (elem) {
return elem.getAttribute("id") === attrId;
};
};
} else {
Expr.find["ID"] = function (id, context) {
if (
typeof context.getElementById !== strundefined &&
!documentIsXML
) {
var m = context.getElementById(id);
return m
? m.id === id ||
(typeof m.getAttributeNode !== strundefined &&
m.getAttributeNode("id").value === id)
? [m]
: undefined
: [];
}
};
Expr.filter["ID"] = function (id) {
var attrId = id.replace(runescape, funescape);
return function (elem) {
var node =
typeof elem.getAttributeNode !== strundefined &&
elem.getAttributeNode("id");
return node && node.value === attrId;
};
};
}
// Tag
Expr.find["TAG"] = support.tagNameNoComments
? function (tag, context) {
if (typeof context.getElementsByTagName !== strundefined) {
return context.getElementsByTagName(tag);
}
}
: function (tag, context) {
var elem,
tmp = [],
i = 0,
results = context.getElementsByTagName(tag);
// Filter out possible comments
if (tag === "*") {
while ((elem = results[i++])) {
if (elem.nodeType === 1) {
tmp.push(elem);
}
}
return tmp;
}
return results;
};
// Name
Expr.find["NAME"] =
support.getByName &&
function (tag, context) {
if (typeof context.getElementsByName !== strundefined) {
return context.getElementsByName(name);
}
};
// Class
Expr.find["CLASS"] =
support.getByClassName &&
function (className, context) {
if (
typeof context.getElementsByClassName !== strundefined &&
!documentIsXML
) {
return context.getElementsByClassName(className);
}
};
// QSA and matchesSelector support
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
// qSa(:focus) reports false when true (Chrome 21),
// no need to also add to buggyMatches since matches checks buggyQSA
// A support test would require too much code (would include document ready)
rbuggyQSA = [":focus"];
if ((support.qsa = isNative(doc.querySelectorAll))) {
// Build QSA regex
// Regex strategy adopted from Diego Perini
assert(function (div) {
// Select is set to empty string on purpose
// This is to test IE's treatment of not explictly
// setting a boolean content attribute,
// since its presence should be enough
// http://bugs.jquery.com/ticket/12359
div.innerHTML = "<select><option selected=''></option></select>";
// IE8 - Some boolean attributes are not treated correctly
if (!div.querySelectorAll("[selected]").length) {
rbuggyQSA.push(
"\\[" +
whitespace +
"*(?:checked|disabled|ismap|multiple|readonly|selected|value)",
);
}
// Webkit/Opera - :checked should return selected option elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
// IE8 throws error here and will not see later tests
if (!div.querySelectorAll(":checked").length) {
rbuggyQSA.push(":checked");
}
});
assert(function (div) {
// Opera 10-12/IE8 - ^= $= *= and empty values
// Should not select anything
div.innerHTML = "<input type='hidden' i=''/>";
if (div.querySelectorAll("[i^='']").length) {
rbuggyQSA.push("[*^$]=" + whitespace + "*(?:\"\"|'')");
}
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
// IE8 throws error here and will not see later tests
if (!div.querySelectorAll(":enabled").length) {
rbuggyQSA.push(":enabled", ":disabled");
}
// Opera 10-11 does not throw on post-comma invalid pseudos
div.querySelectorAll("*,:x");
rbuggyQSA.push(",.*:");
});
}
if (
(support.matchesSelector = isNative(
(matches =
docElem.matchesSelector ||
docElem.mozMatchesSelector ||
docElem.webkitMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector),
))
) {
assert(function (div) {
// Check to see if it's possible to do matchesSelector
// on a disconnected node (IE 9)
support.disconnectedMatch = matches.call(div, "div");
// This should fail with an exception
// Gecko does not error, returns false instead
matches.call(div, "[s!='']:x");
rbuggyMatches.push("!=", pseudos);
});
}
rbuggyQSA = new RegExp(rbuggyQSA.join("|"));
rbuggyMatches = new RegExp(rbuggyMatches.join("|"));
// Element contains another
// Purposefully does not implement inclusive descendent
// As in, an element does not contain itself
contains =
isNative(docElem.contains) || docElem.compareDocumentPosition
? function (a, b) {
var adown = a.nodeType === 9 ? a.documentElement : a,
bup = b && b.parentNode;
return (
a === bup ||
!!(
bup &&
bup.nodeType === 1 &&
(adown.contains
? adown.contains(bup)
: a.compareDocumentPosition &&
a.compareDocumentPosition(bup) & 16)
)
);
}
: function (a, b) {
if (b) {
while ((b = b.parentNode)) {
if (b === a) {
return true;
}
}
}
return false;
};
// Document order sorting
sortOrder = docElem.compareDocumentPosition
? function (a, b) {
var compare;
if (a === b) {
hasDuplicate = true;
return 0;
}
if (
(compare =
b.compareDocumentPosition &&
a.compareDocumentPosition &&
a.compareDocumentPosition(b))
) {
if (
compare & 1 ||
(a.parentNode && a.parentNode.nodeType === 11)
) {
if (a === doc || contains(preferredDoc, a)) {
return -1;
}
if (b === doc || contains(preferredDoc, b)) {
return 1;
}
return 0;
}
return compare & 4 ? -1 : 1;
}
return a.compareDocumentPosition ? -1 : 1;
}
: function (a, b) {
var cur,
i = 0,
aup = a.parentNode,
bup = b.parentNode,
ap = [a],
bp = [b];
// Exit early if the nodes are identical
if (a === b) {
hasDuplicate = true;
return 0;
// Parentless nodes are either documents or disconnected
} else if (!aup || !bup) {
return a === doc ? -1 : b === doc ? 1 : aup ? -1 : bup ? 1 : 0;
// If the nodes are siblings, we can do a quick check
} else if (aup === bup) {
return siblingCheck(a, b);
}
// Otherwise we need full lists of their ancestors for comparison
cur = a;
while ((cur = cur.parentNode)) {
ap.unshift(cur);
}
cur = b;
while ((cur = cur.parentNode)) {
bp.unshift(cur);
}
// Walk down the tree looking for a discrepancy
while (ap[i] === bp[i]) {
i++;
}
return i
? // Do a sibling check if the nodes have a common ancestor
siblingCheck(ap[i], bp[i])
: // Otherwise nodes in our document sort first
ap[i] === preferredDoc
? -1
: bp[i] === preferredDoc
? 1
: 0;
};
// Always assume the presence of duplicates if sort doesn't
// pass them to our comparison function (as in Google Chrome).
hasDuplicate = false;
[0, 0].sort(sortOrder);
support.detectDuplicates = hasDuplicate;
return document;
};
Sizzle.matches = function (expr, elements) {
return Sizzle(expr, null, null, elements);
};
Sizzle.matchesSelector = function (elem, expr) {
// Set document vars if needed
if ((elem.ownerDocument || elem) !== document) {
setDocument(elem);
}
// Make sure that attribute selectors are quoted
expr = expr.replace(rattributeQuotes, "='$1']");
// rbuggyQSA always contains :focus, so no need for an existence check
if (
support.matchesSelector &&
!documentIsXML &&
(!rbuggyMatches || !rbuggyMatches.test(expr)) &&
!rbuggyQSA.test(expr)
) {
try {
var ret = matches.call(elem, expr);
// IE 9's matchesSelector returns false on disconnected nodes
if (
ret ||
support.disconnectedMatch ||
// As well, disconnected nodes are said to be in a document
// fragment in IE 9
(elem.document && elem.document.nodeType !== 11)
) {
return ret;
}
} catch (e) {}
}
return Sizzle(expr, document, null, [elem]).length > 0;
};
Sizzle.contains = function (context, elem) {
// Set document vars if needed
if ((context.ownerDocument || context) !== document) {
setDocument(context);
}
return contains(context, elem);
};
Sizzle.attr = function (elem, name) {
var val;
// Set document vars if needed
if ((elem.ownerDocument || elem) !== document) {
setDocument(elem);
}
if (!documentIsXML) {
name = name.toLowerCase();
}
if ((val = Expr.attrHandle[name])) {
return val(elem);
}
if (documentIsXML || support.attributes) {
return elem.getAttribute(name);
}
return ((val = elem.getAttributeNode(name)) || elem.getAttribute(name)) &&
elem[name] === true
? name
: val && val.specified
? val.value
: null;
};
Sizzle.error = function (msg) {
throw new Error("Syntax error, unrecognized expression: " + msg);
};
// Document sorting and removing duplicates
Sizzle.uniqueSort = function (results) {
var elem,
duplicates = [],
i = 1,
j = 0;
// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates;
results.sort(sortOrder);
if (hasDuplicate) {
for (; (elem = results[i]); i++) {
if (elem === results[i - 1]) {
j = duplicates.push(i);
}
}
while (j--) {
results.splice(duplicates[j], 1);
}
}
return results;
};
function siblingCheck(a, b) {
var cur = b && a,
diff =
cur &&
(~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
// Use IE sourceIndex if available on both nodes
if (diff) {
return diff;
}
// Check if b follows a
if (cur) {
while ((cur = cur.nextSibling)) {
if (cur === b) {
return -1;
}
}
}
return a ? 1 : -1;
}
// Returns a function to use in pseudos for input types
function createInputPseudo(type) {
return function (elem) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === type;
};
}
// Returns a function to use in pseudos for buttons
function createButtonPseudo(type) {
return function (elem) {
var name = elem.nodeName.toLowerCase();
return (name === "input" || name === "button") && elem.type === type;
};
}
// Returns a function to use in pseudos for positionals
function createPositionalPseudo(fn) {
return markFunction(function (argument) {
argument = +argument;
return markFunction(function (seed, matches) {
var j,
matchIndexes = fn([], seed.length, argument),
i = matchIndexes.length;
// Match elements found at the specified indexes
while (i--) {
if (seed[(j = matchIndexes[i])]) {
seed[j] = !(matches[j] = seed[j]);
}
}
});
});
}
/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
getText = Sizzle.getText = function (elem) {
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
if (!nodeType) {
// If no nodeType, this is expected to be an array
for (; (node = elem[i]); i++) {
// Do not traverse comment nodes
ret += getText(node);
}
} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
// Use textContent for elements
// innerText usage removed for consistency of new lines (see #11153)
if (typeof elem.textContent === "string") {
return elem.textContent;
} else {
// Traverse its children
for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
ret += getText(elem);
}
}
} else if (nodeType === 3 || nodeType === 4) {
return elem.nodeValue;
}
// Do not include comment or processing instruction nodes
return ret;
};
Expr = Sizzle.selectors = {
// Can be adjusted by the user
cacheLength: 50,
createPseudo: markFunction,
match: matchExpr,
find: {},
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" },
},
preFilter: {
ATTR: function (match) {
match[1] = match[1].replace(runescape, funescape);
// Move the given value to match[3] whether quoted or unquoted
match[3] = (match[4] || match[5] || "").replace(runescape, funescape);
if (match[2] === "~=") {
match[3] = " " + match[3] + " ";
}
return match.slice(0, 4);
},
CHILD: function (match) {
/* matches from matchExpr["CHILD"]
1 type (only|nth|...)
2 what (child|of-type)
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4 xn-component of xn+y argument ([+-]?\d*n|)
5 sign of xn-component
6 x of xn-component
7 sign of y-component
8 y of y-component
*/
match[1] = match[1].toLowerCase();
if (match[1].slice(0, 3) === "nth") {
// nth-* requires argument
if (!match[3]) {
Sizzle.error(match[0]);
}
// numeric x and y parameters for Expr.filter.CHILD
// remember that false/true cast respectively to 0/1
match[4] = +(match[4]
? match[5] + (match[6] || 1)
: 2 * (match[3] === "even" || match[3] === "odd"));
match[5] = +(match[7] + match[8] || match[3] === "odd");
// other types prohibit arguments
} else if (match[3]) {
Sizzle.error(match[0]);
}
return match;
},
PSEUDO: function (match) {
var excess,
unquoted = !match[5] && match[2];
if (matchExpr["CHILD"].test(match[0])) {
return null;
}
// Accept quoted arguments as-is
if (match[4]) {
match[2] = match[4];
// Strip excess characters from unquoted arguments
} else if (
unquoted &&
rpseudo.test(unquoted) &&
// Get excess from tokenize (recursively)
(excess = tokenize(unquoted, true)) &&
// advance to the next closing parenthesis
(excess =
unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)
) {
// excess is a negative index
match[0] = match[0].slice(0, excess);
match[2] = unquoted.slice(0, excess);
}
// Return only captures needed by the pseudo filter method (type and argument)
return match.slice(0, 3);
},
},
filter: {
TAG: function (nodeName) {
if (nodeName === "*") {
return function () {
return true;
};
}
nodeName = nodeName.replace(runescape, funescape).toLowerCase();
return function (elem) {
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
};
},
CLASS: function (className) {
var pattern = classCache[className + " "];
return (
pattern ||
((pattern = new RegExp(
"(^|" + whitespace + ")" + className + "(" + whitespace + "|$)",
)) &&
classCache(className, function (elem) {
return pattern.test(
elem.className ||
(typeof elem.getAttribute !== strundefined &&
elem.getAttribute("class")) ||
"",
);
}))
);
},
ATTR: function (name, operator, check) {
return function (elem) {
var result = Sizzle.attr(elem, name);
if (result == null) {
return operator === "!=";
}
if (!operator) {
return true;
}
result += "";
return operator === "="
? result === check
: operator === "!="
? result !== check
: operator === "^="
? check && result.indexOf(check) === 0
: operator === "*="
? check && result.indexOf(check) > -1
: operator === "$="
? check && result.slice(-check.length) === check
: operator === "~="
? (" " + result + " ").indexOf(check) > -1
: operator === "|="
? result === check ||
result.slice(0, check.length + 1) === check + "-"
: false;
};
},
CHILD: function (type, what, argument, first, last) {
var simple = type.slice(0, 3) !== "nth",
forward = type.slice(-4) !== "last",
ofType = what === "of-type";
return first === 1 && last === 0
? // Shortcut for :nth-*(n)
function (elem) {
return !!elem.parentNode;
}
: function (elem, context, xml) {
var cache,
outerCache,
node,
diff,
nodeIndex,
start,
dir = simple !== forward ? "nextSibling" : "previousSibling",
parent = elem.parentNode,
name = ofType && elem.nodeName.toLowerCase(),
useCache = !xml && !ofType;
if (parent) {
// :(first|last|only)-(child|of-type)
if (simple) {
while (dir) {
node = elem;
while ((node = node[dir])) {
if (
ofType
? node.nodeName.toLowerCase() === name
: node.nodeType === 1
) {
return false;
}
}
// Reverse direction for :only-* (if we haven't yet done so)
start = dir = type === "only" && !start && "nextSibling";
}
return true;
}
start = [forward ? parent.firstChild : parent.lastChild];
// non-xml :nth-child(...) stores cache data on `parent`
if (forward && useCache) {
// Seek `elem` from a previously-cached index
outerCache = parent[expando] || (parent[expando] = {});
cache = outerCache[type] || [];
nodeIndex = cache[0] === dirruns && cache[1];
diff = cache[0] === dirruns && cache[2];
node = nodeIndex && parent.childNodes[nodeIndex];
while (
(node =
(++nodeIndex && node && node[dir]) ||
// Fallback to seeking `elem` from the start
(diff = nodeIndex = 0) ||
start.pop())
) {
// When found, cache indexes on `parent` and break
if (node.nodeType === 1 && ++diff && node === elem) {
outerCache[type] = [dirruns, nodeIndex, diff];
break;
}
}
// Use previously-cached element index if available
} else if (
useCache &&
(cache = (elem[expando] || (elem[expando] = {}))[type]) &&
cache[0] === dirruns
) {
diff = cache[1];
// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
} else {
// Use the same loop as above to seek `elem` from the start
while (
(node =
(++nodeIndex && node && node[dir]) ||
(diff = nodeIndex = 0) ||
start.pop())
) {
if (
(ofType
? node.nodeName.toLowerCase() === name
: node.nodeType === 1) &&
++diff
) {
// Cache the index of each encountered element
if (useCache) {
(node[expando] || (node[expando] = {}))[type] = [
dirruns,
diff,
];
}
if (node === elem) {
break;
}
}
}
}
// Incorporate the offset, then check against cycle size
diff -= last;
return (
diff === first || (diff % first === 0 && diff / first >= 0)
);
}
};
},
PSEUDO: function (pseudo, argument) {
// pseudo-class names are case-insensitive
// http://www.w3.org/TR/selectors/#pseudo-classes
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
// Remember that setFilters inherits from pseudos
var args,
fn =
Expr.pseudos[pseudo] ||
Expr.setFilters[pseudo.toLowerCase()] ||
Sizzle.error("unsupported pseudo: " + pseudo);
// The user may use createPseudo to indicate that
// arguments are needed to create the filter function
// just as Sizzle does
if (fn[expando]) {
return fn(argument);
}
// But maintain support for old signatures
if (fn.length > 1) {
args = [pseudo, pseudo, "", argument];
return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase())
? markFunction(function (seed, matches) {
var idx,
matched = fn(seed, argument),
i = matched.length;
while (i--) {
idx = indexOf.call(seed, matched[i]);
seed[idx] = !(matches[idx] = matched[i]);
}
})
: function (elem) {
return fn(elem, 0, args);
};
}
return fn;
},
},
pseudos: {
// Potentially complex pseudos
not: markFunction(function (selector) {
// Trim the selector passed to compile
// to avoid treating leading and trailing
// spaces as combinators
var input = [],
results = [],
matcher = compile(selector.replace(rtrim, "$1"));
return matcher[expando]
? markFunction(function (seed, matches, context, xml) {
var elem,
unmatched = matcher(seed, null, xml, []),
i = seed.length;
// Match elements unmatched by `matcher`
while (i--) {
if ((elem = unmatched[i])) {
seed[i] = !(matches[i] = elem);
}
}
})
: function (elem, context, xml) {
input[0] = elem;
matcher(input, null, xml, results);
return !results.pop();
};
}),
has: markFunction(function (selector) {
return function (elem) {
return Sizzle(selector, elem).length > 0;
};
}),
contains: markFunction(function (text) {
return function (elem) {
return (
(elem.textContent || elem.innerText || getText(elem)).indexOf(
text,
) > -1
);
};
}),
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
lang: markFunction(function (lang) {
// lang value must be a valid identifider
if (!ridentifier.test(lang || "")) {
Sizzle.error("unsupported lang: " + lang);
}
lang = lang.replace(runescape, funescape).toLowerCase();
return function (elem) {
var elemLang;
do {
if (
(elemLang = documentIsXML
? elem.getAttribute("xml:lang") || elem.getAttribute("lang")
: elem.lang)
) {
elemLang = elemLang.toLowerCase();
return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
}
} while ((elem = elem.parentNode) && elem.nodeType === 1);
return false;
};
}),
// Miscellaneous
target: function (elem) {
var hash = window.location && window.location.hash;
return hash && hash.slice(1) === elem.id;
},
root: function (elem) {
return elem === docElem;
},
focus: function (elem) {
return (
elem === document.activeElement &&
(!document.hasFocus || document.hasFocus()) &&
!!(elem.type || elem.href || ~elem.tabIndex)
);
},
// Boolean properties
enabled: function (elem) {
return elem.disabled === false;
},
disabled: function (elem) {
return elem.disabled === true;
},
checked: function (elem) {
// In CSS3, :checked should return both checked and selected elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
var nodeName = elem.nodeName.toLowerCase();
return (
(nodeName === "input" && !!elem.checked) ||
(nodeName === "option" && !!elem.selected)
);
},
selected: function (elem) {
// Accessing this property makes selected-by-default
// options in Safari work properly
if (elem.parentNode) {
elem.parentNode.selectedIndex;
}
return elem.selected === true;
},
// Contents
empty: function (elem) {
// http://www.w3.org/TR/selectors/#empty-pseudo
// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
// not comment, processing instructions, or others
// Thanks to Diego Perini for the nodeName shortcut
// Greater than "@" means alpha characters (specifically not starting with "#" or "?")
for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
if (
elem.nodeName > "@" ||
elem.nodeType === 3 ||
elem.nodeType === 4
) {
return false;
}
}
return true;
},
parent: function (elem) {
return !Expr.pseudos["empty"](elem);
},
// Element/input types
header: function (elem) {
return rheader.test(elem.nodeName);
},
input: function (elem) {
return rinputs.test(elem.nodeName);
},
button: function (elem) {
var name = elem.nodeName.toLowerCase();
return (
(name === "input" && elem.type === "button") || name === "button"
);
},
text: function (elem) {
var attr;
// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
// use getAttribute instead to test this case
return (
elem.nodeName.toLowerCase() === "input" &&
elem.type === "text" &&
((attr = elem.getAttribute("type")) == null ||
attr.toLowerCase() === elem.type)
);
},
// Position-in-collection
first: createPositionalPseudo(function () {
return [0];
}),
last: createPositionalPseudo(function (matchIndexes, length) {
return [length - 1];
}),
eq: createPositionalPseudo(function (matchIndexes, length, argument) {
return [argument < 0 ? argument + length : argument];
}),
even: createPositionalPseudo(function (matchIndexes, length) {
var i = 0;
for (; i < length; i += 2) {
matchIndexes.push(i);
}
return matchIndexes;
}),
odd: createPositionalPseudo(function (matchIndexes, length) {
var i = 1;
for (; i < length; i += 2) {
matchIndexes.push(i);
}
return matchIndexes;
}),
lt: createPositionalPseudo(function (matchIndexes, length, argument) {
var i = argument < 0 ? argument + length : argument;
for (; --i >= 0; ) {
matchIndexes.push(i);
}
return matchIndexes;
}),
gt: createPositionalPseudo(function (matchIndexes, length, argument) {
var i = argument < 0 ? argument + length : argument;
for (; ++i < length; ) {
matchIndexes.push(i);
}
return matchIndexes;
}),
},
};
// Add button/input type pseudos
for (i in {
radio: true,
checkbox: true,
file: true,
password: true,
image: true,
}) {
Expr.pseudos[i] = createInputPseudo(i);
}
for (i in { submit: true, reset: true }) {
Expr.pseudos[i] = createButtonPseudo(i);
}
function tokenize(selector, parseOnly) {
var matched,
match,
tokens,
type,
soFar,
groups,
preFilters,
cached = tokenCache[selector + " "];
if (cached) {
return parseOnly ? 0 : cached.slice(0);
}
soFar = selector;
groups = [];
preFilters = Expr.preFilter;
while (soFar) {
// Comma and first run
if (!matched || (match = rcomma.exec(soFar))) {
if (match) {
// Don't consume trailing commas as valid
soFar = soFar.slice(match[0].length) || soFar;
}
groups.push((tokens = []));
}
matched = false;
// Combinators
if ((match = rcombinators.exec(soFar))) {
matched = match.shift();
tokens.push({
value: matched,
// Cast descendant combinators to space
type: match[0].replace(rtrim, " "),
});
soFar = soFar.slice(matched.length);
}
// Filters
for (type in Expr.filter) {
if (
(match = matchExpr[type].exec(soFar)) &&
(!preFilters[type] || (match = preFilters[type](match)))
) {
matched = match.shift();
tokens.push({
value: matched,
type: type,
matches: match,
});
soFar = soFar.slice(matched.length);
}
}
if (!matched) {
break;
}
}
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly
? soFar.length
: soFar
? Sizzle.error(selector)
: // Cache the tokens
tokenCache(selector, groups).slice(0);
}
function toSelector(tokens) {
var i = 0,
len = tokens.length,
selector = "";
for (; i < len; i++) {
selector += tokens[i].value;
}
return selector;
}
function addCombinator(matcher, combinator, base) {
var dir = combinator.dir,
checkNonElements = base && dir === "parentNode",
doneName = done++;
return combinator.first
? // Check against closest ancestor/preceding element
function (elem, context, xml) {
while ((elem = elem[dir])) {
if (elem.nodeType === 1 || checkNonElements) {
return matcher(elem, context, xml);
}
}
}
: // Check against all ancestor/preceding elements
function (elem, context, xml) {
var data,
cache,
outerCache,
dirkey = dirruns + " " + doneName;
// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
if (xml) {
while ((elem = elem[dir])) {
if (elem.nodeType === 1 || checkNonElements) {
if (matcher(elem, context, xml)) {
return true;
}
}
}
} else {
while ((elem = elem[dir])) {
if (elem.nodeType === 1 || checkNonElements) {
outerCache = elem[expando] || (elem[expando] = {});
if ((cache = outerCache[dir]) && cache[0] === dirkey) {
if ((data = cache[1]) === true || data === cachedruns) {
return data === true;
}
} else {
cache = outerCache[dir] = [dirkey];
cache[1] = matcher(elem, context, xml) || cachedruns;
if (cache[1] === true) {
return true;
}
}
}
}
}
};
}
function elementMatcher(matchers) {
return matchers.length > 1
? function (elem, context, xml) {
var i = matchers.length;
while (i--) {
if (!matchers[i](elem, context, xml)) {
return false;
}
}
return true;
}
: matchers[0];
}
function condense(unmatched, map, filter, context, xml) {
var elem,
newUnmatched = [],
i = 0,
len = unmatched.length,
mapped = map != null;
for (; i < len; i++) {
if ((elem = unmatched[i])) {
if (!filter || filter(elem, context, xml)) {
newUnmatched.push(elem);
if (mapped) {
map.push(i);
}
}
}
}
return newUnmatched;
}
function setMatcher(
preFilter,
selector,
matcher,
postFilter,
postFinder,
postSelector,
) {
if (postFilter && !postFilter[expando]) {
postFilter = setMatcher(postFilter);
}
if (postFinder && !postFinder[expando]) {
postFinder = setMatcher(postFinder, postSelector);
}
return markFunction(function (seed, results, context, xml) {
var temp,
i,
elem,
preMap = [],
postMap = [],
preexisting = results.length,
// Get initial elements from seed or context
elems =
seed ||
multipleContexts(
selector || "*",
context.nodeType ? [context] : context,
[],
),
// Prefilter to get matcher input, preserving a map for seed-results synchronization
matcherIn =
preFilter && (seed || !selector)
? condense(elems, preMap, preFilter, context, xml)
: elems,
matcherOut = matcher
? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
postFinder || (seed ? preFilter : preexisting || postFilter)
? // ...intermediate processing is necessary
[]
: // ...otherwise use results directly
results
: matcherIn;
// Find primary matches
if (matcher) {
matcher(matcherIn, matcherOut, context, xml);
}
// Apply postFilter
if (postFilter) {
temp = condense(matcherOut, postMap);
postFilter(temp, [], context, xml);
// Un-match failing elements by moving them back to matcherIn
i = temp.length;
while (i--) {
if ((elem = temp[i])) {
matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
}
}
}
if (seed) {
if (postFinder || preFilter) {
if (postFinder) {
// Get the final matcherOut by condensing this intermediate into postFinder contexts
temp = [];
i = matcherOut.length;
while (i--) {
if ((elem = matcherOut[i])) {
// Restore matcherIn since elem is not yet a final match
temp.push((matcherIn[i] = elem));
}
}
postFinder(null, (matcherOut = []), temp, xml);
}
// Move matched elements from seed to results to keep them synchronized
i = matcherOut.length;
while (i--) {
if (
(elem = matcherOut[i]) &&
(temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1
) {
seed[temp] = !(results[temp] = elem);
}
}
}
// Add elements to results, through postFinder if defined
} else {
matcherOut = condense(
matcherOut === results
? matcherOut.splice(preexisting, matcherOut.length)
: matcherOut,
);
if (postFinder) {
postFinder(null, results, matcherOut, xml);
} else {
push.apply(results, matcherOut);
}
}
});
}
function matcherFromTokens(tokens) {
var checkContext,
matcher,
j,
len = tokens.length,
leadingRelative = Expr.relative[tokens[0].type],
implicitRelative = leadingRelative || Expr.relative[" "],
i = leadingRelative ? 1 : 0,
// The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator(
function (elem) {
return elem === checkContext;
},
implicitRelative,
true,
),
matchAnyContext = addCombinator(
function (elem) {
return indexOf.call(checkContext, elem) > -1;
},
implicitRelative,
true,
),
matchers = [
function (elem, context, xml) {
return (
(!leadingRelative && (xml || context !== outermostContext)) ||
((checkContext = context).nodeType
? matchContext(elem, context, xml)
: matchAnyContext(elem, context, xml))
);
},
];
for (; i < len; i++) {
if ((matcher = Expr.relative[tokens[i].type])) {
matchers = [addCombinator(elementMatcher(matchers), matcher)];
} else {
matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
// Return special upon seeing a positional matcher
if (matcher[expando]) {
// Find the next relative operator (if any) for proper handling
j = ++i;
for (; j < len; j++) {
if (Expr.relative[tokens[j].type]) {
break;
}
}
return setMatcher(
i > 1 && elementMatcher(matchers),
i > 1 && toSelector(tokens.slice(0, i - 1)).replace(rtrim, "$1"),
matcher,
i < j && matcherFromTokens(tokens.slice(i, j)),
j < len && matcherFromTokens((tokens = tokens.slice(j))),
j < len && toSelector(tokens),
);
}
matchers.push(matcher);
}
}
return elementMatcher(matchers);
}
function matcherFromGroupMatchers(elementMatchers, setMatchers) {
// A counter to specify which element is currently being matched
var matcherCachedRuns = 0,
bySet = setMatchers.length > 0,
byElement = elementMatchers.length > 0,
superMatcher = function (seed, context, xml, results, expandContext) {
var elem,
j,
matcher,
setMatched = [],
matchedCount = 0,
i = "0",
unmatched = seed && [],
outermost = expandContext != null,
contextBackup = outermostContext,
// We must always have either seed elements or context
elems =
seed ||
(byElement &&
Expr.find["TAG"](
"*",
(expandContext && context.parentNode) || context,
)),
// Use integer dirruns iff this is the outermost matcher
dirrunsUnique = (dirruns +=
contextBackup == null ? 1 : Math.random() || 0.1);
if (outermost) {
outermostContext = context !== document && context;
cachedruns = matcherCachedRuns;
}
// Add elements passing elementMatchers directly to results
// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
for (; (elem = elems[i]) != null; i++) {
if (byElement && elem) {
j = 0;
while ((matcher = elementMatchers[j++])) {
if (matcher(elem, context, xml)) {
results.push(elem);
break;
}
}
if (outermost) {
dirruns = dirrunsUnique;
cachedruns = ++matcherCachedRuns;
}
}
// Track unmatched elements for set filters
if (bySet) {
// They will have gone through all possible matchers
if ((elem = !matcher && elem)) {
matchedCount--;
}
// Lengthen the array for every element, matched or not
if (seed) {
unmatched.push(elem);
}
}
}
// Apply set filters to unmatched elements
matchedCount += i;
if (bySet && i !== matchedCount) {
j = 0;
while ((matcher = setMatchers[j++])) {
matcher(unmatched, setMatched, context, xml);
}
if (seed) {
// Reintegrate element matches to eliminate the need for sorting
if (matchedCount > 0) {
while (i--) {
if (!(unmatched[i] || setMatched[i])) {
setMatched[i] = pop.call(results);
}
}
}
// Discard index placeholder values to get only actual matches
setMatched = condense(setMatched);
}
// Add matches to results
push.apply(results, setMatched);
// Seedless set matches succeeding multiple successful matchers stipulate sorting
if (
outermost &&
!seed &&
setMatched.length > 0 &&
matchedCount + setMatchers.length > 1
) {
Sizzle.uniqueSort(results);
}
}
// Override manipulation of globals by nested matchers
if (outermost) {
dirruns = dirrunsUnique;
outermostContext = contextBackup;
}
return unmatched;
};
return bySet ? markFunction(superMatcher) : superMatcher;
}
compile = Sizzle.compile = function (
selector,
group /* Internal Use Only */,
) {
var i,
setMatchers = [],
elementMatchers = [],
cached = compilerCache[selector + " "];
if (!cached) {
// Generate a function of recursive functions that can be used to check each element
if (!group) {
group = tokenize(selector);
}
i = group.length;
while (i--) {
cached = matcherFromTokens(group[i]);
if (cached[expando]) {
setMatchers.push(cached);
} else {
elementMatchers.push(cached);
}
}
// Cache the compiled function
cached = compilerCache(
selector,
matcherFromGroupMatchers(elementMatchers, setMatchers),
);
}
return cached;
};
function multipleContexts(selector, contexts, results) {
var i = 0,
len = contexts.length;
for (; i < len; i++) {
Sizzle(selector, contexts[i], results);
}
return results;
}
function select(selector, context, results, seed) {
var i,
tokens,
token,
type,
find,
match = tokenize(selector);
if (!seed) {
// Try to minimize operations if there is only one group
if (match.length === 1) {
// Take a shortcut and set the context if the root selector is an ID
tokens = match[0] = match[0].slice(0);
if (
tokens.length > 2 &&
(token = tokens[0]).type === "ID" &&
context.nodeType === 9 &&
!documentIsXML &&
Expr.relative[tokens[1].type]
) {
context = Expr.find["ID"](
token.matches[0].replace(runescape, funescape),
context,
)[0];
if (!context) {
return results;
}
selector = selector.slice(tokens.shift().value.length);
}
// Fetch a seed set for right-to-left matching
i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
while (i--) {
token = tokens[i];
// Abort if we hit a combinator
if (Expr.relative[(type = token.type)]) {
break;
}
if ((find = Expr.find[type])) {
// Search, expanding context for leading sibling combinators
if (
(seed = find(
token.matches[0].replace(runescape, funescape),
(rsibling.test(tokens[0].type) && context.parentNode) ||
context,
))
) {
// If seed is empty or no tokens remain, we can return early
tokens.splice(i, 1);
selector = seed.length && toSelector(tokens);
if (!selector) {
push.apply(results, slice.call(seed, 0));
return results;
}
break;
}
}
}
}
}
// Compile and execute a filtering function
// Provide `match` to avoid retokenization if we modified the selector above
compile(selector, match)(
seed,
context,
documentIsXML,
results,
rsibling.test(selector),
);
return results;
}
// Deprecated
Expr.pseudos["nth"] = Expr.pseudos["eq"];
// Easy API for creating new setFilters
function setFilters() {}
Expr.filters = setFilters.prototype = Expr.pseudos;
Expr.setFilters = new setFilters();
// Initialize with the default document
setDocument();
// Override sizzle attribute retrieval
Sizzle.attr = jQuery.attr;
jQuery.find = Sizzle;
jQuery.expr = Sizzle.selectors;
jQuery.expr[":"] = jQuery.expr.pseudos;
jQuery.unique = Sizzle.uniqueSort;
jQuery.text = Sizzle.getText;
jQuery.isXMLDoc = Sizzle.isXML;
jQuery.contains = Sizzle.contains;
})(window);
var runtil = /Until$/,
rparentsprev = /^(?:parents|prev(?:Until|All))/,
isSimple = /^.[^:#\[\.,]*$/,
rneedsContext = jQuery.expr.match.needsContext,
// methods guaranteed to produce a unique set when starting from a unique set
guaranteedUnique = {
children: true,
contents: true,
next: true,
prev: true,
};
jQuery.fn.extend({
find: function (selector) {
var i,
ret,
self,
len = this.length;
if (typeof selector !== "string") {
self = this;
return this.pushStack(
jQuery(selector).filter(function () {
for (i = 0; i < len; i++) {
if (jQuery.contains(self[i], this)) {
return true;
}
}
}),
);
}
ret = [];
for (i = 0; i < len; i++) {
jQuery.find(selector, this[i], ret);
}
// Needed because $( selector, context ) becomes $( context ).find( selector )
ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
ret.selector = (this.selector ? this.selector + " " : "") + selector;
return ret;
},
has: function (target) {
var i,
targets = jQuery(target, this),
len = targets.length;
return this.filter(function () {
for (i = 0; i < len; i++) {
if (jQuery.contains(this, targets[i])) {
return true;
}
}
});
},
not: function (selector) {
return this.pushStack(winnow(this, selector, false));
},
filter: function (selector) {
return this.pushStack(winnow(this, selector, true));
},
is: function (selector) {
return (
!!selector &&
(typeof selector === "string"
? // If this is a positional/relative selector, check membership in the returned set
// so $("p:first").is("p:last") won't return true for a doc with two "p".
rneedsContext.test(selector)
? jQuery(selector, this.context).index(this[0]) >= 0
: jQuery.filter(selector, this).length > 0
: this.filter(selector).length > 0)
);
},
closest: function (selectors, context) {
var cur,
i = 0,
l = this.length,
ret = [],
pos =
rneedsContext.test(selectors) || typeof selectors !== "string"
? jQuery(selectors, context || this.context)
: 0;
for (; i < l; i++) {
cur = this[i];
while (
cur &&
cur.ownerDocument &&
cur !== context &&
cur.nodeType !== 11
) {
if (
pos
? pos.index(cur) > -1
: jQuery.find.matchesSelector(cur, selectors)
) {
ret.push(cur);
break;
}
cur = cur.parentNode;
}
}
return this.pushStack(ret.length > 1 ? jQuery.unique(ret) : ret);
},
// Determine the position of an element within
// the matched set of elements
index: function (elem) {
// No argument, return index in parent
if (!elem) {
return this[0] && this[0].parentNode
? this.first().prevAll().length
: -1;
}
// index in selector
if (typeof elem === "string") {
return jQuery.inArray(this[0], jQuery(elem));
}
// Locate the position of the desired element
return jQuery.inArray(
// If it receives a jQuery object, the first element is used
elem.jquery ? elem[0] : elem,
this,
);
},
add: function (selector, context) {
var set =
typeof selector === "string"
? jQuery(selector, context)
: jQuery.makeArray(
selector && selector.nodeType ? [selector] : selector,
),
all = jQuery.merge(this.get(), set);
return this.pushStack(jQuery.unique(all));
},
addBack: function (selector) {
return this.add(
selector == null ? this.prevObject : this.prevObject.filter(selector),
);
},
});
jQuery.fn.andSelf = jQuery.fn.addBack;
function sibling(cur, dir) {
do {
cur = cur[dir];
} while (cur && cur.nodeType !== 1);
return cur;
}
jQuery.each(
{
parent: function (elem) {
var parent = elem.parentNode;
return parent && parent.nodeType !== 11 ? parent : null;
},
parents: function (elem) {
return jQuery.dir(elem, "parentNode");
},
parentsUntil: function (elem, i, until) {
return jQuery.dir(elem, "parentNode", until);
},
next: function (elem) {
return sibling(elem, "nextSibling");
},
prev: function (elem) {
return sibling(elem, "previousSibling");
},
nextAll: function (elem) {
return jQuery.dir(elem, "nextSibling");
},
prevAll: function (elem) {
return jQuery.dir(elem, "previousSibling");
},
nextUntil: function (elem, i, until) {
return jQuery.dir(elem, "nextSibling", until);
},
prevUntil: function (elem, i, until) {
return jQuery.dir(elem, "previousSibling", until);
},
siblings: function (elem) {
return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
},
children: function (elem) {
return jQuery.sibling(elem.firstChild);
},
contents: function (elem) {
return jQuery.nodeName(elem, "iframe")
? elem.contentDocument || elem.contentWindow.document
: jQuery.merge([], elem.childNodes);
},
},
function (name, fn) {
jQuery.fn[name] = function (until, selector) {
var ret = jQuery.map(this, fn, until);
if (!runtil.test(name)) {
selector = until;
}
if (selector && typeof selector === "string") {
ret = jQuery.filter(selector, ret);
}
ret =
this.length > 1 && !guaranteedUnique[name] ? jQuery.unique(ret) : ret;
if (this.length > 1 && rparentsprev.test(name)) {
ret = ret.reverse();
}
return this.pushStack(ret);
};
},
);
jQuery.extend({
filter: function (expr, elems, not) {
if (not) {
expr = ":not(" + expr + ")";
}
return elems.length === 1
? jQuery.find.matchesSelector(elems[0], expr)
? [elems[0]]
: []
: jQuery.find.matches(expr, elems);
},
dir: function (elem, dir, until) {
var matched = [],
cur = elem[dir];
while (
cur &&
cur.nodeType !== 9 &&
(until === undefined || cur.nodeType !== 1 || !jQuery(cur).is(until))
) {
if (cur.nodeType === 1) {
matched.push(cur);
}
cur = cur[dir];
}
return matched;
},
sibling: function (n, elem) {
var r = [];
for (; n; n = n.nextSibling) {
if (n.nodeType === 1 && n !== elem) {
r.push(n);
}
}
return r;
},
});
// Implement the identical functionality for filter and not
function winnow(elements, qualifier, keep) {
// Can't pass null or undefined to indexOf in Firefox 4
// Set to 0 to skip string check
qualifier = qualifier || 0;
if (jQuery.isFunction(qualifier)) {
return jQuery.grep(elements, function (elem, i) {
var retVal = !!qualifier.call(elem, i, elem);
return retVal === keep;
});
} else if (qualifier.nodeType) {
return jQuery.grep(elements, function (elem) {
return (elem === qualifier) === keep;
});
} else if (typeof qualifier === "string") {
var filtered = jQuery.grep(elements, function (elem) {
return elem.nodeType === 1;
});
if (isSimple.test(qualifier)) {
return jQuery.filter(qualifier, filtered, !keep);
} else {
qualifier = jQuery.filter(qualifier, filtered);
}
}
return jQuery.grep(elements, function (elem) {
return jQuery.inArray(elem, qualifier) >= 0 === keep;
});
}
function createSafeFragment(document) {
var list = nodeNames.split("|"),
safeFrag = document.createDocumentFragment();
if (safeFrag.createElement) {
while (list.length) {
safeFrag.createElement(list.pop());
}
}
return safeFrag;
}
var nodeNames =
"abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
rleadingWhitespace = /^\s+/,
rxhtmlTag =
/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
rtagName = /<([\w:]+)/,
rtbody = /<tbody/i,
rhtml = /<|&#?\w+;/,
rnoInnerhtml = /<(?:script|style|link)/i,
manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
// checked="checked" or checked
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
rscriptType = /^$|\/(?:java|ecma)script/i,
rscriptTypeMasked = /^true\/(.*)/,
rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
// We have to close these tags to support XHTML (#13200)
wrapMap = {
option: [1, "<select multiple='multiple'>", "</select>"],
legend: [1, "<fieldset>", "</fieldset>"],
area: [1, "<map>", "</map>"],
param: [1, "<object>", "</object>"],
thead: [1, "<table>", "</table>"],
tr: [2, "<table><tbody>", "</tbody></table>"],
col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"],
td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
// unless wrapped in a div with non-breaking characters in front of it.
_default: jQuery.support.htmlSerialize
? [0, "", ""]
: [1, "X<div>", "</div>"],
},
safeFragment = createSafeFragment(document),
fragmentDiv = safeFragment.appendChild(document.createElement("div"));
wrapMap.optgroup = wrapMap.option;
wrapMap.tbody =
wrapMap.tfoot =
wrapMap.colgroup =
wrapMap.caption =
wrapMap.thead;
wrapMap.th = wrapMap.td;
jQuery.fn.extend({
text: function (value) {
return jQuery.access(
this,
function (value) {
return value === undefined
? jQuery.text(this)
: this.empty().append(
((this[0] && this[0].ownerDocument) || document).createTextNode(
value,
),
);
},
null,
value,
arguments.length,
);
},
wrapAll: function (html) {
if (jQuery.isFunction(html)) {
return this.each(function (i) {
jQuery(this).wrapAll(html.call(this, i));
});
}
if (this[0]) {
// The elements to wrap the target around
var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
if (this[0].parentNode) {
wrap.insertBefore(this[0]);
}
wrap
.map(function () {
var elem = this;
while (elem.firstChild && elem.firstChild.nodeType === 1) {
elem = elem.firstChild;
}
return elem;
})
.append(this);
}
return this;
},
wrapInner: function (html) {
if (jQuery.isFunction(html)) {
return this.each(function (i) {
jQuery(this).wrapInner(html.call(this, i));
});
}
return this.each(function () {
var self = jQuery(this),
contents = self.contents();
if (contents.length) {
contents.wrapAll(html);
} else {
self.append(html);
}
});
},
wrap: function (html) {
var isFunction = jQuery.isFunction(html);
return this.each(function (i) {
jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
});
},
unwrap: function () {
return this.parent()
.each(function () {
if (!jQuery.nodeName(this, "body")) {
jQuery(this).replaceWith(this.childNodes);
}
})
.end();
},
append: function () {
return this.domManip(arguments, true, function (elem) {
if (
this.nodeType === 1 ||
this.nodeType === 11 ||
this.nodeType === 9
) {
this.appendChild(elem);
}
});
},
prepend: function () {
return this.domManip(arguments, true, function (elem) {
if (
this.nodeType === 1 ||
this.nodeType === 11 ||
this.nodeType === 9
) {
this.insertBefore(elem, this.firstChild);
}
});
},
before: function () {
return this.domManip(arguments, false, function (elem) {
if (this.parentNode) {
this.parentNode.insertBefore(elem, this);
}
});
},
after: function () {
return this.domManip(arguments, false, function (elem) {
if (this.parentNode) {
this.parentNode.insertBefore(elem, this.nextSibling);
}
});
},
// keepData is for internal use only--do not document
remove: function (selector, keepData) {
var elem,
i = 0;
for (; (elem = this[i]) != null; i++) {
if (!selector || jQuery.filter(selector, [elem]).length > 0) {
if (!keepData && elem.nodeType === 1) {
jQuery.cleanData(getAll(elem));
}
if (elem.parentNode) {
if (keepData && jQuery.contains(elem.ownerDocument, elem)) {
setGlobalEval(getAll(elem, "script"));
}
elem.parentNode.removeChild(elem);
}
}
}
return this;
},
empty: function () {
var elem,
i = 0;
for (; (elem = this[i]) != null; i++) {
// Remove element nodes and prevent memory leaks
if (elem.nodeType === 1) {
jQuery.cleanData(getAll(elem, false));
}
// Remove any remaining nodes
while (elem.firstChild) {
elem.removeChild(elem.firstChild);
}
// If this is a select, ensure that it displays empty (#12336)
// Support: IE<9
if (elem.options && jQuery.nodeName(elem, "select")) {
elem.options.length = 0;
}
}
return this;
},
clone: function (dataAndEvents, deepDataAndEvents) {
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
deepDataAndEvents =
deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
return this.map(function () {
return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
});
},
html: function (value) {
return jQuery.access(
this,
function (value) {
var elem = this[0] || {},
i = 0,
l = this.length;
if (value === undefined) {
return elem.nodeType === 1
? elem.innerHTML.replace(rinlinejQuery, "")
: undefined;
}
// See if we can take a shortcut and just use innerHTML
if (
typeof value === "string" &&
!rnoInnerhtml.test(value) &&
(jQuery.support.htmlSerialize || !rnoshimcache.test(value)) &&
(jQuery.support.leadingWhitespace ||
!rleadingWhitespace.test(value)) &&
!wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]
) {
value = value.replace(rxhtmlTag, "<$1></$2>");
try {
for (; i < l; i++) {
// Remove element nodes and prevent memory leaks
elem = this[i] || {};
if (elem.nodeType === 1) {
jQuery.cleanData(getAll(elem, false));
elem.innerHTML = value;
}
}
elem = 0;
// If using innerHTML throws an exception, use the fallback method
} catch (e) {}
}
if (elem) {
this.empty().append(value);
}
},
null,
value,
arguments.length,
);
},
replaceWith: function (value) {
var isFunc = jQuery.isFunction(value);
// Make sure that the elements are removed from the DOM before they are inserted
// this can help fix replacing a parent with child elements
if (!isFunc && typeof value !== "string") {
value = jQuery(value).not(this).detach();
}
return this.domManip([value], true, function (elem) {
var next = this.nextSibling,
parent = this.parentNode;
if (parent) {
jQuery(this).remove();
parent.insertBefore(elem, next);
}
});
},
detach: function (selector) {
return this.remove(selector, true);
},
domManip: function (args, table, callback) {
// Flatten any nested arrays
args = core_concat.apply([], args);
var first,
node,
hasScripts,
scripts,
doc,
fragment,
i = 0,
l = this.length,
set = this,
iNoClone = l - 1,
value = args[0],
isFunction = jQuery.isFunction(value);
// We can't cloneNode fragments that contain checked, in WebKit
if (
isFunction ||
!(
l <= 1 ||
typeof value !== "string" ||
jQuery.support.checkClone ||
!rchecked.test(value)
)
) {
return this.each(function (index) {
var self = set.eq(index);
if (isFunction) {
args[0] = value.call(this, index, table ? self.html() : undefined);
}
self.domManip(args, table, callback);
});
}
if (l) {
fragment = jQuery.buildFragment(
args,
this[0].ownerDocument,
false,
this,
);
first = fragment.firstChild;
if (fragment.childNodes.length === 1) {
fragment = first;
}
if (first) {
table = table && jQuery.nodeName(first, "tr");
scripts = jQuery.map(getAll(fragment, "script"), disableScript);
hasScripts = scripts.length;
// Use the original fragment for the last item instead of the first because it can end up
// being emptied incorrectly in certain situations (#8070).
for (; i < l; i++) {
node = fragment;
if (i !== iNoClone) {
node = jQuery.clone(node, true, true);
// Keep references to cloned scripts for later restoration
if (hasScripts) {
jQuery.merge(scripts, getAll(node, "script"));
}
}
callback.call(
table && jQuery.nodeName(this[i], "table")
? findOrAppend(this[i], "tbody")
: this[i],
node,
i,
);
}
if (hasScripts) {
doc = scripts[scripts.length - 1].ownerDocument;
// Reenable scripts
jQuery.map(scripts, restoreScript);
// Evaluate executable scripts on first document insertion
for (i = 0; i < hasScripts; i++) {
node = scripts[i];
if (
rscriptType.test(node.type || "") &&
!jQuery._data(node, "globalEval") &&
jQuery.contains(doc, node)
) {
if (node.src) {
// Hope ajax is available...
jQuery.ajax({
url: node.src,
type: "GET",
dataType: "script",
async: false,
global: false,
throws: true,
});
} else {
jQuery.globalEval(
(
node.text ||
node.textContent ||
node.innerHTML ||
""
).replace(rcleanScript, ""),
);
}
}
}
}
// Fix #11809: Avoid leaking memory
fragment = first = null;
}
}
return this;
},
});
function findOrAppend(elem, tag) {
return (
elem.getElementsByTagName(tag)[0] ||
elem.appendChild(elem.ownerDocument.createElement(tag))
);
}
// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript(elem) {
var attr = elem.getAttributeNode("type");
elem.type = (attr && attr.specified) + "/" + elem.type;
return elem;
}
function restoreScript(elem) {
var match = rscriptTypeMasked.exec(elem.type);
if (match) {
elem.type = match[1];
} else {
elem.removeAttribute("type");
}
return elem;
}
// Mark scripts as having already been evaluated
function setGlobalEval(elems, refElements) {
var elem,
i = 0;
for (; (elem = elems[i]) != null; i++) {
jQuery._data(
elem,
"globalEval",
!refElements || jQuery._data(refElements[i], "globalEval"),
);
}
}
function cloneCopyEvent(src, dest) {
if (dest.nodeType !== 1 || !jQuery.hasData(src)) {
return;
}
var type,
i,
l,
oldData = jQuery._data(src),
curData = jQuery._data(dest, oldData),
events = oldData.events;
if (events) {
delete curData.handle;
curData.events = {};
for (type in events) {
for (i = 0, l = events[type].length; i < l; i++) {
jQuery.event.add(dest, type, events[type][i]);
}
}
}
// make the cloned public data object a copy from the original
if (curData.data) {
curData.data = jQuery.extend({}, curData.data);
}
}
function fixCloneNodeIssues(src, dest) {
var nodeName, e, data;
// We do not need to do anything for non-Elements
if (dest.nodeType !== 1) {
return;
}
nodeName = dest.nodeName.toLowerCase();
// IE6-8 copies events bound via attachEvent when using cloneNode.
if (!jQuery.support.noCloneEvent && dest[jQuery.expando]) {
data = jQuery._data(dest);
for (e in data.events) {
jQuery.removeEvent(dest, e, data.handle);
}
// Event data gets referenced instead of copied if the expando gets copied too
dest.removeAttribute(jQuery.expando);
}
// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
if (nodeName === "script" && dest.text !== src.text) {
disableScript(dest).text = src.text;
restoreScript(dest);
// IE6-10 improperly clones children of object elements using classid.
// IE10 throws NoModificationAllowedError if parent is null, #12132.
} else if (nodeName === "object") {
if (dest.parentNode) {
dest.outerHTML = src.outerHTML;
}
// This path appears unavoidable for IE9. When cloning an object
// element in IE9, the outerHTML strategy above is not sufficient.
// If the src has innerHTML and the destination does not,
// copy the src.innerHTML into the dest.innerHTML. #10324
if (
jQuery.support.html5Clone &&
src.innerHTML &&
!jQuery.trim(dest.innerHTML)
) {
dest.innerHTML = src.innerHTML;
}
} else if (
nodeName === "input" &&
manipulation_rcheckableType.test(src.type)
) {
// IE6-8 fails to persist the checked state of a cloned checkbox
// or radio button. Worse, IE6-7 fail to give the cloned element
// a checked appearance if the defaultChecked value isn't also set
dest.defaultChecked = dest.checked = src.checked;
// IE6-7 get confused and end up setting the value of a cloned
// checkbox/radio button to an empty string instead of "on"
if (dest.value !== src.value) {
dest.value = src.value;
}
// IE6-8 fails to return the selected option to the default selected
// state when cloning options
} else if (nodeName === "option") {
dest.defaultSelected = dest.selected = src.defaultSelected;
// IE6-8 fails to set the defaultValue to the correct value when
// cloning other types of input fields
} else if (nodeName === "input" || nodeName === "textarea") {
dest.defaultValue = src.defaultValue;
}
}
jQuery.each(
{
appendTo: "append",
prependTo: "prepend",
insertBefore: "before",
insertAfter: "after",
replaceAll: "replaceWith",
},
function (name, original) {
jQuery.fn[name] = function (selector) {
var elems,
i = 0,
ret = [],
insert = jQuery(selector),
last = insert.length - 1;
for (; i <= last; i++) {
elems = i === last ? this : this.clone(true);
jQuery(insert[i])[original](elems);
// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
core_push.apply(ret, elems.get());
}
return this.pushStack(ret);
};
},
);
function getAll(context, tag) {
var elems,
elem,
i = 0,
found =
typeof context.getElementsByTagName !== core_strundefined
? context.getElementsByTagName(tag || "*")
: typeof context.querySelectorAll !== core_strundefined
? context.querySelectorAll(tag || "*")
: undefined;
if (!found) {
for (
found = [], elems = context.childNodes || context;
(elem = elems[i]) != null;
i++
) {
if (!tag || jQuery.nodeName(elem, tag)) {
found.push(elem);
} else {
jQuery.merge(found, getAll(elem, tag));
}
}
}
return tag === undefined || (tag && jQuery.nodeName(context, tag))
? jQuery.merge([context], found)
: found;
}
// Used in buildFragment, fixes the defaultChecked property
function fixDefaultChecked(elem) {
if (manipulation_rcheckableType.test(elem.type)) {
elem.defaultChecked = elem.checked;
}
}
jQuery.extend({
clone: function (elem, dataAndEvents, deepDataAndEvents) {
var destElements,
node,
clone,
i,
srcElements,
inPage = jQuery.contains(elem.ownerDocument, elem);
if (
jQuery.support.html5Clone ||
jQuery.isXMLDoc(elem) ||
!rnoshimcache.test("<" + elem.nodeName + ">")
) {
clone = elem.cloneNode(true);
// IE<=8 does not properly clone detached, unknown element nodes
} else {
fragmentDiv.innerHTML = elem.outerHTML;
fragmentDiv.removeChild((clone = fragmentDiv.firstChild));
}
if (
(!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
(elem.nodeType === 1 || elem.nodeType === 11) &&
!jQuery.isXMLDoc(elem)
) {
// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
destElements = getAll(clone);
srcElements = getAll(elem);
// Fix all IE cloning issues
for (i = 0; (node = srcElements[i]) != null; ++i) {
// Ensure that the destination node is not null; Fixes #9587
if (destElements[i]) {
fixCloneNodeIssues(node, destElements[i]);
}
}
}
// Copy the events from the original to the clone
if (dataAndEvents) {
if (deepDataAndEvents) {
srcElements = srcElements || getAll(elem);
destElements = destElements || getAll(clone);
for (i = 0; (node = srcElements[i]) != null; i++) {
cloneCopyEvent(node, destElements[i]);
}
} else {
cloneCopyEvent(elem, clone);
}
}
// Preserve script evaluation history
destElements = getAll(clone, "script");
if (destElements.length > 0) {
setGlobalEval(destElements, !inPage && getAll(elem, "script"));
}
destElements = srcElements = node = null;
// Return the cloned set
return clone;
},
buildFragment: function (elems, context, scripts, selection) {
var j,
elem,
contains,
tmp,
tag,
tbody,
wrap,
l = elems.length,
// Ensure a safe fragment
safe = createSafeFragment(context),
nodes = [],
i = 0;
for (; i < l; i++) {
elem = elems[i];
if (elem || elem === 0) {
// Add nodes directly
if (jQuery.type(elem) === "object") {
jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
// Convert non-html into a text node
} else if (!rhtml.test(elem)) {
nodes.push(context.createTextNode(elem));
// Convert html into DOM nodes
} else {
tmp = tmp || safe.appendChild(context.createElement("div"));
// Deserialize a standard representation
tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
wrap = wrapMap[tag] || wrapMap._default;
tmp.innerHTML =
wrap[1] + elem.replace(rxhtmlTag, "<$1></$2>") + wrap[2];
// Descend through wrappers to the right content
j = wrap[0];
while (j--) {
tmp = tmp.lastChild;
}
// Manually add leading whitespace removed by IE
if (
!jQuery.support.leadingWhitespace &&
rleadingWhitespace.test(elem)
) {
nodes.push(
context.createTextNode(rleadingWhitespace.exec(elem)[0]),
);
}
// Remove IE's autoinserted <tbody> from table fragments
if (!jQuery.support.tbody) {
// String was a <table>, *may* have spurious <tbody>
elem =
tag === "table" && !rtbody.test(elem)
? tmp.firstChild
: // String was a bare <thead> or <tfoot>
wrap[1] === "<table>" && !rtbody.test(elem)
? tmp
: 0;
j = elem && elem.childNodes.length;
while (j--) {
if (
jQuery.nodeName((tbody = elem.childNodes[j]), "tbody") &&
!tbody.childNodes.length
) {
elem.removeChild(tbody);
}
}
}
jQuery.merge(nodes, tmp.childNodes);
// Fix #12392 for WebKit and IE > 9
tmp.textContent = "";
// Fix #12392 for oldIE
while (tmp.firstChild) {
tmp.removeChild(tmp.firstChild);
}
// Remember the top-level container for proper cleanup
tmp = safe.lastChild;
}
}
}
// Fix #11356: Clear elements from fragment
if (tmp) {
safe.removeChild(tmp);
}
// Reset defaultChecked for any radios and checkboxes
// about to be appended to the DOM in IE 6/7 (#8060)
if (!jQuery.support.appendChecked) {
jQuery.grep(getAll(nodes, "input"), fixDefaultChecked);
}
i = 0;
while ((elem = nodes[i++])) {
// #4087 - If origin and destination elements are the same, and this is
// that element, do not do anything
if (selection && jQuery.inArray(elem, selection) !== -1) {
continue;
}
contains = jQuery.contains(elem.ownerDocument, elem);
// Append to fragment
tmp = getAll(safe.appendChild(elem), "script");
// Preserve script evaluation history
if (contains) {
setGlobalEval(tmp);
}
// Capture executables
if (scripts) {
j = 0;
while ((elem = tmp[j++])) {
if (rscriptType.test(elem.type || "")) {
scripts.push(elem);
}
}
}
}
tmp = null;
return safe;
},
cleanData: function (elems, /* internal */ acceptData) {
var elem,
type,
id,
data,
i = 0,
internalKey = jQuery.expando,
cache = jQuery.cache,
deleteExpando = jQuery.support.deleteExpando,
special = jQuery.event.special;
for (; (elem = elems[i]) != null; i++) {
if (acceptData || jQuery.acceptData(elem)) {
id = elem[internalKey];
data = id && cache[id];
if (data) {
if (data.events) {
for (type in data.events) {
if (special[type]) {
jQuery.event.remove(elem, type);
// This is a shortcut to avoid jQuery.event.remove's overhead
} else {
jQuery.removeEvent(elem, type, data.handle);
}
}
}
// Remove cache only if it was not already removed by jQuery.event.remove
if (cache[id]) {
delete cache[id];
// IE does not allow us to delete expando properties from nodes,
// nor does it have a removeAttribute function on Document nodes;
// we must handle all of these cases
if (deleteExpando) {
delete elem[internalKey];
} else if (typeof elem.removeAttribute !== core_strundefined) {
elem.removeAttribute(internalKey);
} else {
elem[internalKey] = null;
}
core_deletedIds.push(id);
}
}
}
}
},
});
var iframe,
getStyles,
curCSS,
ralpha = /alpha\([^)]*\)/i,
ropacity = /opacity\s*=\s*([^)]*)/,
rposition = /^(top|right|bottom|left)$/,
// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
rmargin = /^margin/,
rnumsplit = new RegExp("^(" + core_pnum + ")(.*)$", "i"),
rnumnonpx = new RegExp("^(" + core_pnum + ")(?!px)[a-z%]+$", "i"),
rrelNum = new RegExp("^([+-])=(" + core_pnum + ")", "i"),
elemdisplay = { BODY: "block" },
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
cssNormalTransform = {
letterSpacing: 0,
fontWeight: 400,
},
cssExpand = ["Top", "Right", "Bottom", "Left"],
cssPrefixes = ["Webkit", "O", "Moz", "ms"];
// return a css property mapped to a potentially vendor prefixed property
function vendorPropName(style, name) {
// shortcut for names that are not vendor prefixed
if (name in style) {
return name;
}
// check for vendor prefixed names
var capName = name.charAt(0).toUpperCase() + name.slice(1),
origName = name,
i = cssPrefixes.length;
while (i--) {
name = cssPrefixes[i] + capName;
if (name in style) {
return name;
}
}
return origName;
}
function isHidden(elem, el) {
// isHidden might be called from jQuery#filter function;
// in that case, element will be second argument
elem = el || elem;
return (
jQuery.css(elem, "display") === "none" ||
!jQuery.contains(elem.ownerDocument, elem)
);
}
function showHide(elements, show) {
var display,
elem,
hidden,
values = [],
index = 0,
length = elements.length;
for (; index < length; index++) {
elem = elements[index];
if (!elem.style) {
continue;
}
values[index] = jQuery._data(elem, "olddisplay");
display = elem.style.display;
if (show) {
// Reset the inline display of this element to learn if it is
// being hidden by cascaded rules or not
if (!values[index] && display === "none") {
elem.style.display = "";
}
// Set elements which have been overridden with display: none
// in a stylesheet to whatever the default browser style is
// for such an element
if (elem.style.display === "" && isHidden(elem)) {
values[index] = jQuery._data(
elem,
"olddisplay",
css_defaultDisplay(elem.nodeName),
);
}
} else {
if (!values[index]) {
hidden = isHidden(elem);
if ((display && display !== "none") || !hidden) {
jQuery._data(
elem,
"olddisplay",
hidden ? display : jQuery.css(elem, "display"),
);
}
}
}
}
// Set the display of most of the elements in a second loop
// to avoid the constant reflow
for (index = 0; index < length; index++) {
elem = elements[index];
if (!elem.style) {
continue;
}
if (!show || elem.style.display === "none" || elem.style.display === "") {
elem.style.display = show ? values[index] || "" : "none";
}
}
return elements;
}
jQuery.fn.extend({
css: function (name, value) {
return jQuery.access(
this,
function (elem, name, value) {
var len,
styles,
map = {},
i = 0;
if (jQuery.isArray(name)) {
styles = getStyles(elem);
len = name.length;
for (; i < len; i++) {
map[name[i]] = jQuery.css(elem, name[i], false, styles);
}
return map;
}
return value !== undefined
? jQuery.style(elem, name, value)
: jQuery.css(elem, name);
},
name,
value,
arguments.length > 1,
);
},
show: function () {
return showHide(this, true);
},
hide: function () {
return showHide(this);
},
toggle: function (state) {
var bool = typeof state === "boolean";
return this.each(function () {
if (bool ? state : isHidden(this)) {
jQuery(this).show();
} else {
jQuery(this).hide();
}
});
},
});
jQuery.extend({
// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
opacity: {
get: function (elem, computed) {
if (computed) {
// We should always get a number back from opacity
var ret = curCSS(elem, "opacity");
return ret === "" ? "1" : ret;
}
},
},
},
// Exclude the following css properties to add px
cssNumber: {
columnCount: true,
fillOpacity: true,
fontWeight: true,
lineHeight: true,
opacity: true,
orphans: true,
widows: true,
zIndex: true,
zoom: true,
},
// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {
// normalize float css property
float: jQuery.support.cssFloat ? "cssFloat" : "styleFloat",
},
// Get and set the style property on a DOM Node
style: function (elem, name, value, extra) {
// Don't set styles on text and comment nodes
if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
return;
}
// Make sure that we're working with the right name
var ret,
type,
hooks,
origName = jQuery.camelCase(name),
style = elem.style;
name =
jQuery.cssProps[origName] ||
(jQuery.cssProps[origName] = vendorPropName(style, origName));
// gets hook for the prefixed version
// followed by the unprefixed version
hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
// Check if we're setting a value
if (value !== undefined) {
type = typeof value;
// convert relative number strings (+= or -=) to relative numbers. #7345
if (type === "string" && (ret = rrelNum.exec(value))) {
value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name));
// Fixes bug #9237
type = "number";
}
// Make sure that NaN and null values aren't set. See: #7116
if (value == null || (type === "number" && isNaN(value))) {
return;
}
// If a number was passed in, add 'px' to the (except for certain CSS properties)
if (type === "number" && !jQuery.cssNumber[origName]) {
value += "px";
}
// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
// but it would mean to define eight (for every problematic property) identical functions
if (
!jQuery.support.clearCloneStyle &&
value === "" &&
name.indexOf("background") === 0
) {
style[name] = "inherit";
}
// If a hook was provided, use that value, otherwise just set the specified value
if (
!hooks ||
!("set" in hooks) ||
(value = hooks.set(elem, value, extra)) !== undefined
) {
// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
// Fixes bug #5509
try {
style[name] = value;
} catch (e) {}
}
} else {
// If a hook was provided get the non-computed value from there
if (
hooks &&
"get" in hooks &&
(ret = hooks.get(elem, false, extra)) !== undefined
) {
return ret;
}
// Otherwise just get the value from the style object
return style[name];
}
},
css: function (elem, name, extra, styles) {
var num,
val,
hooks,
origName = jQuery.camelCase(name);
// Make sure that we're working with the right name
name =
jQuery.cssProps[origName] ||
(jQuery.cssProps[origName] = vendorPropName(elem.style, origName));
// gets hook for the prefixed version
// followed by the unprefixed version
hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
// If a hook was provided get the computed value from there
if (hooks && "get" in hooks) {
val = hooks.get(elem, true, extra);
}
// Otherwise, if a way to get the computed value exists, use that
if (val === undefined) {
val = curCSS(elem, name, styles);
}
//convert "normal" to computed value
if (val === "normal" && name in cssNormalTransform) {
val = cssNormalTransform[name];
}
// Return, converting to number if forced or a qualifier was provided and val looks numeric
if (extra === "" || extra) {
num = parseFloat(val);
return extra === true || jQuery.isNumeric(num) ? num || 0 : val;
}
return val;
},
// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function (elem, options, callback, args) {
var ret,
name,
old = {};
// Remember the old values, and insert the new ones
for (name in options) {
old[name] = elem.style[name];
elem.style[name] = options[name];
}
ret = callback.apply(elem, args || []);
// Revert the old values
for (name in options) {
elem.style[name] = old[name];
}
return ret;
},
});
// NOTE: we've included the "window" in window.getComputedStyle
// because jsdom on node.js will break without it.
if (window.getComputedStyle) {
getStyles = function (elem) {
return window.getComputedStyle(elem, null);
};
curCSS = function (elem, name, _computed) {
var width,
minWidth,
maxWidth,
computed = _computed || getStyles(elem),
// getPropertyValue is only needed for .css('filter') in IE9, see #12537
ret = computed
? computed.getPropertyValue(name) || computed[name]
: undefined,
style = elem.style;
if (computed) {
if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
ret = jQuery.style(elem, name);
}
// A tribute to the "awesome hack by Dean Edwards"
// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
if (rnumnonpx.test(ret) && rmargin.test(name)) {
// Remember the original values
width = style.width;
minWidth = style.minWidth;
maxWidth = style.maxWidth;
// Put in the new values to get a computed value out
style.minWidth = style.maxWidth = style.width = ret;
ret = computed.width;
// Revert the changed values
style.width = width;
style.minWidth = minWidth;
style.maxWidth = maxWidth;
}
}
return ret;
};
} else if (document.documentElement.currentStyle) {
getStyles = function (elem) {
return elem.currentStyle;
};
curCSS = function (elem, name, _computed) {
var left,
rs,
rsLeft,
computed = _computed || getStyles(elem),
ret = computed ? computed[name] : undefined,
style = elem.style;
// Avoid setting ret to empty string here
// so we don't default to auto
if (ret == null && style && style[name]) {
ret = style[name];
}
// From the awesome hack by Dean Edwards
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
// If we're not dealing with a regular pixel number
// but a number that has a weird ending, we need to convert it to pixels
// but not position css attributes, as those are proportional to the parent element instead
// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
if (rnumnonpx.test(ret) && !rposition.test(name)) {
// Remember the original values
left = style.left;
rs = elem.runtimeStyle;
rsLeft = rs && rs.left;
// Put in the new values to get a computed value out
if (rsLeft) {
rs.left = elem.currentStyle.left;
}
style.left = name === "fontSize" ? "1em" : ret;
ret = style.pixelLeft + "px";
// Revert the changed values
style.left = left;
if (rsLeft) {
rs.left = rsLeft;
}
}
return ret === "" ? "auto" : ret;
};
}
function setPositiveNumber(elem, value, subtract) {
var matches = rnumsplit.exec(value);
return matches
? // Guard against undefined "subtract", e.g., when used as in cssHooks
Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px")
: value;
}
function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
var i =
extra === (isBorderBox ? "border" : "content")
? // If we already have the right measurement, avoid augmentation
4
: // Otherwise initialize for horizontal or vertical properties
name === "width"
? 1
: 0,
val = 0;
for (; i < 4; i += 2) {
// both box models exclude margin, so add it if we want it
if (extra === "margin") {
val += jQuery.css(elem, extra + cssExpand[i], true, styles);
}
if (isBorderBox) {
// border-box includes padding, so remove it if we want content
if (extra === "content") {
val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
}
// at this point, extra isn't border nor margin, so remove border
if (extra !== "margin") {
val -= jQuery.css(
elem,
"border" + cssExpand[i] + "Width",
true,
styles,
);
}
} else {
// at this point, extra isn't content, so add padding
val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);
// at this point, extra isn't content nor padding, so add border
if (extra !== "padding") {
val += jQuery.css(
elem,
"border" + cssExpand[i] + "Width",
true,
styles,
);
}
}
}
return val;
}
function getWidthOrHeight(elem, name, extra) {
// Start with offset property, which is equivalent to the border-box value
var valueIsBorderBox = true,
val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
styles = getStyles(elem),
isBorderBox =
jQuery.support.boxSizing &&
jQuery.css(elem, "boxSizing", false, styles) === "border-box";
// some non-html elements return undefined for offsetWidth, so check for null/undefined
// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
if (val <= 0 || val == null) {
// Fall back to computed then uncomputed css if necessary
val = curCSS(elem, name, styles);
if (val < 0 || val == null) {
val = elem.style[name];
}
// Computed unit is not pixels. Stop here and return.
if (rnumnonpx.test(val)) {
return val;
}
// we need the check for style in case a browser which returns unreliable values
// for getComputedStyle silently falls back to the reliable elem.style
valueIsBorderBox =
isBorderBox &&
(jQuery.support.boxSizingReliable || val === elem.style[name]);
// Normalize "", auto, and prepare for extra
val = parseFloat(val) || 0;
}
// use the active box-sizing model to add/subtract irrelevant styles
return (
val +
augmentWidthOrHeight(
elem,
name,
extra || (isBorderBox ? "border" : "content"),
valueIsBorderBox,
styles,
) +
"px"
);
}
// Try to determine the default display value of an element
function css_defaultDisplay(nodeName) {
var doc = document,
display = elemdisplay[nodeName];
if (!display) {
display = actualDisplay(nodeName, doc);
// If the simple way fails, read from inside an iframe
if (display === "none" || !display) {
// Use the already-created iframe if possible
iframe = (
iframe ||
jQuery("<iframe frameborder='0' width='0' height='0'/>").css(
"cssText",
"display:block !important",
)
).appendTo(doc.documentElement);
// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
doc = (iframe[0].contentWindow || iframe[0].contentDocument).document;
doc.write("<!doctype html><html><body>");
doc.close();
display = actualDisplay(nodeName, doc);
iframe.detach();
}
// Store the correct default display
elemdisplay[nodeName] = display;
}
return display;
}
// Called ONLY from within css_defaultDisplay
function actualDisplay(name, doc) {
var elem = jQuery(doc.createElement(name)).appendTo(doc.body),
display = jQuery.css(elem[0], "display");
elem.remove();
return display;
}
jQuery.each(["height", "width"], function (i, name) {
jQuery.cssHooks[name] = {
get: function (elem, computed, extra) {
if (computed) {
// certain elements can have dimension info if we invisibly show them
// however, it must have a current display style that would benefit from this
return elem.offsetWidth === 0 &&
rdisplayswap.test(jQuery.css(elem, "display"))
? jQuery.swap(elem, cssShow, function () {
return getWidthOrHeight(elem, name, extra);
})
: getWidthOrHeight(elem, name, extra);
}
},
set: function (elem, value, extra) {
var styles = extra && getStyles(elem);
return setPositiveNumber(
elem,
value,
extra
? augmentWidthOrHeight(
elem,
name,
extra,
jQuery.support.boxSizing &&
jQuery.css(elem, "boxSizing", false, styles) === "border-box",
styles,
)
: 0,
);
},
};
});
if (!jQuery.support.opacity) {
jQuery.cssHooks.opacity = {
get: function (elem, computed) {
// IE uses filters for opacity
return ropacity.test(
(computed && elem.currentStyle
? elem.currentStyle.filter
: elem.style.filter) || "",
)
? 0.01 * parseFloat(RegExp.$1) + ""
: computed
? "1"
: "";
},
set: function (elem, value) {
var style = elem.style,
currentStyle = elem.currentStyle,
opacity = jQuery.isNumeric(value)
? "alpha(opacity=" + value * 100 + ")"
: "",
filter = (currentStyle && currentStyle.filter) || style.filter || "";
// IE has trouble with opacity if it does not have layout
// Force it by setting the zoom level
style.zoom = 1;
// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
// if value === "", then remove inline opacity #12685
if (
(value >= 1 || value === "") &&
jQuery.trim(filter.replace(ralpha, "")) === "" &&
style.removeAttribute
) {
// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
// if "filter:" is present at all, clearType is disabled, we want to avoid this
// style.removeAttribute is IE Only, but so apparently is this code path...
style.removeAttribute("filter");
// if there is no filter style applied in a css rule or unset inline opacity, we are done
if (value === "" || (currentStyle && !currentStyle.filter)) {
return;
}
}
// otherwise, set new filter values
style.filter = ralpha.test(filter)
? filter.replace(ralpha, opacity)
: filter + " " + opacity;
},
};
}
// These hooks cannot be added until DOM ready because the support test
// for it is not run until after DOM ready
jQuery(function () {
if (!jQuery.support.reliableMarginRight) {
jQuery.cssHooks.marginRight = {
get: function (elem, computed) {
if (computed) {
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
// Work around by temporarily setting element display to inline-block
return jQuery.swap(elem, { display: "inline-block" }, curCSS, [
elem,
"marginRight",
]);
}
},
};
}
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
// getComputedStyle returns percent when specified for top/left/bottom/right
// rather than make the css module depend on the offset module, we just check for it here
if (!jQuery.support.pixelPosition && jQuery.fn.position) {
jQuery.each(["top", "left"], function (i, prop) {
jQuery.cssHooks[prop] = {
get: function (elem, computed) {
if (computed) {
computed = curCSS(elem, prop);
// if curCSS returns percentage, fallback to offset
return rnumnonpx.test(computed)
? jQuery(elem).position()[prop] + "px"
: computed;
}
},
};
});
}
});
if (jQuery.expr && jQuery.expr.filters) {
jQuery.expr.filters.hidden = function (elem) {
// Support: Opera <= 12.12
// Opera reports offsetWidths and offsetHeights less than zero on some elements
return (
(elem.offsetWidth <= 0 && elem.offsetHeight <= 0) ||
(!jQuery.support.reliableHiddenOffsets &&
((elem.style && elem.style.display) ||
jQuery.css(elem, "display")) === "none")
);
};
jQuery.expr.filters.visible = function (elem) {
return !jQuery.expr.filters.hidden(elem);
};
}
// These hooks are used by animate to expand properties
jQuery.each(
{
margin: "",
padding: "",
border: "Width",
},
function (prefix, suffix) {
jQuery.cssHooks[prefix + suffix] = {
expand: function (value) {
var i = 0,
expanded = {},
// assumes a single number if not a string
parts = typeof value === "string" ? value.split(" ") : [value];
for (; i < 4; i++) {
expanded[prefix + cssExpand[i] + suffix] =
parts[i] || parts[i - 2] || parts[0];
}
return expanded;
},
};
if (!rmargin.test(prefix)) {
jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
}
},
);
var r20 = /%20/g,
rbracket = /\[\]$/,
rCRLF = /\r?\n/g,
rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
rsubmittable = /^(?:input|select|textarea|keygen)/i;
jQuery.fn.extend({
serialize: function () {
return jQuery.param(this.serializeArray());
},
serializeArray: function () {
return this.map(function () {
// Can add propHook for "elements" to filter or add form elements
var elements = jQuery.prop(this, "elements");
return elements ? jQuery.makeArray(elements) : this;
})
.filter(function () {
var type = this.type;
// Use .is(":disabled") so that fieldset[disabled] works
return (
this.name &&
!jQuery(this).is(":disabled") &&
rsubmittable.test(this.nodeName) &&
!rsubmitterTypes.test(type) &&
(this.checked || !manipulation_rcheckableType.test(type))
);
})
.map(function (i, elem) {
var val = jQuery(this).val();
return val == null
? null
: jQuery.isArray(val)
? jQuery.map(val, function (val) {
return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
})
: { name: elem.name, value: val.replace(rCRLF, "\r\n") };
})
.get();
},
});
//Serialize an array of form elements or a set of
//key/values into a query string
jQuery.param = function (a, traditional) {
var prefix,
s = [],
add = function (key, value) {
// If value is a function, invoke it and return its value
value = jQuery.isFunction(value) ? value() : value == null ? "" : value;
s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
};
// Set traditional to true for jQuery <= 1.3.2 behavior.
if (traditional === undefined) {
traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
}
// If an array was passed in, assume that it is an array of form elements.
if (jQuery.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {
// Serialize the form elements
jQuery.each(a, function () {
add(this.name, this.value);
});
} else {
// If traditional, encode the "old" way (the way 1.3.2 or older
// did it), otherwise encode params recursively.
for (prefix in a) {
buildParams(prefix, a[prefix], traditional, add);
}
}
// Return the resulting serialization
return s.join("&").replace(r20, "+");
};
function buildParams(prefix, obj, traditional, add) {
var name;
if (jQuery.isArray(obj)) {
// Serialize array item.
jQuery.each(obj, function (i, v) {
if (traditional || rbracket.test(prefix)) {
// Treat each array item as a scalar.
add(prefix, v);
} else {
// Item is non-scalar (array or object), encode its numeric index.
buildParams(
prefix + "[" + (typeof v === "object" ? i : "") + "]",
v,
traditional,
add,
);
}
});
} else if (!traditional && jQuery.type(obj) === "object") {
// Serialize object item.
for (name in obj) {
buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
}
} else {
// Serialize scalar item.
add(prefix, obj);
}
}
jQuery.each(
(
"blur focus focusin focusout load resize scroll unload click dblclick " +
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
"change select submit keydown keypress keyup error contextmenu"
).split(" "),
function (i, name) {
// Handle event binding
jQuery.fn[name] = function (data, fn) {
return arguments.length > 0
? this.on(name, null, data, fn)
: this.trigger(name);
};
},
);
jQuery.fn.hover = function (fnOver, fnOut) {
return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
};
var // Document location
ajaxLocParts,
ajaxLocation,
ajax_nonce = jQuery.now(),
ajax_rquery = /\?/,
rhash = /#.*$/,
rts = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/gm, // IE leaves an \r character at EOL
// #7653, #8125, #8152: local protocol detection
rlocalProtocol =
/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
// Keep a copy of the old load method
_load = jQuery.fn.load,
/* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
* - BEFORE asking for a transport
* - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/
prefilters = {},
/* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/
transports = {},
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat("*");
// #8138, IE may throw an exception when accessing
// a field from window.location if document.domain has been set
try {
ajaxLocation = location.href;
} catch (e) {
// Use the href attribute of an A element
// since IE will modify it given document.location
ajaxLocation = document.createElement("a");
ajaxLocation.href = "";
ajaxLocation = ajaxLocation.href;
}
// Segment location into parts
ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports(structure) {
// dataTypeExpression is optional and defaults to "*"
return function (dataTypeExpression, func) {
if (typeof dataTypeExpression !== "string") {
func = dataTypeExpression;
dataTypeExpression = "*";
}
var dataType,
i = 0,
dataTypes =
dataTypeExpression.toLowerCase().match(core_rnotwhite) || [];
if (jQuery.isFunction(func)) {
// For each dataType in the dataTypeExpression
while ((dataType = dataTypes[i++])) {
// Prepend if requested
if (dataType[0] === "+") {
dataType = dataType.slice(1) || "*";
(structure[dataType] = structure[dataType] || []).unshift(func);
// Otherwise append
} else {
(structure[dataType] = structure[dataType] || []).push(func);
}
}
}
};
}
// Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports(
structure,
options,
originalOptions,
jqXHR,
) {
var inspected = {},
seekingTransport = structure === transports;
function inspect(dataType) {
var selected;
inspected[dataType] = true;
jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
var dataTypeOrTransport = prefilterOrFactory(
options,
originalOptions,
jqXHR,
);
if (
typeof dataTypeOrTransport === "string" &&
!seekingTransport &&
!inspected[dataTypeOrTransport]
) {
options.dataTypes.unshift(dataTypeOrTransport);
inspect(dataTypeOrTransport);
return false;
} else if (seekingTransport) {
return !(selected = dataTypeOrTransport);
}
});
return selected;
}
return inspect(options.dataTypes[0]) || (!inspected["*"] && inspect("*"));
}
// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
function ajaxExtend(target, src) {
var deep,
key,
flatOptions = jQuery.ajaxSettings.flatOptions || {};
for (key in src) {
if (src[key] !== undefined) {
(flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
}
}
if (deep) {
jQuery.extend(true, target, deep);
}
return target;
}
jQuery.fn.load = function (url, params, callback) {
if (typeof url !== "string" && _load) {
return _load.apply(this, arguments);
}
var selector,
response,
type,
self = this,
off = url.indexOf(" ");
if (off >= 0) {
selector = url.slice(off, url.length);
url = url.slice(0, off);
}
// If it's a function
if (jQuery.isFunction(params)) {
// We assume that it's the callback
callback = params;
params = undefined;
// Otherwise, build a param string
} else if (params && typeof params === "object") {
type = "POST";
}
// If we have elements to modify, make the request
if (self.length > 0) {
jQuery
.ajax({
url: url,
// if "type" variable is undefined, then "GET" method will be used
type: type,
dataType: "html",
data: params,
})
.done(function (responseText) {
// Save response for use in complete callback
response = arguments;
self.html(
selector
? // If a selector was specified, locate the right elements in a dummy div
// Exclude scripts to avoid IE 'Permission Denied' errors
jQuery("<div>")
.append(jQuery.parseHTML(responseText))
.find(selector)
: // Otherwise use the full result
responseText,
);
})
.complete(
callback &&
function (jqXHR, status) {
self.each(
callback,
response || [jqXHR.responseText, status, jqXHR],
);
},
);
}
return this;
};
// Attach a bunch of functions for handling common AJAX events
jQuery.each(
[
"ajaxStart",
"ajaxStop",
"ajaxComplete",
"ajaxError",
"ajaxSuccess",
"ajaxSend",
],
function (i, type) {
jQuery.fn[type] = function (fn) {
return this.on(type, fn);
};
},
);
jQuery.each(["get", "post"], function (i, method) {
jQuery[method] = function (url, data, callback, type) {
// shift arguments if data argument was omitted
if (jQuery.isFunction(data)) {
type = type || callback;
callback = data;
data = undefined;
}
return jQuery.ajax({
url: url,
type: method,
dataType: type,
data: data,
success: callback,
});
};
});
jQuery.extend({
// Counter for holding the number of active queries
active: 0,
// Last-Modified header cache for next request
lastModified: {},
etag: {},
ajaxSettings: {
url: ajaxLocation,
type: "GET",
isLocal: rlocalProtocol.test(ajaxLocParts[1]),
global: true,
processData: true,
async: true,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/
accepts: {
"*": allTypes,
text: "text/plain",
html: "text/html",
xml: "application/xml, text/xml",
json: "application/json, text/javascript",
},
contents: {
xml: /xml/,
html: /html/,
json: /json/,
},
responseFields: {
xml: "responseXML",
text: "responseText",
},
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
converters: {
// Convert anything to text
"* text": window.String,
// Text to html (true = no transformation)
"text html": true,
// Evaluate text as a json expression
"text json": jQuery.parseJSON,
// Parse text as xml
"text xml": jQuery.parseXML,
},
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
flatOptions: {
url: true,
context: true,
},
},
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function (target, settings) {
return settings
? // Building a settings object
ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings)
: // Extending ajaxSettings
ajaxExtend(jQuery.ajaxSettings, target);
},
ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
ajaxTransport: addToPrefiltersOrTransports(transports),
// Main method
ajax: function (url, options) {
// If url is an object, simulate pre-1.5 signature
if (typeof url === "object") {
options = url;
url = undefined;
}
// Force options to be an object
options = options || {};
var // Cross-domain detection vars
parts,
// Loop variable
i,
// URL without anti-cache param
cacheURL,
// Response headers as string
responseHeadersString,
// timeout handle
timeoutTimer,
// To know if global events are to be dispatched
fireGlobals,
transport,
// Response headers
responseHeaders,
// Create the final options object
s = jQuery.ajaxSetup({}, options),
// Callbacks context
callbackContext = s.context || s,
// Context for global events is callbackContext if it is a DOM node or jQuery collection
globalEventContext =
s.context && (callbackContext.nodeType || callbackContext.jquery)
? jQuery(callbackContext)
: jQuery.event,
// Deferreds
deferred = jQuery.Deferred(),
completeDeferred = jQuery.Callbacks("once memory"),
// Status-dependent callbacks
statusCode = s.statusCode || {},
// Headers (they are sent all at once)
requestHeaders = {},
requestHeadersNames = {},
// The jqXHR state
state = 0,
// Default abort message
strAbort = "canceled",
// Fake xhr
jqXHR = {
readyState: 0,
// Builds headers hashtable if needed
getResponseHeader: function (key) {
var match;
if (state === 2) {
if (!responseHeaders) {
responseHeaders = {};
while ((match = rheaders.exec(responseHeadersString))) {
responseHeaders[match[1].toLowerCase()] = match[2];
}
}
match = responseHeaders[key.toLowerCase()];
}
return match == null ? null : match;
},
// Raw string
getAllResponseHeaders: function () {
return state === 2 ? responseHeadersString : null;
},
// Caches the header
setRequestHeader: function (name, value) {
var lname = name.toLowerCase();
if (!state) {
name = requestHeadersNames[lname] =
requestHeadersNames[lname] || name;
requestHeaders[name] = value;
}
return this;
},
// Overrides response content-type header
overrideMimeType: function (type) {
if (!state) {
s.mimeType = type;
}
return this;
},
// Status-dependent callbacks
statusCode: function (map) {
var code;
if (map) {
if (state < 2) {
for (code in map) {
// Lazy-add the new callback in a way that preserves old ones
statusCode[code] = [statusCode[code], map[code]];
}
} else {
// Execute the appropriate callbacks
jqXHR.always(map[jqXHR.status]);
}
}
return this;
},
// Cancel the request
abort: function (statusText) {
var finalText = statusText || strAbort;
if (transport) {
transport.abort(finalText);
}
done(0, finalText);
return this;
},
};
// Attach deferreds
deferred.promise(jqXHR).complete = completeDeferred.add;
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
// Remove hash character (#7531: and string promotion)
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
// Handle falsy url in the settings object (#10093: consistency with old signature)
// We also use the url parameter if available
s.url = ((url || s.url || ajaxLocation) + "")
.replace(rhash, "")
.replace(rprotocol, ajaxLocParts[1] + "//");
// Alias method option to type as per ticket #12004
s.type = options.method || options.type || s.method || s.type;
// Extract dataTypes list
s.dataTypes = jQuery
.trim(s.dataType || "*")
.toLowerCase()
.match(core_rnotwhite) || [""];
// A cross-domain request is in order when we have a protocol:host:port mismatch
if (s.crossDomain == null) {
parts = rurl.exec(s.url.toLowerCase());
s.crossDomain = !!(
parts &&
(parts[1] !== ajaxLocParts[1] ||
parts[2] !== ajaxLocParts[2] ||
(parts[3] || (parts[1] === "http:" ? 80 : 443)) !=
(ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? 80 : 443)))
);
}
// Convert data if not already a string
if (s.data && s.processData && typeof s.data !== "string") {
s.data = jQuery.param(s.data, s.traditional);
}
// Apply prefilters
inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
// If request was aborted inside a prefilter, stop there
if (state === 2) {
return jqXHR;
}
// We can fire global events as of now if asked to
fireGlobals = s.global;
// Watch for a new set of requests
if (fireGlobals && jQuery.active++ === 0) {
jQuery.event.trigger("ajaxStart");
}
// Uppercase the type
s.type = s.type.toUpperCase();
// Determine if request has content
s.hasContent = !rnoContent.test(s.type);
// Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
cacheURL = s.url;
// More options handling for requests with no content
if (!s.hasContent) {
// If data is available, append data to url
if (s.data) {
cacheURL = s.url += (ajax_rquery.test(cacheURL) ? "&" : "?") + s.data;
// #9682: remove data so that it's not used in an eventual retry
delete s.data;
}
// Add anti-cache in url if needed
if (s.cache === false) {
s.url = rts.test(cacheURL)
? // If there is already a '_' parameter, set its value
cacheURL.replace(rts, "$1_=" + ajax_nonce++)
: // Otherwise add one to the end
cacheURL +
(ajax_rquery.test(cacheURL) ? "&" : "?") +
"_=" +
ajax_nonce++;
}
}
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if (s.ifModified) {
if (jQuery.lastModified[cacheURL]) {
jqXHR.setRequestHeader(
"If-Modified-Since",
jQuery.lastModified[cacheURL],
);
}
if (jQuery.etag[cacheURL]) {
jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
}
}
// Set the correct header, if data is being sent
if (
(s.data && s.hasContent && s.contentType !== false) ||
options.contentType
) {
jqXHR.setRequestHeader("Content-Type", s.contentType);
}
// Set the Accepts header for the server, depending on the dataType
jqXHR.setRequestHeader(
"Accept",
s.dataTypes[0] && s.accepts[s.dataTypes[0]]
? s.accepts[s.dataTypes[0]] +
(s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "")
: s.accepts["*"],
);
// Check for headers option
for (i in s.headers) {
jqXHR.setRequestHeader(i, s.headers[i]);
}
// Allow custom headers/mimetypes and early abort
if (
s.beforeSend &&
(s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)
) {
// Abort if not done already and return
return jqXHR.abort();
}
// aborting is no longer a cancellation
strAbort = "abort";
// Install callbacks on deferreds
for (i in { success: 1, error: 1, complete: 1 }) {
jqXHR[i](s[i]);
}
// Get transport
transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
// If no transport, we auto-abort
if (!transport) {
done(-1, "No Transport");
} else {
jqXHR.readyState = 1;
// Send global event
if (fireGlobals) {
globalEventContext.trigger("ajaxSend", [jqXHR, s]);
}
// Timeout
if (s.async && s.timeout > 0) {
timeoutTimer = setTimeout(function () {
jqXHR.abort("timeout");
}, s.timeout);
}
try {
state = 1;
transport.send(requestHeaders, done);
} catch (e) {
// Propagate exception as error if not done
if (state < 2) {
done(-1, e);
// Simply rethrow otherwise
} else {
throw e;
}
}
}
// Callback for when everything is done
function done(status, nativeStatusText, responses, headers) {
var isSuccess,
success,
error,
response,
modified,
statusText = nativeStatusText;
// Called once
if (state === 2) {
return;
}
// State is "done" now
state = 2;
// Clear timeout if it exists
if (timeoutTimer) {
clearTimeout(timeoutTimer);
}
// Dereference transport for early garbage collection
// (no matter how long the jqXHR object will be used)
transport = undefined;
// Cache response headers
responseHeadersString = headers || "";
// Set readyState
jqXHR.readyState = status > 0 ? 4 : 0;
// Get response data
if (responses) {
response = ajaxHandleResponses(s, jqXHR, responses);
}
// If successful, handle type chaining
if ((status >= 200 && status < 300) || status === 304) {
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if (s.ifModified) {
modified = jqXHR.getResponseHeader("Last-Modified");
if (modified) {
jQuery.lastModified[cacheURL] = modified;
}
modified = jqXHR.getResponseHeader("etag");
if (modified) {
jQuery.etag[cacheURL] = modified;
}
}
// if no content
if (status === 204) {
isSuccess = true;
statusText = "nocontent";
// if not modified
} else if (status === 304) {
isSuccess = true;
statusText = "notmodified";
// If we have data, let's convert it
} else {
isSuccess = ajaxConvert(s, response);
statusText = isSuccess.state;
success = isSuccess.data;
error = isSuccess.error;
isSuccess = !error;
}
} else {
// We extract error from statusText
// then normalize statusText and status for non-aborts
error = statusText;
if (status || !statusText) {
statusText = "error";
if (status < 0) {
status = 0;
}
}
}
// Set data for the fake xhr object
jqXHR.status = status;
jqXHR.statusText = (nativeStatusText || statusText) + "";
// Success/Error
if (isSuccess) {
deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
} else {
deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
}
// Status-dependent callbacks
jqXHR.statusCode(statusCode);
statusCode = undefined;
if (fireGlobals) {
globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [
jqXHR,
s,
isSuccess ? success : error,
]);
}
// Complete
completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
if (fireGlobals) {
globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
// Handle the global AJAX counter
if (!--jQuery.active) {
jQuery.event.trigger("ajaxStop");
}
}
}
return jqXHR;
},
getScript: function (url, callback) {
return jQuery.get(url, undefined, callback, "script");
},
getJSON: function (url, data, callback) {
return jQuery.get(url, data, callback, "json");
},
});
/* Handles responses to an ajax request:
* - sets all responseXXX fields accordingly
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/
function ajaxHandleResponses(s, jqXHR, responses) {
var firstDataType,
ct,
finalDataType,
type,
contents = s.contents,
dataTypes = s.dataTypes,
responseFields = s.responseFields;
// Fill responseXXX fields
for (type in responseFields) {
if (type in responses) {
jqXHR[responseFields[type]] = responses[type];
}
}
// Remove auto dataType and get content-type in the process
while (dataTypes[0] === "*") {
dataTypes.shift();
if (ct === undefined) {
ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
}
}
// Check if we're dealing with a known content-type
if (ct) {
for (type in contents) {
if (contents[type] && contents[type].test(ct)) {
dataTypes.unshift(type);
break;
}
}
}
// Check to see if we have a response for the expected dataType
if (dataTypes[0] in responses) {
finalDataType = dataTypes[0];
} else {
// Try convertible dataTypes
for (type in responses) {
if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
finalDataType = type;
break;
}
if (!firstDataType) {
firstDataType = type;
}
}
// Or just use first one
finalDataType = finalDataType || firstDataType;
}
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if (finalDataType) {
if (finalDataType !== dataTypes[0]) {
dataTypes.unshift(finalDataType);
}
return responses[finalDataType];
}
}
// Chain conversions given the request and the original response
function ajaxConvert(s, response) {
var conv2,
current,
conv,
tmp,
converters = {},
i = 0,
// Work with a copy of dataTypes in case we need to modify it for conversion
dataTypes = s.dataTypes.slice(),
prev = dataTypes[0];
// Apply the dataFilter if provided
if (s.dataFilter) {
response = s.dataFilter(response, s.dataType);
}
// Create converters map with lowercased keys
if (dataTypes[1]) {
for (conv in s.converters) {
converters[conv.toLowerCase()] = s.converters[conv];
}
}
// Convert to each sequential dataType, tolerating list modification
for (; (current = dataTypes[++i]); ) {
// There's only work to do if current dataType is non-auto
if (current !== "*") {
// Convert response if prev dataType is non-auto and differs from current
if (prev !== "*" && prev !== current) {
// Seek a direct converter
conv = converters[prev + " " + current] || converters["* " + current];
// If none found, seek a pair
if (!conv) {
for (conv2 in converters) {
// If conv2 outputs current
tmp = conv2.split(" ");
if (tmp[1] === current) {
// If prev can be converted to accepted input
conv =
converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
if (conv) {
// Condense equivalence converters
if (conv === true) {
conv = converters[conv2];
// Otherwise, insert the intermediate dataType
} else if (converters[conv2] !== true) {
current = tmp[0];
dataTypes.splice(i--, 0, current);
}
break;
}
}
}
}
// Apply converter (if not an equivalence)
if (conv !== true) {
// Unless errors are allowed to bubble, catch and return them
if (conv && s["throws"]) {
response = conv(response);
} else {
try {
response = conv(response);
} catch (e) {
return {
state: "parsererror",
error: conv
? e
: "No conversion from " + prev + " to " + current,
};
}
}
}
}
// Update prev for next iteration
prev = current;
}
}
return { state: "success", data: response };
}
// Install script dataType
jQuery.ajaxSetup({
accepts: {
script:
"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript",
},
contents: {
script: /(?:java|ecma)script/,
},
converters: {
"text script": function (text) {
jQuery.globalEval(text);
return text;
},
},
});
// Handle cache's special case and global
jQuery.ajaxPrefilter("script", function (s) {
if (s.cache === undefined) {
s.cache = false;
}
if (s.crossDomain) {
s.type = "GET";
s.global = false;
}
});
// Bind script tag hack transport
jQuery.ajaxTransport("script", function (s) {
// This transport only deals with cross domain requests
if (s.crossDomain) {
var script,
head = document.head || jQuery("head")[0] || document.documentElement;
return {
send: function (_, callback) {
script = document.createElement("script");
script.async = true;
if (s.scriptCharset) {
script.charset = s.scriptCharset;
}
script.src = s.url;
// Attach handlers for all browsers
script.onload = script.onreadystatechange = function (_, isAbort) {
if (
isAbort ||
!script.readyState ||
/loaded|complete/.test(script.readyState)
) {
// Handle memory leak in IE
script.onload = script.onreadystatechange = null;
// Remove the script
if (script.parentNode) {
script.parentNode.removeChild(script);
}
// Dereference the script
script = null;
// Callback if not abort
if (!isAbort) {
callback(200, "success");
}
}
};
// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
// Use native DOM manipulation to avoid our domManip AJAX trickery
head.insertBefore(script, head.firstChild);
},
abort: function () {
if (script) {
script.onload(undefined, true);
}
},
};
}
});
var oldCallbacks = [],
rjsonp = /(=)\?(?=&|$)|\?\?/;
// Default jsonp settings
jQuery.ajaxSetup({
jsonp: "callback",
jsonpCallback: function () {
var callback = oldCallbacks.pop() || jQuery.expando + "_" + ajax_nonce++;
this[callback] = true;
return callback;
},
});
// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {
var callbackName,
overwritten,
responseContainer,
jsonProp =
s.jsonp !== false &&
(rjsonp.test(s.url)
? "url"
: typeof s.data === "string" &&
!(s.contentType || "").indexOf(
"application/x-www-form-urlencoded",
) &&
rjsonp.test(s.data) &&
"data");
// Handle iff the expected data type is "jsonp" or we have a parameter to set
if (jsonProp || s.dataTypes[0] === "jsonp") {
// Get callback name, remembering preexisting value associated with it
callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback)
? s.jsonpCallback()
: s.jsonpCallback;
// Insert callback into url or form data
if (jsonProp) {
s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
} else if (s.jsonp !== false) {
s.url +=
(ajax_rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
}
// Use data converter to retrieve json after script execution
s.converters["script json"] = function () {
if (!responseContainer) {
jQuery.error(callbackName + " was not called");
}
return responseContainer[0];
};
// force json dataType
s.dataTypes[0] = "json";
// Install callback
overwritten = window[callbackName];
window[callbackName] = function () {
responseContainer = arguments;
};
// Clean-up function (fires after converters)
jqXHR.always(function () {
// Restore preexisting value
window[callbackName] = overwritten;
// Save back as free
if (s[callbackName]) {
// make sure that re-using the options doesn't screw things around
s.jsonpCallback = originalSettings.jsonpCallback;
// save the callback name for future use
oldCallbacks.push(callbackName);
}
// Call if it was a function and we have a response
if (responseContainer && jQuery.isFunction(overwritten)) {
overwritten(responseContainer[0]);
}
responseContainer = overwritten = undefined;
});
// Delegate to script
return "script";
}
});
var xhrCallbacks,
xhrSupported,
xhrId = 0,
// #5280: Internet Explorer will keep connections alive if we don't abort on unload
xhrOnUnloadAbort =
window.ActiveXObject &&
function () {
// Abort all pending requests
var key;
for (key in xhrCallbacks) {
xhrCallbacks[key](undefined, true);
}
};
// Functions to create xhrs
function createStandardXHR() {
try {
return new window.XMLHttpRequest();
} catch (e) {}
}
function createActiveXHR() {
try {
return new window.ActiveXObject("Microsoft.XMLHTTP");
} catch (e) {}
}
// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window.ActiveXObject
? /* Microsoft failed to properly
* implement the XMLHttpRequest in IE7 (can't request local files),
* so we use the ActiveXObject when it is available
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
* we need a fallback.
*/
function () {
return (!this.isLocal && createStandardXHR()) || createActiveXHR();
}
: // For all other browsers, use the standard XMLHttpRequest object
createStandardXHR;
// Determine support properties
xhrSupported = jQuery.ajaxSettings.xhr();
jQuery.support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
xhrSupported = jQuery.support.ajax = !!xhrSupported;
// Create transport if the browser can provide an xhr
if (xhrSupported) {
jQuery.ajaxTransport(function (s) {
// Cross domain only allowed if supported through XMLHttpRequest
if (!s.crossDomain || jQuery.support.cors) {
var callback;
return {
send: function (headers, complete) {
// Get a new xhr
var handle,
i,
xhr = s.xhr();
// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if (s.username) {
xhr.open(s.type, s.url, s.async, s.username, s.password);
} else {
xhr.open(s.type, s.url, s.async);
}
// Apply custom fields if provided
if (s.xhrFields) {
for (i in s.xhrFields) {
xhr[i] = s.xhrFields[i];
}
}
// Override mime type if needed
if (s.mimeType && xhr.overrideMimeType) {
xhr.overrideMimeType(s.mimeType);
}
// X-Requested-With header
// For cross-domain requests, seeing as conditions for a preflight are
// akin to a jigsaw puzzle, we simply never set it to be sure.
// (it can always be set on a per-request basis or even using ajaxSetup)
// For same-domain requests, won't change header if already provided.
if (!s.crossDomain && !headers["X-Requested-With"]) {
headers["X-Requested-With"] = "XMLHttpRequest";
}
// Need an extra try/catch for cross domain requests in Firefox 3
try {
for (i in headers) {
xhr.setRequestHeader(i, headers[i]);
}
} catch (err) {}
// Do send the request
// This may raise an exception which is actually
// handled in jQuery.ajax (so no try/catch here)
xhr.send((s.hasContent && s.data) || null);
// Listener
callback = function (_, isAbort) {
var status, responseHeaders, statusText, responses;
// Firefox throws exceptions when accessing properties
// of an xhr when a network error occurred
// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
try {
// Was never called and is aborted or complete
if (callback && (isAbort || xhr.readyState === 4)) {
// Only called once
callback = undefined;
// Do not keep as active anymore
if (handle) {
xhr.onreadystatechange = jQuery.noop;
if (xhrOnUnloadAbort) {
delete xhrCallbacks[handle];
}
}
// If it's an abort
if (isAbort) {
// Abort it manually if needed
if (xhr.readyState !== 4) {
xhr.abort();
}
} else {
responses = {};
status = xhr.status;
responseHeaders = xhr.getAllResponseHeaders();
// When requesting binary data, IE6-9 will throw an exception
// on any attempt to access responseText (#11426)
if (typeof xhr.responseText === "string") {
responses.text = xhr.responseText;
}
// Firefox throws an exception when accessing
// statusText for faulty cross-domain requests
try {
statusText = xhr.statusText;
} catch (e) {
// We normalize with Webkit giving an empty statusText
statusText = "";
}
// Filter status for non standard behaviors
// If the request is local and we have data: assume a success
// (success with no data won't get notified, that's the best we
// can do given current implementations)
if (!status && s.isLocal && !s.crossDomain) {
status = responses.text ? 200 : 404;
// IE - #1450: sometimes returns 1223 when it should be 204
} else if (status === 1223) {
status = 204;
}
}
}
} catch (firefoxAccessException) {
if (!isAbort) {
complete(-1, firefoxAccessException);
}
}
// Call complete if needed
if (responses) {
complete(status, statusText, responses, responseHeaders);
}
};
if (!s.async) {
// if we're in sync mode we fire the callback
callback();
} else if (xhr.readyState === 4) {
// (IE6 & IE7) if it's in cache and has been
// retrieved directly we need to fire the callback
setTimeout(callback);
} else {
handle = ++xhrId;
if (xhrOnUnloadAbort) {
// Create the active xhrs callbacks list if needed
// and attach the unload handler
if (!xhrCallbacks) {
xhrCallbacks = {};
jQuery(window).unload(xhrOnUnloadAbort);
}
// Add to list of active xhrs callbacks
xhrCallbacks[handle] = callback;
}
xhr.onreadystatechange = callback;
}
},
abort: function () {
if (callback) {
callback(undefined, true);
}
},
};
}
});
}
var fxNow,
timerId,
rfxtypes = /^(?:toggle|show|hide)$/,
rfxnum = new RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i"),
rrun = /queueHooks$/,
animationPrefilters = [defaultPrefilter],
tweeners = {
"*": [
function (prop, value) {
var end,
unit,
tween = this.createTween(prop, value),
parts = rfxnum.exec(value),
target = tween.cur(),
start = +target || 0,
scale = 1,
maxIterations = 20;
if (parts) {
end = +parts[2];
unit = parts[3] || (jQuery.cssNumber[prop] ? "" : "px");
// We need to compute starting value
if (unit !== "px" && start) {
// Iteratively approximate from a nonzero starting point
// Prefer the current property, because this process will be trivial if it uses the same units
// Fallback to end or a simple constant
start = jQuery.css(tween.elem, prop, true) || end || 1;
do {
// If previous iteration zeroed out, double until we get *something*
// Use a string for doubling factor so we don't accidentally see scale as unchanged below
scale = scale || ".5";
// Adjust and apply
start = start / scale;
jQuery.style(tween.elem, prop, start + unit);
// Update scale, tolerating zero or NaN from tween.cur()
// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
} while (
scale !== (scale = tween.cur() / target) &&
scale !== 1 &&
--maxIterations
);
}
tween.unit = unit;
tween.start = start;
// If a +=/-= token was provided, we're doing a relative animation
tween.end = parts[1] ? start + (parts[1] + 1) * end : end;
}
return tween;
},
],
};
// Animations created synchronously will run synchronously
function createFxNow() {
setTimeout(function () {
fxNow = undefined;
});
return (fxNow = jQuery.now());
}
function createTweens(animation, props) {
jQuery.each(props, function (prop, value) {
var collection = (tweeners[prop] || []).concat(tweeners["*"]),
index = 0,
length = collection.length;
for (; index < length; index++) {
if (collection[index].call(animation, prop, value)) {
// we're done with this property
return;
}
}
});
}
function Animation(elem, properties, options) {
var result,
stopped,
index = 0,
length = animationPrefilters.length,
deferred = jQuery.Deferred().always(function () {
// don't match elem in the :animated selector
delete tick.elem;
}),
tick = function () {
if (stopped) {
return false;
}
var currentTime = fxNow || createFxNow(),
remaining = Math.max(
0,
animation.startTime + animation.duration - currentTime,
),
// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
temp = remaining / animation.duration || 0,
percent = 1 - temp,
index = 0,
length = animation.tweens.length;
for (; index < length; index++) {
animation.tweens[index].run(percent);
}
deferred.notifyWith(elem, [animation, percent, remaining]);
if (percent < 1 && length) {
return remaining;
} else {
deferred.resolveWith(elem, [animation]);
return false;
}
},
animation = deferred.promise({
elem: elem,
props: jQuery.extend({}, properties),
opts: jQuery.extend(true, { specialEasing: {} }, options),
originalProperties: properties,
originalOptions: options,
startTime: fxNow || createFxNow(),
duration: options.duration,
tweens: [],
createTween: function (prop, end) {
var tween = jQuery.Tween(
elem,
animation.opts,
prop,
end,
animation.opts.specialEasing[prop] || animation.opts.easing,
);
animation.tweens.push(tween);
return tween;
},
stop: function (gotoEnd) {
var index = 0,
// if we are going to the end, we want to run all the tweens
// otherwise we skip this part
length = gotoEnd ? animation.tweens.length : 0;
if (stopped) {
return this;
}
stopped = true;
for (; index < length; index++) {
animation.tweens[index].run(1);
}
// resolve when we played the last frame
// otherwise, reject
if (gotoEnd) {
deferred.resolveWith(elem, [animation, gotoEnd]);
} else {
deferred.rejectWith(elem, [animation, gotoEnd]);
}
return this;
},
}),
props = animation.props;
propFilter(props, animation.opts.specialEasing);
for (; index < length; index++) {
result = animationPrefilters[index].call(
animation,
elem,
props,
animation.opts,
);
if (result) {
return result;
}
}
createTweens(animation, props);
if (jQuery.isFunction(animation.opts.start)) {
animation.opts.start.call(elem, animation);
}
jQuery.fx.timer(
jQuery.extend(tick, {
elem: elem,
anim: animation,
queue: animation.opts.queue,
}),
);
// attach callbacks from options
return animation
.progress(animation.opts.progress)
.done(animation.opts.done, animation.opts.complete)
.fail(animation.opts.fail)
.always(animation.opts.always);
}
function propFilter(props, specialEasing) {
var value, name, index, easing, hooks;
// camelCase, specialEasing and expand cssHook pass
for (index in props) {
name = jQuery.camelCase(index);
easing = specialEasing[name];
value = props[index];
if (jQuery.isArray(value)) {
easing = value[1];
value = props[index] = value[0];
}
if (index !== name) {
props[name] = value;
delete props[index];
}
hooks = jQuery.cssHooks[name];
if (hooks && "expand" in hooks) {
value = hooks.expand(value);
delete props[name];
// not quite $.extend, this wont overwrite keys already present.
// also - reusing 'index' from above because we have the correct "name"
for (index in value) {
if (!(index in props)) {
props[index] = value[index];
specialEasing[index] = easing;
}
}
} else {
specialEasing[name] = easing;
}
}
}
jQuery.Animation = jQuery.extend(Animation, {
tweener: function (props, callback) {
if (jQuery.isFunction(props)) {
callback = props;
props = ["*"];
} else {
props = props.split(" ");
}
var prop,
index = 0,
length = props.length;
for (; index < length; index++) {
prop = props[index];
tweeners[prop] = tweeners[prop] || [];
tweeners[prop].unshift(callback);
}
},
prefilter: function (callback, prepend) {
if (prepend) {
animationPrefilters.unshift(callback);
} else {
animationPrefilters.push(callback);
}
},
});
function defaultPrefilter(elem, props, opts) {
/*jshint validthis:true */
var prop,
index,
length,
value,
dataShow,
toggle,
tween,
hooks,
oldfire,
anim = this,
style = elem.style,
orig = {},
handled = [],
hidden = elem.nodeType && isHidden(elem);
// handle queue: false promises
if (!opts.queue) {
hooks = jQuery._queueHooks(elem, "fx");
if (hooks.unqueued == null) {
hooks.unqueued = 0;
oldfire = hooks.empty.fire;
hooks.empty.fire = function () {
if (!hooks.unqueued) {
oldfire();
}
};
}
hooks.unqueued++;
anim.always(function () {
// doing this makes sure that the complete handler will be called
// before this completes
anim.always(function () {
hooks.unqueued--;
if (!jQuery.queue(elem, "fx").length) {
hooks.empty.fire();
}
});
});
}
// height/width overflow pass
if (elem.nodeType === 1 && ("height" in props || "width" in props)) {
// Make sure that nothing sneaks out
// Record all 3 overflow attributes because IE does not
// change the overflow attribute when overflowX and
// overflowY are set to the same value
opts.overflow = [style.overflow, style.overflowX, style.overflowY];
// Set display property to inline-block for height/width
// animations on inline elements that are having width/height animated
if (
jQuery.css(elem, "display") === "inline" &&
jQuery.css(elem, "float") === "none"
) {
// inline-level elements accept inline-block;
// block-level elements need to be inline with layout
if (
!jQuery.support.inlineBlockNeedsLayout ||
css_defaultDisplay(elem.nodeName) === "inline"
) {
style.display = "inline-block";
} else {
style.zoom = 1;
}
}
}
if (opts.overflow) {
style.overflow = "hidden";
if (!jQuery.support.shrinkWrapBlocks) {
anim.always(function () {
style.overflow = opts.overflow[0];
style.overflowX = opts.overflow[1];
style.overflowY = opts.overflow[2];
});
}
}
// show/hide pass
for (index in props) {
value = props[index];
if (rfxtypes.exec(value)) {
delete props[index];
toggle = toggle || value === "toggle";
if (value === (hidden ? "hide" : "show")) {
continue;
}
handled.push(index);
}
}
length = handled.length;
if (length) {
dataShow =
jQuery._data(elem, "fxshow") || jQuery._data(elem, "fxshow", {});
if ("hidden" in dataShow) {
hidden = dataShow.hidden;
}
// store state if its toggle - enables .stop().toggle() to "reverse"
if (toggle) {
dataShow.hidden = !hidden;
}
if (hidden) {
jQuery(elem).show();
} else {
anim.done(function () {
jQuery(elem).hide();
});
}
anim.done(function () {
var prop;
jQuery._removeData(elem, "fxshow");
for (prop in orig) {
jQuery.style(elem, prop, orig[prop]);
}
});
for (index = 0; index < length; index++) {
prop = handled[index];
tween = anim.createTween(prop, hidden ? dataShow[prop] : 0);
orig[prop] = dataShow[prop] || jQuery.style(elem, prop);
if (!(prop in dataShow)) {
dataShow[prop] = tween.start;
if (hidden) {
tween.end = tween.start;
tween.start = prop === "width" || prop === "height" ? 1 : 0;
}
}
}
}
}
function Tween(elem, options, prop, end, easing) {
return new Tween.prototype.init(elem, options, prop, end, easing);
}
jQuery.Tween = Tween;
Tween.prototype = {
constructor: Tween,
init: function (elem, options, prop, end, easing, unit) {
this.elem = elem;
this.prop = prop;
this.easing = easing || "swing";
this.options = options;
this.start = this.now = this.cur();
this.end = end;
this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
},
cur: function () {
var hooks = Tween.propHooks[this.prop];
return hooks && hooks.get
? hooks.get(this)
: Tween.propHooks._default.get(this);
},
run: function (percent) {
var eased,
hooks = Tween.propHooks[this.prop];
if (this.options.duration) {
this.pos = eased = jQuery.easing[this.easing](
percent,
this.options.duration * percent,
0,
1,
this.options.duration,
);
} else {
this.pos = eased = percent;
}
this.now = (this.end - this.start) * eased + this.start;
if (this.options.step) {
this.options.step.call(this.elem, this.now, this);
}
if (hooks && hooks.set) {
hooks.set(this);
} else {
Tween.propHooks._default.set(this);
}
return this;
},
};
Tween.prototype.init.prototype = Tween.prototype;
Tween.propHooks = {
_default: {
get: function (tween) {
var result;
if (
tween.elem[tween.prop] != null &&
(!tween.elem.style || tween.elem.style[tween.prop] == null)
) {
return tween.elem[tween.prop];
}
// passing an empty string as a 3rd parameter to .css will automatically
// attempt a parseFloat and fallback to a string if the parse fails
// so, simple values such as "10px" are parsed to Float.
// complex values such as "rotate(1rad)" are returned as is.
result = jQuery.css(tween.elem, tween.prop, "");
// Empty strings, null, undefined and "auto" are converted to 0.
return !result || result === "auto" ? 0 : result;
},
set: function (tween) {
// use step hook for back compat - use cssHook if its there - use .style if its
// available and use plain properties where available
if (jQuery.fx.step[tween.prop]) {
jQuery.fx.step[tween.prop](tween);
} else if (
tween.elem.style &&
(tween.elem.style[jQuery.cssProps[tween.prop]] != null ||
jQuery.cssHooks[tween.prop])
) {
jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
} else {
tween.elem[tween.prop] = tween.now;
}
},
},
};
// Remove in 2.0 - this supports IE8's panic based approach
// to setting things on disconnected nodes
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
set: function (tween) {
if (tween.elem.nodeType && tween.elem.parentNode) {
tween.elem[tween.prop] = tween.now;
}
},
};
jQuery.each(["toggle", "show", "hide"], function (i, name) {
var cssFn = jQuery.fn[name];
jQuery.fn[name] = function (speed, easing, callback) {
return speed == null || typeof speed === "boolean"
? cssFn.apply(this, arguments)
: this.animate(genFx(name, true), speed, easing, callback);
};
});
jQuery.fn.extend({
fadeTo: function (speed, to, easing, callback) {
// show any hidden elements after setting opacity to 0
return (
this.filter(isHidden)
.css("opacity", 0)
.show()
// animate to the value specified
.end()
.animate({ opacity: to }, speed, easing, callback)
);
},
animate: function (prop, speed, easing, callback) {
var empty = jQuery.isEmptyObject(prop),
optall = jQuery.speed(speed, easing, callback),
doAnimation = function () {
// Operate on a copy of prop so per-property easing won't be lost
var anim = Animation(this, jQuery.extend({}, prop), optall);
doAnimation.finish = function () {
anim.stop(true);
};
// Empty animations, or finishing resolves immediately
if (empty || jQuery._data(this, "finish")) {
anim.stop(true);
}
};
doAnimation.finish = doAnimation;
return empty || optall.queue === false
? this.each(doAnimation)
: this.queue(optall.queue, doAnimation);
},
stop: function (type, clearQueue, gotoEnd) {
var stopQueue = function (hooks) {
var stop = hooks.stop;
delete hooks.stop;
stop(gotoEnd);
};
if (typeof type !== "string") {
gotoEnd = clearQueue;
clearQueue = type;
type = undefined;
}
if (clearQueue && type !== false) {
this.queue(type || "fx", []);
}
return this.each(function () {
var dequeue = true,
index = type != null && type + "queueHooks",
timers = jQuery.timers,
data = jQuery._data(this);
if (index) {
if (data[index] && data[index].stop) {
stopQueue(data[index]);
}
} else {
for (index in data) {
if (data[index] && data[index].stop && rrun.test(index)) {
stopQueue(data[index]);
}
}
}
for (index = timers.length; index--; ) {
if (
timers[index].elem === this &&
(type == null || timers[index].queue === type)
) {
timers[index].anim.stop(gotoEnd);
dequeue = false;
timers.splice(index, 1);
}
}
// start the next in the queue if the last step wasn't forced
// timers currently will call their complete callbacks, which will dequeue
// but only if they were gotoEnd
if (dequeue || !gotoEnd) {
jQuery.dequeue(this, type);
}
});
},
finish: function (type) {
if (type !== false) {
type = type || "fx";
}
return this.each(function () {
var index,
data = jQuery._data(this),
queue = data[type + "queue"],
hooks = data[type + "queueHooks"],
timers = jQuery.timers,
length = queue ? queue.length : 0;
// enable finishing flag on private data
data.finish = true;
// empty the queue first
jQuery.queue(this, type, []);
if (hooks && hooks.cur && hooks.cur.finish) {
hooks.cur.finish.call(this);
}
// look for any active animations, and finish them
for (index = timers.length; index--; ) {
if (timers[index].elem === this && timers[index].queue === type) {
timers[index].anim.stop(true);
timers.splice(index, 1);
}
}
// look for any animations in the old queue and finish them
for (index = 0; index < length; index++) {
if (queue[index] && queue[index].finish) {
queue[index].finish.call(this);
}
}
// turn off finishing flag
delete data.finish;
});
},
});
// Generate parameters to create a standard animation
function genFx(type, includeWidth) {
var which,
attrs = { height: type },
i = 0;
// if we include width, step value is 1 to do all cssExpand values,
// if we don't include width, step value is 2 to skip over Left and Right
includeWidth = includeWidth ? 1 : 0;
for (; i < 4; i += 2 - includeWidth) {
which = cssExpand[i];
attrs["margin" + which] = attrs["padding" + which] = type;
}
if (includeWidth) {
attrs.opacity = attrs.width = type;
}
return attrs;
}
// Generate shortcuts for custom animations
jQuery.each(
{
slideDown: genFx("show"),
slideUp: genFx("hide"),
slideToggle: genFx("toggle"),
fadeIn: { opacity: "show" },
fadeOut: { opacity: "hide" },
fadeToggle: { opacity: "toggle" },
},
function (name, props) {
jQuery.fn[name] = function (speed, easing, callback) {
return this.animate(props, speed, easing, callback);
};
},
);
jQuery.speed = function (speed, easing, fn) {
var opt =
speed && typeof speed === "object"
? jQuery.extend({}, speed)
: {
complete:
fn || (!fn && easing) || (jQuery.isFunction(speed) && speed),
duration: speed,
easing:
(fn && easing) ||
(easing && !jQuery.isFunction(easing) && easing),
};
opt.duration = jQuery.fx.off
? 0
: typeof opt.duration === "number"
? opt.duration
: opt.duration in jQuery.fx.speeds
? jQuery.fx.speeds[opt.duration]
: jQuery.fx.speeds._default;
// normalize opt.queue - true/undefined/null -> "fx"
if (opt.queue == null || opt.queue === true) {
opt.queue = "fx";
}
// Queueing
opt.old = opt.complete;
opt.complete = function () {
if (jQuery.isFunction(opt.old)) {
opt.old.call(this);
}
if (opt.queue) {
jQuery.dequeue(this, opt.queue);
}
};
return opt;
};
jQuery.easing = {
linear: function (p) {
return p;
},
swing: function (p) {
return 0.5 - Math.cos(p * Math.PI) / 2;
},
};
jQuery.timers = [];
jQuery.fx = Tween.prototype.init;
jQuery.fx.tick = function () {
var timer,
timers = jQuery.timers,
i = 0;
fxNow = jQuery.now();
for (; i < timers.length; i++) {
timer = timers[i];
// Checks the timer has not already been removed
if (!timer() && timers[i] === timer) {
timers.splice(i--, 1);
}
}
if (!timers.length) {
jQuery.fx.stop();
}
fxNow = undefined;
};
jQuery.fx.timer = function (timer) {
if (timer() && jQuery.timers.push(timer)) {
jQuery.fx.start();
}
};
jQuery.fx.interval = 13;
jQuery.fx.start = function () {
if (!timerId) {
timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval);
}
};
jQuery.fx.stop = function () {
clearInterval(timerId);
timerId = null;
};
jQuery.fx.speeds = {
slow: 600,
fast: 200,
// Default speed
_default: 400,
};
// Back Compat <1.8 extension point
jQuery.fx.step = {};
if (jQuery.expr && jQuery.expr.filters) {
jQuery.expr.filters.animated = function (elem) {
return jQuery.grep(jQuery.timers, function (fn) {
return elem === fn.elem;
}).length;
};
}
jQuery.fn.offset = function (options) {
if (arguments.length) {
return options === undefined
? this
: this.each(function (i) {
jQuery.offset.setOffset(this, options, i);
});
}
var docElem,
win,
box = { top: 0, left: 0 },
elem = this[0],
doc = elem && elem.ownerDocument;
if (!doc) {
return;
}
docElem = doc.documentElement;
// Make sure it's not a disconnected DOM node
if (!jQuery.contains(docElem, elem)) {
return box;
}
// If we don't have gBCR, just use 0,0 rather than error
// BlackBerry 5, iOS 3 (original iPhone)
if (typeof elem.getBoundingClientRect !== core_strundefined) {
box = elem.getBoundingClientRect();
}
win = getWindow(doc);
return {
top:
box.top +
(win.pageYOffset || docElem.scrollTop) -
(docElem.clientTop || 0),
left:
box.left +
(win.pageXOffset || docElem.scrollLeft) -
(docElem.clientLeft || 0),
};
};
jQuery.offset = {
setOffset: function (elem, options, i) {
var position = jQuery.css(elem, "position");
// set position first, in-case top/left are set even on static elem
if (position === "static") {
elem.style.position = "relative";
}
var curElem = jQuery(elem),
curOffset = curElem.offset(),
curCSSTop = jQuery.css(elem, "top"),
curCSSLeft = jQuery.css(elem, "left"),
calculatePosition =
(position === "absolute" || position === "fixed") &&
jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
props = {},
curPosition = {},
curTop,
curLeft;
// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
if (calculatePosition) {
curPosition = curElem.position();
curTop = curPosition.top;
curLeft = curPosition.left;
} else {
curTop = parseFloat(curCSSTop) || 0;
curLeft = parseFloat(curCSSLeft) || 0;
}
if (jQuery.isFunction(options)) {
options = options.call(elem, i, curOffset);
}
if (options.top != null) {
props.top = options.top - curOffset.top + curTop;
}
if (options.left != null) {
props.left = options.left - curOffset.left + curLeft;
}
if ("using" in options) {
options.using.call(elem, props);
} else {
curElem.css(props);
}
},
};
jQuery.fn.extend({
position: function () {
if (!this[0]) {
return;
}
var offsetParent,
offset,
parentOffset = { top: 0, left: 0 },
elem = this[0];
// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
if (jQuery.css(elem, "position") === "fixed") {
// we assume that getBoundingClientRect is available when computed position is fixed
offset = elem.getBoundingClientRect();
} else {
// Get *real* offsetParent
offsetParent = this.offsetParent();
// Get correct offsets
offset = this.offset();
if (!jQuery.nodeName(offsetParent[0], "html")) {
parentOffset = offsetParent.offset();
}
// Add offsetParent borders
parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true);
parentOffset.left += jQuery.css(
offsetParent[0],
"borderLeftWidth",
true,
);
}
// Subtract parent offsets and element margins
// note: when an element has margin: auto the offsetLeft and marginLeft
// are the same in Safari causing offset.left to incorrectly be 0
return {
top:
offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
left:
offset.left -
parentOffset.left -
jQuery.css(elem, "marginLeft", true),
};
},
offsetParent: function () {
return this.map(function () {
var offsetParent = this.offsetParent || document.documentElement;
while (
offsetParent &&
!jQuery.nodeName(offsetParent, "html") &&
jQuery.css(offsetParent, "position") === "static"
) {
offsetParent = offsetParent.offsetParent;
}
return offsetParent || document.documentElement;
});
},
});
// Create scrollLeft and scrollTop methods
jQuery.each(
{ scrollLeft: "pageXOffset", scrollTop: "pageYOffset" },
function (method, prop) {
var top = /Y/.test(prop);
jQuery.fn[method] = function (val) {
return jQuery.access(
this,
function (elem, method, val) {
var win = getWindow(elem);
if (val === undefined) {
return win
? prop in win
? win[prop]
: win.document.documentElement[method]
: elem[method];
}
if (win) {
win.scrollTo(
!top ? val : jQuery(win).scrollLeft(),
top ? val : jQuery(win).scrollTop(),
);
} else {
elem[method] = val;
}
},
method,
val,
arguments.length,
null,
);
};
},
);
function getWindow(elem) {
return jQuery.isWindow(elem)
? elem
: elem.nodeType === 9
? elem.defaultView || elem.parentWindow
: false;
}
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
jQuery.each({ Height: "height", Width: "width" }, function (name, type) {
jQuery.each(
{ padding: "inner" + name, content: type, "": "outer" + name },
function (defaultExtra, funcName) {
// margin is only for outerHeight, outerWidth
jQuery.fn[funcName] = function (margin, value) {
var chainable =
arguments.length && (defaultExtra || typeof margin !== "boolean"),
extra =
defaultExtra ||
(margin === true || value === true ? "margin" : "border");
return jQuery.access(
this,
function (elem, type, value) {
var doc;
if (jQuery.isWindow(elem)) {
// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
// isn't a whole lot we can do. See pull request at this URL for discussion:
// https://github.com/jquery/jquery/pull/764
return elem.document.documentElement["client" + name];
}
// Get document width or height
if (elem.nodeType === 9) {
doc = elem.documentElement;
// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
return Math.max(
elem.body["scroll" + name],
doc["scroll" + name],
elem.body["offset" + name],
doc["offset" + name],
doc["client" + name],
);
}
return value === undefined
? // Get width or height on the element, requesting but not forcing parseFloat
jQuery.css(elem, type, extra)
: // Set width or height on the element
jQuery.style(elem, type, value, extra);
},
type,
chainable ? margin : undefined,
chainable,
null,
);
};
},
);
});
// Limit scope pollution from any deprecated API
// (function() {
// })();
// Expose jQuery to the global object
window.jQuery = window.$ = jQuery;
// Expose jQuery as an AMD module, but only for AMD loaders that
// understand the issues with loading multiple versions of jQuery
// in a page that all might call define(). The loader will indicate
// they have special allowances for multiple jQuery versions by
// specifying define.amd.jQuery = true. Register as a named module,
// since jQuery can be concatenated with other files that may use define,
// but not use a proper concatenation script that understands anonymous
// AMD modules. A named AMD is safest and most robust way to register.
// Lowercase jquery is used because AMD module names are derived from
// file names, and jQuery is normally delivered in a lowercase file name.
// Do this after creating the global so that if an AMD module wants to call
// noConflict to hide this version of jQuery, it will work.
if (typeof define === "function" && define.amd && define.amd.jQuery) {
define("jquery", [], function () {
return jQuery;
});
}
})(window);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/jquery.mobile-1.4.2.js | JavaScript | /*!
* jQuery Mobile 1.4.2
* Git HEAD hash: 9d9a42a27d0c693e8b5569c3a10d771916af5045 <> Date: Fri Feb 28 2014 17:32:01 UTC
* http://jquerymobile.com
*
* Copyright 2010, 2014 jQuery Foundation, Inc. and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
*/
(function (root, doc, factory) {
if (typeof define === "function" && define.amd) {
// AMD. Register as an anonymous module.
define(["jquery"], function ($) {
factory($, root, doc);
return $.mobile;
});
} else {
// Browser globals
factory(root.jQuery, root, doc);
}
})(this, document, function (jQuery, window, document, undefined) {
(function ($) {
$.mobile = {};
})(jQuery);
(function ($, window, undefined) {
$.extend($.mobile, {
// Version of the jQuery Mobile Framework
version: "1.4.2",
// Deprecated and no longer used in 1.4 remove in 1.5
// Define the url parameter used for referencing widget-generated sub-pages.
// Translates to example.html&ui-page=subpageIdentifier
// hash segment before &ui-page= is used to make Ajax request
subPageUrlKey: "ui-page",
hideUrlBar: true,
// Keepnative Selector
keepNative: ":jqmData(role='none'), :jqmData(role='nojs')",
// Deprecated in 1.4 remove in 1.5
// Class assigned to page currently in view, and during transitions
activePageClass: "ui-page-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "active" button state, from CSS framework
activeBtnClass: "ui-btn-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "focus" form element state, from CSS framework
focusClass: "ui-focus",
// Automatically handle clicks and form submissions through Ajax, when same-domain
ajaxEnabled: true,
// Automatically load and show pages based on location.hash
hashListeningEnabled: true,
// disable to prevent jquery from bothering with links
linkBindingEnabled: true,
// Set default page transition - 'none' for no transitions
defaultPageTransition: "fade",
// Set maximum window width for transitions to apply - 'false' for no limit
maxTransitionWidth: false,
// Minimum scroll distance that will be remembered when returning to a page
// Deprecated remove in 1.5
minScrollBack: 0,
// Set default dialog transition - 'none' for no transitions
defaultDialogTransition: "pop",
// Error response message - appears when an Ajax page request fails
pageLoadErrorMessage: "Error Loading Page",
// For error messages, which theme does the box uses?
pageLoadErrorMessageTheme: "a",
// replace calls to window.history.back with phonegaps navigation helper
// where it is provided on the window object
phonegapNavigationEnabled: false,
//automatically initialize the DOM when it's ready
autoInitializePage: true,
pushStateEnabled: true,
// allows users to opt in to ignoring content by marking a parent element as
// data-ignored
ignoreContentEnabled: false,
buttonMarkup: {
hoverDelay: 200,
},
// disable the alteration of the dynamic base tag or links in the case
// that a dynamic base tag isn't supported
dynamicBaseEnabled: true,
// default the property to remove dependency on assignment in init module
pageContainer: $(),
//enable cross-domain page support
allowCrossDomainPages: false,
dialogHashKey: "&ui-state=dialog",
});
})(jQuery, this);
(function ($, window, undefined) {
var nsNormalizeDict = {},
oldFind = $.find,
rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
jqmDataRE = /:jqmData\(([^)]*)\)/g;
$.extend($.mobile, {
// Namespace used framework-wide for data-attrs. Default is no namespace
ns: "",
// Retrieve an attribute from an element and perform some massaging of the value
getAttribute: function (element, key) {
var data;
element = element.jquery ? element[0] : element;
if (element && element.getAttribute) {
data = element.getAttribute("data-" + $.mobile.ns + key);
}
// Copied from core's src/data.js:dataAttr()
// Convert from a string to a proper data type
try {
data =
data === "true"
? true
: data === "false"
? false
: data === "null"
? null
: // Only convert to a number if it doesn't change the string
+data + "" === data
? +data
: rbrace.test(data)
? JSON.parse(data)
: data;
} catch (err) {}
return data;
},
// Expose our cache for testing purposes.
nsNormalizeDict: nsNormalizeDict,
// Take a data attribute property, prepend the namespace
// and then camel case the attribute string. Add the result
// to our nsNormalizeDict so we don't have to do this again.
nsNormalize: function (prop) {
return (
nsNormalizeDict[prop] ||
(nsNormalizeDict[prop] = $.camelCase($.mobile.ns + prop))
);
},
// Find the closest javascript page element to gather settings data jsperf test
// http://jsperf.com/single-complex-selector-vs-many-complex-selectors/edit
// possibly naive, but it shows that the parsing overhead for *just* the page selector vs
// the page and dialog selector is negligable. This could probably be speed up by
// doing a similar parent node traversal to the one found in the inherited theme code above
closestPageData: function ($target) {
return $target
.closest(":jqmData(role='page'), :jqmData(role='dialog')")
.data("mobile-page");
},
});
// Mobile version of data and removeData and hasData methods
// ensures all data is set and retrieved using jQuery Mobile's data namespace
$.fn.jqmData = function (prop, value) {
var result;
if (typeof prop !== "undefined") {
if (prop) {
prop = $.mobile.nsNormalize(prop);
}
// undefined is permitted as an explicit input for the second param
// in this case it returns the value and does not set it to undefined
if (arguments.length < 2 || value === undefined) {
result = this.data(prop);
} else {
result = this.data(prop, value);
}
}
return result;
};
$.jqmData = function (elem, prop, value) {
var result;
if (typeof prop !== "undefined") {
result = $.data(elem, prop ? $.mobile.nsNormalize(prop) : prop, value);
}
return result;
};
$.fn.jqmRemoveData = function (prop) {
return this.removeData($.mobile.nsNormalize(prop));
};
$.jqmRemoveData = function (elem, prop) {
return $.removeData(elem, $.mobile.nsNormalize(prop));
};
$.find = function (selector, context, ret, extra) {
if (selector.indexOf(":jqmData") > -1) {
selector = selector.replace(
jqmDataRE,
"[data-" + ($.mobile.ns || "") + "$1]",
);
}
return oldFind.call(this, selector, context, ret, extra);
};
$.extend($.find, oldFind);
})(jQuery, this);
/*!
* jQuery UI Core c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/category/ui-core/
*/
(function ($, undefined) {
var uuid = 0,
runiqueId = /^ui-id-\d+$/;
// $.ui might exist from components with no dependencies, e.g., $.ui.position
$.ui = $.ui || {};
$.extend($.ui, {
version: "c0ab71056b936627e8a7821f03c044aec6280a40",
keyCode: {
BACKSPACE: 8,
COMMA: 188,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
PERIOD: 190,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38,
},
});
// plugins
$.fn.extend({
focus: (function (orig) {
return function (delay, fn) {
return typeof delay === "number"
? this.each(function () {
var elem = this;
setTimeout(function () {
$(elem).focus();
if (fn) {
fn.call(elem);
}
}, delay);
})
: orig.apply(this, arguments);
};
})($.fn.focus),
scrollParent: function () {
var scrollParent;
if (
($.ui.ie && /(static|relative)/.test(this.css("position"))) ||
/absolute/.test(this.css("position"))
) {
scrollParent = this.parents()
.filter(function () {
return (
/(relative|absolute|fixed)/.test($.css(this, "position")) &&
/(auto|scroll)/.test(
$.css(this, "overflow") +
$.css(this, "overflow-y") +
$.css(this, "overflow-x"),
)
);
})
.eq(0);
} else {
scrollParent = this.parents()
.filter(function () {
return /(auto|scroll)/.test(
$.css(this, "overflow") +
$.css(this, "overflow-y") +
$.css(this, "overflow-x"),
);
})
.eq(0);
}
return /fixed/.test(this.css("position")) || !scrollParent.length
? $(this[0].ownerDocument || document)
: scrollParent;
},
uniqueId: function () {
return this.each(function () {
if (!this.id) {
this.id = "ui-id-" + ++uuid;
}
});
},
removeUniqueId: function () {
return this.each(function () {
if (runiqueId.test(this.id)) {
$(this).removeAttr("id");
}
});
},
});
// selectors
function focusable(element, isTabIndexNotNaN) {
var map,
mapName,
img,
nodeName = element.nodeName.toLowerCase();
if ("area" === nodeName) {
map = element.parentNode;
mapName = map.name;
if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
return false;
}
img = $("img[usemap=#" + mapName + "]")[0];
return !!img && visible(img);
}
return (
(/input|select|textarea|button|object/.test(nodeName)
? !element.disabled
: "a" === nodeName
? element.href || isTabIndexNotNaN
: isTabIndexNotNaN) &&
// the element and all of its ancestors must be visible
visible(element)
);
}
function visible(element) {
return (
$.expr.filters.visible(element) &&
!$(element)
.parents()
.addBack()
.filter(function () {
return $.css(this, "visibility") === "hidden";
}).length
);
}
$.extend($.expr[":"], {
data: $.expr.createPseudo
? $.expr.createPseudo(function (dataName) {
return function (elem) {
return !!$.data(elem, dataName);
};
})
: // support: jQuery <1.8
function (elem, i, match) {
return !!$.data(elem, match[3]);
},
focusable: function (element) {
return focusable(element, !isNaN($.attr(element, "tabindex")));
},
tabbable: function (element) {
var tabIndex = $.attr(element, "tabindex"),
isTabIndexNaN = isNaN(tabIndex);
return (
(isTabIndexNaN || tabIndex >= 0) && focusable(element, !isTabIndexNaN)
);
},
});
// support: jQuery <1.8
if (!$("<a>").outerWidth(1).jquery) {
$.each(["Width", "Height"], function (i, name) {
var side = name === "Width" ? ["Left", "Right"] : ["Top", "Bottom"],
type = name.toLowerCase(),
orig = {
innerWidth: $.fn.innerWidth,
innerHeight: $.fn.innerHeight,
outerWidth: $.fn.outerWidth,
outerHeight: $.fn.outerHeight,
};
function reduce(elem, size, border, margin) {
$.each(side, function () {
size -= parseFloat($.css(elem, "padding" + this)) || 0;
if (border) {
size -= parseFloat($.css(elem, "border" + this + "Width")) || 0;
}
if (margin) {
size -= parseFloat($.css(elem, "margin" + this)) || 0;
}
});
return size;
}
$.fn["inner" + name] = function (size) {
if (size === undefined) {
return orig["inner" + name].call(this);
}
return this.each(function () {
$(this).css(type, reduce(this, size) + "px");
});
};
$.fn["outer" + name] = function (size, margin) {
if (typeof size !== "number") {
return orig["outer" + name].call(this, size);
}
return this.each(function () {
$(this).css(type, reduce(this, size, true, margin) + "px");
});
};
});
}
// support: jQuery <1.8
if (!$.fn.addBack) {
$.fn.addBack = function (selector) {
return this.add(
selector == null ? this.prevObject : this.prevObject.filter(selector),
);
};
}
// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
if ($("<a>").data("a-b", "a").removeData("a-b").data("a-b")) {
$.fn.removeData = (function (removeData) {
return function (key) {
if (arguments.length) {
return removeData.call(this, $.camelCase(key));
} else {
return removeData.call(this);
}
};
})($.fn.removeData);
}
// deprecated
$.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());
$.support.selectstart = "onselectstart" in document.createElement("div");
$.fn.extend({
disableSelection: function () {
return this.bind(
($.support.selectstart ? "selectstart" : "mousedown") +
".ui-disableSelection",
function (event) {
event.preventDefault();
},
);
},
enableSelection: function () {
return this.unbind(".ui-disableSelection");
},
zIndex: function (zIndex) {
if (zIndex !== undefined) {
return this.css("zIndex", zIndex);
}
if (this.length) {
var elem = $(this[0]),
position,
value;
while (elem.length && elem[0] !== document) {
// Ignore z-index if position is set to a value where z-index is ignored by the browser
// This makes behavior of this function consistent across browsers
// WebKit always returns auto if the element is positioned
position = elem.css("position");
if (
position === "absolute" ||
position === "relative" ||
position === "fixed"
) {
// IE returns 0 when zIndex is not specified
// other browsers return a string
// we ignore the case of nested elements with an explicit value of 0
// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
value = parseInt(elem.css("zIndex"), 10);
if (!isNaN(value) && value !== 0) {
return value;
}
}
elem = elem.parent();
}
}
return 0;
},
});
// $.ui.plugin is deprecated. Use $.widget() extensions instead.
$.ui.plugin = {
add: function (module, option, set) {
var i,
proto = $.ui[module].prototype;
for (i in set) {
proto.plugins[i] = proto.plugins[i] || [];
proto.plugins[i].push([option, set[i]]);
}
},
call: function (instance, name, args, allowDisconnected) {
var i,
set = instance.plugins[name];
if (!set) {
return;
}
if (
!allowDisconnected &&
(!instance.element[0].parentNode ||
instance.element[0].parentNode.nodeType === 11)
) {
return;
}
for (i = 0; i < set.length; i++) {
if (instance.options[set[i][0]]) {
set[i][1].apply(instance.element, args);
}
}
},
};
})(jQuery);
(function ($, window, undefined) {
// Subtract the height of external toolbars from the page height, if the page does not have
// internal toolbars of the same type
var compensateToolbars = function (page, desiredHeight) {
var pageParent = page.parent(),
toolbarsAffectingHeight = [],
externalHeaders = pageParent.children(":jqmData(role='header')"),
internalHeaders = page.children(":jqmData(role='header')"),
externalFooters = pageParent.children(":jqmData(role='footer')"),
internalFooters = page.children(":jqmData(role='footer')");
// If we have no internal headers, but we do have external headers, then their height
// reduces the page height
if (internalHeaders.length === 0 && externalHeaders.length > 0) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat(
externalHeaders.toArray(),
);
}
// If we have no internal footers, but we do have external footers, then their height
// reduces the page height
if (internalFooters.length === 0 && externalFooters.length > 0) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat(
externalFooters.toArray(),
);
}
$.each(toolbarsAffectingHeight, function (index, value) {
desiredHeight -= $(value).outerHeight();
});
// Height must be at least zero
return Math.max(0, desiredHeight);
};
$.extend($.mobile, {
// define the window and the document objects
window: $(window),
document: $(document),
// TODO: Remove and use $.ui.keyCode directly
keyCode: $.ui.keyCode,
// Place to store various widget extensions
behaviors: {},
// Scroll page vertically: scroll to 0 to hide iOS address bar, or pass a Y value
silentScroll: function (ypos) {
if ($.type(ypos) !== "number") {
ypos = $.mobile.defaultHomeScroll;
}
// prevent scrollstart and scrollstop events
$.event.special.scrollstart.enabled = false;
setTimeout(function () {
window.scrollTo(0, ypos);
$.mobile.document.trigger("silentscroll", { x: 0, y: ypos });
}, 20);
setTimeout(function () {
$.event.special.scrollstart.enabled = true;
}, 150);
},
getClosestBaseUrl: function (ele) {
// Find the closest page and extract out its url.
var url = $(ele).closest(".ui-page").jqmData("url"),
base = $.mobile.path.documentBase.hrefNoHash;
if (
!$.mobile.dynamicBaseEnabled ||
!url ||
!$.mobile.path.isPath(url)
) {
url = base;
}
return $.mobile.path.makeUrlAbsolute(url, base);
},
removeActiveLinkClass: function (forceRemoval) {
if (
!!$.mobile.activeClickedLink &&
(!$.mobile.activeClickedLink.closest("." + $.mobile.activePageClass)
.length ||
forceRemoval)
) {
$.mobile.activeClickedLink.removeClass($.mobile.activeBtnClass);
}
$.mobile.activeClickedLink = null;
},
// DEPRECATED in 1.4
// Find the closest parent with a theme class on it. Note that
// we are not using $.fn.closest() on purpose here because this
// method gets called quite a bit and we need it to be as fast
// as possible.
getInheritedTheme: function (el, defaultTheme) {
var e = el[0],
ltr = "",
re = /ui-(bar|body|overlay)-([a-z])\b/,
c,
m;
while (e) {
c = e.className || "";
if (c && (m = re.exec(c)) && (ltr = m[2])) {
// We found a parent with a theme class
// on it so bail from this loop.
break;
}
e = e.parentNode;
}
// Return the theme letter we found, if none, return the
// specified default.
return ltr || defaultTheme || "a";
},
enhanceable: function (elements) {
return this.haveParents(elements, "enhance");
},
hijackable: function (elements) {
return this.haveParents(elements, "ajax");
},
haveParents: function (elements, attr) {
if (!$.mobile.ignoreContentEnabled) {
return elements;
}
var count = elements.length,
$newSet = $(),
e,
$element,
excluded,
i,
c;
for (i = 0; i < count; i++) {
$element = elements.eq(i);
excluded = false;
e = elements[i];
while (e) {
c = e.getAttribute
? e.getAttribute("data-" + $.mobile.ns + attr)
: "";
if (c === "false") {
excluded = true;
break;
}
e = e.parentNode;
}
if (!excluded) {
$newSet = $newSet.add($element);
}
}
return $newSet;
},
getScreenHeight: function () {
// Native innerHeight returns more accurate value for this across platforms,
// jQuery version is here as a normalized fallback for platforms like Symbian
return window.innerHeight || $.mobile.window.height();
},
//simply set the active page's minimum height to screen height, depending on orientation
resetActivePageHeight: function (height) {
var page = $("." + $.mobile.activePageClass),
pageHeight = page.height(),
pageOuterHeight = page.outerHeight(true);
height = compensateToolbars(
page,
typeof height === "number" ? height : $.mobile.getScreenHeight(),
);
page.css("min-height", height - (pageOuterHeight - pageHeight));
},
loading: function () {
// If this is the first call to this function, instantiate a loader widget
var loader =
this.loading._widget ||
$($.mobile.loader.prototype.defaultHtml).loader(),
// Call the appropriate method on the loader
returnValue = loader.loader.apply(loader, arguments);
// Make sure the loader is retained for future calls to this function.
this.loading._widget = loader;
return returnValue;
},
});
$.addDependents = function (elem, newDependents) {
var $elem = $(elem),
dependents = $elem.jqmData("dependents") || $();
$elem.jqmData("dependents", $(dependents).add(newDependents));
};
// plugins
$.fn.extend({
removeWithDependents: function () {
$.removeWithDependents(this);
},
// Enhance child elements
enhanceWithin: function () {
var index,
widgetElements = {},
keepNative = $.mobile.page.prototype.keepNativeSelector(),
that = this;
// Add no js class to elements
if ($.mobile.nojs) {
$.mobile.nojs(this);
}
// Bind links for ajax nav
if ($.mobile.links) {
$.mobile.links(this);
}
// Degrade inputs for styleing
if ($.mobile.degradeInputsWithin) {
$.mobile.degradeInputsWithin(this);
}
// Run buttonmarkup
if ($.fn.buttonMarkup) {
this.find($.fn.buttonMarkup.initSelector)
.not(keepNative)
.jqmEnhanceable()
.buttonMarkup();
}
// Add classes for fieldContain
if ($.fn.fieldcontain) {
this.find(":jqmData(role='fieldcontain')")
.not(keepNative)
.jqmEnhanceable()
.fieldcontain();
}
// Enhance widgets
$.each($.mobile.widgets, function (name, constructor) {
// If initSelector not false find elements
if (constructor.initSelector) {
// Filter elements that should not be enhanced based on parents
var elements = $.mobile.enhanceable(
that.find(constructor.initSelector),
);
// If any matching elements remain filter ones with keepNativeSelector
if (elements.length > 0) {
// $.mobile.page.prototype.keepNativeSelector is deprecated this is just for backcompat
// Switch to $.mobile.keepNative in 1.5 which is just a value not a function
elements = elements.not(keepNative);
}
// Enhance whatever is left
if (elements.length > 0) {
widgetElements[constructor.prototype.widgetName] = elements;
}
}
});
for (index in widgetElements) {
widgetElements[index][index]();
}
return this;
},
addDependents: function (newDependents) {
$.addDependents(this, newDependents);
},
// note that this helper doesn't attempt to handle the callback
// or setting of an html element's text, its only purpose is
// to return the html encoded version of the text in all cases. (thus the name)
getEncodedText: function () {
return $("<a>").text(this.text()).html();
},
// fluent helper function for the mobile namespaced equivalent
jqmEnhanceable: function () {
return $.mobile.enhanceable(this);
},
jqmHijackable: function () {
return $.mobile.hijackable(this);
},
});
$.removeWithDependents = function (nativeElement) {
var element = $(nativeElement);
(element.jqmData("dependents") || $()).remove();
element.remove();
};
$.addDependents = function (nativeElement, newDependents) {
var element = $(nativeElement),
dependents = element.jqmData("dependents") || $();
element.jqmData("dependents", $(dependents).add(newDependents));
};
$.find.matches = function (expr, set) {
return $.find(expr, null, null, set);
};
$.find.matchesSelector = function (node, expr) {
return $.find(expr, null, null, [node]).length > 0;
};
})(jQuery, this);
/*!
* jQuery UI Widget c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/jQuery.widget/
*/
(function ($, undefined) {
var uuid = 0,
slice = Array.prototype.slice,
_cleanData = $.cleanData;
$.cleanData = function (elems) {
for (var i = 0, elem; (elem = elems[i]) != null; i++) {
try {
$(elem).triggerHandler("remove");
// http://bugs.jquery.com/ticket/8235
} catch (e) {}
}
_cleanData(elems);
};
$.widget = function (name, base, prototype) {
var fullName,
existingConstructor,
constructor,
basePrototype,
// proxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
proxiedPrototype = {},
namespace = name.split(".")[0];
name = name.split(".")[1];
fullName = namespace + "-" + name;
if (!prototype) {
prototype = base;
base = $.Widget;
}
// create selector for plugin
$.expr[":"][fullName.toLowerCase()] = function (elem) {
return !!$.data(elem, fullName);
};
$[namespace] = $[namespace] || {};
existingConstructor = $[namespace][name];
constructor = $[namespace][name] = function (options, element) {
// allow instantiation without "new" keyword
if (!this._createWidget) {
return new constructor(options, element);
}
// allow instantiation without initializing for simple inheritance
// must use "new" keyword (the code above always passes args)
if (arguments.length) {
this._createWidget(options, element);
}
};
// extend with the existing constructor to carry over any static properties
$.extend(constructor, existingConstructor, {
version: prototype.version,
// copy the object used to create the prototype in case we need to
// redefine the widget later
_proto: $.extend({}, prototype),
// track widgets that inherit from this widget in case this widget is
// redefined after a widget inherits from it
_childConstructors: [],
});
basePrototype = new base();
// we need to make the options hash a property directly on the new instance
// otherwise we'll modify the options hash on the prototype that we're
// inheriting from
basePrototype.options = $.widget.extend({}, basePrototype.options);
$.each(prototype, function (prop, value) {
if (!$.isFunction(value)) {
proxiedPrototype[prop] = value;
return;
}
proxiedPrototype[prop] = (function () {
var _super = function () {
return base.prototype[prop].apply(this, arguments);
},
_superApply = function (args) {
return base.prototype[prop].apply(this, args);
};
return function () {
var __super = this._super,
__superApply = this._superApply,
returnValue;
this._super = _super;
this._superApply = _superApply;
returnValue = value.apply(this, arguments);
this._super = __super;
this._superApply = __superApply;
return returnValue;
};
})();
});
constructor.prototype = $.widget.extend(
basePrototype,
{
// TODO: remove support for widgetEventPrefix
// always use the name + a colon as the prefix, e.g., draggable:start
// don't prefix for widgets that aren't DOM-based
widgetEventPrefix: existingConstructor
? basePrototype.widgetEventPrefix || name
: name,
},
proxiedPrototype,
{
constructor: constructor,
namespace: namespace,
widgetName: name,
widgetFullName: fullName,
},
);
// If this widget is being redefined then we need to find all widgets that
// are inheriting from it and redefine all of them so that they inherit from
// the new version of this widget. We're essentially trying to replace one
// level in the prototype chain.
if (existingConstructor) {
$.each(existingConstructor._childConstructors, function (i, child) {
var childPrototype = child.prototype;
// redefine the child widget using the same prototype that was
// originally used, but inherit from the new version of the base
$.widget(
childPrototype.namespace + "." + childPrototype.widgetName,
constructor,
child._proto,
);
});
// remove the list of existing child constructors from the old constructor
// so the old child constructors can be garbage collected
delete existingConstructor._childConstructors;
} else {
base._childConstructors.push(constructor);
}
$.widget.bridge(name, constructor);
return constructor;
};
$.widget.extend = function (target) {
var input = slice.call(arguments, 1),
inputIndex = 0,
inputLength = input.length,
key,
value;
for (; inputIndex < inputLength; inputIndex++) {
for (key in input[inputIndex]) {
value = input[inputIndex][key];
if (input[inputIndex].hasOwnProperty(key) && value !== undefined) {
// Clone objects
if ($.isPlainObject(value)) {
target[key] = $.isPlainObject(target[key])
? $.widget.extend({}, target[key], value)
: // Don't extend strings, arrays, etc. with objects
$.widget.extend({}, value);
// Copy everything else by reference
} else {
target[key] = value;
}
}
}
}
return target;
};
$.widget.bridge = function (name, object) {
var fullName = object.prototype.widgetFullName || name;
$.fn[name] = function (options) {
var isMethodCall = typeof options === "string",
args = slice.call(arguments, 1),
returnValue = this;
// allow multiple hashes to be passed on init
options =
!isMethodCall && args.length
? $.widget.extend.apply(null, [options].concat(args))
: options;
if (isMethodCall) {
this.each(function () {
var methodValue,
instance = $.data(this, fullName);
if (options === "instance") {
returnValue = instance;
return false;
}
if (!instance) {
return $.error(
"cannot call methods on " +
name +
" prior to initialization; " +
"attempted to call method '" +
options +
"'",
);
}
if (!$.isFunction(instance[options]) || options.charAt(0) === "_") {
return $.error(
"no such method '" +
options +
"' for " +
name +
" widget instance",
);
}
methodValue = instance[options].apply(instance, args);
if (methodValue !== instance && methodValue !== undefined) {
returnValue =
methodValue && methodValue.jquery
? returnValue.pushStack(methodValue.get())
: methodValue;
return false;
}
});
} else {
this.each(function () {
var instance = $.data(this, fullName);
if (instance) {
instance.option(options || {})._init();
} else {
$.data(this, fullName, new object(options, this));
}
});
}
return returnValue;
};
};
$.Widget = function (/* options, element */) {};
$.Widget._childConstructors = [];
$.Widget.prototype = {
widgetName: "widget",
widgetEventPrefix: "",
defaultElement: "<div>",
options: {
disabled: false,
// callbacks
create: null,
},
_createWidget: function (options, element) {
element = $(element || this.defaultElement || this)[0];
this.element = $(element);
this.uuid = uuid++;
this.eventNamespace = "." + this.widgetName + this.uuid;
this.options = $.widget.extend(
{},
this.options,
this._getCreateOptions(),
options,
);
this.bindings = $();
this.hoverable = $();
this.focusable = $();
if (element !== this) {
$.data(element, this.widgetFullName, this);
this._on(true, this.element, {
remove: function (event) {
if (event.target === element) {
this.destroy();
}
},
});
this.document = $(
element.style
? // element within the document
element.ownerDocument
: // element is window or document
element.document || element,
);
this.window = $(
this.document[0].defaultView || this.document[0].parentWindow,
);
}
this._create();
this._trigger("create", null, this._getCreateEventData());
this._init();
},
_getCreateOptions: $.noop,
_getCreateEventData: $.noop,
_create: $.noop,
_init: $.noop,
destroy: function () {
this._destroy();
// we can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element
.unbind(this.eventNamespace)
.removeData(this.widgetFullName)
// support: jquery <1.6.3
// http://bugs.jquery.com/ticket/9413
.removeData($.camelCase(this.widgetFullName));
this.widget()
.unbind(this.eventNamespace)
.removeAttr("aria-disabled")
.removeClass(
this.widgetFullName + "-disabled " + "ui-state-disabled",
);
// clean up events and states
this.bindings.unbind(this.eventNamespace);
this.hoverable.removeClass("ui-state-hover");
this.focusable.removeClass("ui-state-focus");
},
_destroy: $.noop,
widget: function () {
return this.element;
},
option: function (key, value) {
var options = key,
parts,
curOption,
i;
if (arguments.length === 0) {
// don't return a reference to the internal hash
return $.widget.extend({}, this.options);
}
if (typeof key === "string") {
// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
parts = key.split(".");
key = parts.shift();
if (parts.length) {
curOption = options[key] = $.widget.extend({}, this.options[key]);
for (i = 0; i < parts.length - 1; i++) {
curOption[parts[i]] = curOption[parts[i]] || {};
curOption = curOption[parts[i]];
}
key = parts.pop();
if (value === undefined) {
return curOption[key] === undefined ? null : curOption[key];
}
curOption[key] = value;
} else {
if (value === undefined) {
return this.options[key] === undefined ? null : this.options[key];
}
options[key] = value;
}
}
this._setOptions(options);
return this;
},
_setOptions: function (options) {
var key;
for (key in options) {
this._setOption(key, options[key]);
}
return this;
},
_setOption: function (key, value) {
this.options[key] = value;
if (key === "disabled") {
this.widget().toggleClass(this.widgetFullName + "-disabled", !!value);
this.hoverable.removeClass("ui-state-hover");
this.focusable.removeClass("ui-state-focus");
}
return this;
},
enable: function () {
return this._setOptions({ disabled: false });
},
disable: function () {
return this._setOptions({ disabled: true });
},
_on: function (suppressDisabledCheck, element, handlers) {
var delegateElement,
instance = this;
// no suppressDisabledCheck flag, shuffle arguments
if (typeof suppressDisabledCheck !== "boolean") {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// no element argument, shuffle and use this.element
if (!handlers) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
// accept selectors, DOM elements
element = delegateElement = $(element);
this.bindings = this.bindings.add(element);
}
$.each(handlers, function (event, handler) {
function handlerProxy() {
// allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if (
!suppressDisabledCheck &&
(instance.options.disabled === true ||
$(this).hasClass("ui-state-disabled"))
) {
return;
}
return (
typeof handler === "string" ? instance[handler] : handler
).apply(instance, arguments);
}
// copy the guid so direct unbinding works
if (typeof handler !== "string") {
handlerProxy.guid = handler.guid =
handler.guid || handlerProxy.guid || $.guid++;
}
var match = event.match(/^(\w+)\s*(.*)$/),
eventName = match[1] + instance.eventNamespace,
selector = match[2];
if (selector) {
delegateElement.delegate(selector, eventName, handlerProxy);
} else {
element.bind(eventName, handlerProxy);
}
});
},
_off: function (element, eventName) {
eventName =
(eventName || "").split(" ").join(this.eventNamespace + " ") +
this.eventNamespace;
element.unbind(eventName).undelegate(eventName);
},
_delay: function (handler, delay) {
function handlerProxy() {
return (
typeof handler === "string" ? instance[handler] : handler
).apply(instance, arguments);
}
var instance = this;
return setTimeout(handlerProxy, delay || 0);
},
_hoverable: function (element) {
this.hoverable = this.hoverable.add(element);
this._on(element, {
mouseenter: function (event) {
$(event.currentTarget).addClass("ui-state-hover");
},
mouseleave: function (event) {
$(event.currentTarget).removeClass("ui-state-hover");
},
});
},
_focusable: function (element) {
this.focusable = this.focusable.add(element);
this._on(element, {
focusin: function (event) {
$(event.currentTarget).addClass("ui-state-focus");
},
focusout: function (event) {
$(event.currentTarget).removeClass("ui-state-focus");
},
});
},
_trigger: function (type, event, data) {
var prop,
orig,
callback = this.options[type];
data = data || {};
event = $.Event(event);
event.type = (
type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type
).toLowerCase();
// the original event may come from any element
// so we need to reset the target on the new event
event.target = this.element[0];
// copy original event properties over to the new event
orig = event.originalEvent;
if (orig) {
for (prop in orig) {
if (!(prop in event)) {
event[prop] = orig[prop];
}
}
}
this.element.trigger(event, data);
return !(
($.isFunction(callback) &&
callback.apply(this.element[0], [event].concat(data)) === false) ||
event.isDefaultPrevented()
);
},
};
$.each(
{ show: "fadeIn", hide: "fadeOut" },
function (method, defaultEffect) {
$.Widget.prototype["_" + method] = function (
element,
options,
callback,
) {
if (typeof options === "string") {
options = { effect: options };
}
var hasOptions,
effectName = !options
? method
: options === true || typeof options === "number"
? defaultEffect
: options.effect || defaultEffect;
options = options || {};
if (typeof options === "number") {
options = { duration: options };
}
hasOptions = !$.isEmptyObject(options);
options.complete = callback;
if (options.delay) {
element.delay(options.delay);
}
if (hasOptions && $.effects && $.effects.effect[effectName]) {
element[method](options);
} else if (effectName !== method && element[effectName]) {
element[effectName](options.duration, options.easing, callback);
} else {
element.queue(function (next) {
$(this)[method]();
if (callback) {
callback.call(element[0]);
}
next();
});
}
};
},
);
})(jQuery);
(function ($, undefined) {
var rcapitals = /[A-Z]/g,
replaceFunction = function (c) {
return "-" + c.toLowerCase();
};
$.extend($.Widget.prototype, {
_getCreateOptions: function () {
var option,
value,
elem = this.element[0],
options = {};
//
if (!$.mobile.getAttribute(elem, "defaults")) {
for (option in this.options) {
value = $.mobile.getAttribute(
elem,
option.replace(rcapitals, replaceFunction),
);
if (value != null) {
options[option] = value;
}
}
}
return options;
},
});
//TODO: Remove in 1.5 for backcompat only
$.mobile.widget = $.Widget;
})(jQuery);
(function ($) {
// TODO move loader class down into the widget settings
var loaderClass = "ui-loader",
$html = $("html");
$.widget("mobile.loader", {
// NOTE if the global config settings are defined they will override these
// options
options: {
// the theme for the loading message
theme: "a",
// whether the text in the loading message is shown
textVisible: false,
// custom html for the inner content of the loading message
html: "",
// the text to be displayed when the popup is shown
text: "loading",
},
defaultHtml:
"<div class='" +
loaderClass +
"'>" +
"<span class='ui-icon-loading'></span>" +
"<h1></h1>" +
"</div>",
// For non-fixed supportin browsers. Position at y center (if scrollTop supported), above the activeBtn (if defined), or just 100px from top
fakeFixLoader: function () {
var activeBtn = $("." + $.mobile.activeBtnClass).first();
this.element.css({
top:
($.support.scrollTop &&
this.window.scrollTop() + this.window.height() / 2) ||
(activeBtn.length && activeBtn.offset().top) ||
100,
});
},
// check position of loader to see if it appears to be "fixed" to center
// if not, use abs positioning
checkLoaderPosition: function () {
var offset = this.element.offset(),
scrollTop = this.window.scrollTop(),
screenHeight = $.mobile.getScreenHeight();
if (offset.top < scrollTop || offset.top - scrollTop > screenHeight) {
this.element.addClass("ui-loader-fakefix");
this.fakeFixLoader();
this.window
.unbind("scroll", this.checkLoaderPosition)
.bind("scroll", $.proxy(this.fakeFixLoader, this));
}
},
resetHtml: function () {
this.element.html($(this.defaultHtml).html());
},
// Turn on/off page loading message. Theme doubles as an object argument
// with the following shape: { theme: '', text: '', html: '', textVisible: '' }
// NOTE that the $.mobile.loading* settings and params past the first are deprecated
// TODO sweet jesus we need to break some of this out
show: function (theme, msgText, textonly) {
var textVisible, message, loadSettings;
this.resetHtml();
// use the prototype options so that people can set them globally at
// mobile init. Consistency, it's what's for dinner
if ($.type(theme) === "object") {
loadSettings = $.extend({}, this.options, theme);
theme = loadSettings.theme;
} else {
loadSettings = this.options;
// here we prefer the theme value passed as a string argument, then
// we prefer the global option because we can't use undefined default
// prototype options, then the prototype option
theme = theme || loadSettings.theme;
}
// set the message text, prefer the param, then the settings object
// then loading message
message =
msgText || (loadSettings.text === false ? "" : loadSettings.text);
// prepare the dom
$html.addClass("ui-loading");
textVisible = loadSettings.textVisible;
// add the proper css given the options (theme, text, etc)
// Force text visibility if the second argument was supplied, or
// if the text was explicitly set in the object args
this.element.attr(
"class",
loaderClass +
" ui-corner-all ui-body-" +
theme +
" ui-loader-" +
(textVisible || msgText || theme.text ? "verbose" : "default") +
(loadSettings.textonly || textonly ? " ui-loader-textonly" : ""),
);
// TODO verify that jquery.fn.html is ok to use in both cases here
// this might be overly defensive in preventing unknowing xss
// if the html attribute is defined on the loading settings, use that
// otherwise use the fallbacks from above
if (loadSettings.html) {
this.element.html(loadSettings.html);
} else {
this.element.find("h1").text(message);
}
// attach the loader to the DOM
this.element.appendTo($.mobile.pageContainer);
// check that the loader is visible
this.checkLoaderPosition();
// on scroll check the loader position
this.window.bind("scroll", $.proxy(this.checkLoaderPosition, this));
},
hide: function () {
$html.removeClass("ui-loading");
if (this.options.text) {
this.element.removeClass("ui-loader-fakefix");
}
$.mobile.window.unbind("scroll", this.fakeFixLoader);
$.mobile.window.unbind("scroll", this.checkLoaderPosition);
},
});
})(jQuery, this);
/*!
* jQuery hashchange event - v1.3 - 7/21/2010
* http://benalman.com/projects/jquery-hashchange-plugin/
*
* Copyright (c) 2010 "Cowboy" Ben Alman
* Dual licensed under the MIT and GPL licenses.
* http://benalman.com/about/license/
*/
// Script: jQuery hashchange event
//
// *Version: 1.3, Last updated: 7/21/2010*
//
// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
// GitHub - http://github.com/cowboy/jquery-hashchange/
// Source - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
// (Minified) - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (0.8kb gzipped)
//
// About: License
//
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
//
// About: Examples
//
// These working examples, complete with fully commented code, illustrate a few
// ways in which this plugin can be used.
//
// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
// document.domain - http://benalman.com/code/projects/jquery-hashchange/examples/document_domain/
//
// About: Support and Testing
//
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
//
// jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-4, Chrome 5-6, Safari 3.2-5,
// Opera 9.6-10.60, iPhone 3.1, Android 1.6-2.2, BlackBerry 4.6-5.
// Unit Tests - http://benalman.com/code/projects/jquery-hashchange/unit/
//
// About: Known issues
//
// While this jQuery hashchange event implementation is quite stable and
// robust, there are a few unfortunate browser bugs surrounding expected
// hashchange event-based behaviors, independent of any JavaScript
// window.onhashchange abstraction. See the following examples for more
// information:
//
// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
//
// Also note that should a browser natively support the window.onhashchange
// event, but not report that it does, the fallback polling loop will be used.
//
// About: Release History
//
// 1.3 - (7/21/2010) Reorganized IE6/7 Iframe code to make it more
// "removable" for mobile-only development. Added IE6/7 document.title
// support. Attempted to make Iframe as hidden as possible by using
// techniques from http://www.paciellogroup.com/blog/?p=604. Added
// support for the "shortcut" format $(window).hashchange( fn ) and
// $(window).hashchange() like jQuery provides for built-in events.
// Renamed jQuery.hashchangeDelay to <jQuery.fn.hashchange.delay> and
// lowered its default value to 50. Added <jQuery.fn.hashchange.domain>
// and <jQuery.fn.hashchange.src> properties plus document-domain.html
// file to address access denied issues when setting document.domain in
// IE6/7.
// 1.2 - (2/11/2010) Fixed a bug where coming back to a page using this plugin
// from a page on another domain would cause an error in Safari 4. Also,
// IE6/7 Iframe is now inserted after the body (this actually works),
// which prevents the page from scrolling when the event is first bound.
// Event can also now be bound before DOM ready, but it won't be usable
// before then in IE6/7.
// 1.1 - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
// where browser version is incorrectly reported as 8.0, despite
// inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
// 1.0 - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
// window.onhashchange functionality into a separate plugin for users
// who want just the basic event & back button support, without all the
// extra awesomeness that BBQ provides. This plugin will be included as
// part of jQuery BBQ, but also be available separately.
(function ($, window, undefined) {
"$:nomunge"; // Used by YUI compressor.
// Reused string.
var str_hashchange = "hashchange",
// Method / object references.
doc = document,
fake_onhashchange,
special = $.event.special,
// Does the browser support window.onhashchange? Note that IE8 running in
// IE7 compatibility mode reports true for 'onhashchange' in window, even
// though the event isn't supported, so also test document.documentMode.
doc_mode = doc.documentMode,
supports_onhashchange =
"on" + str_hashchange in window &&
(doc_mode === undefined || doc_mode > 7);
// Get location.hash (or what you'd expect location.hash to be) sans any
// leading #. Thanks for making this necessary, Firefox!
function get_fragment(url) {
url = url || location.href;
return "#" + url.replace(/^[^#]*#?(.*)$/, "$1");
}
// Method: jQuery.fn.hashchange
//
// Bind a handler to the window.onhashchange event or trigger all bound
// window.onhashchange event handlers. This behavior is consistent with
// jQuery's built-in event handlers.
//
// Usage:
//
// > jQuery(window).hashchange( [ handler ] );
//
// Arguments:
//
// handler - (Function) Optional handler to be bound to the hashchange
// event. This is a "shortcut" for the more verbose form:
// jQuery(window).bind( 'hashchange', handler ). If handler is omitted,
// all bound window.onhashchange event handlers will be triggered. This
// is a shortcut for the more verbose
// jQuery(window).trigger( 'hashchange' ). These forms are described in
// the <hashchange event> section.
//
// Returns:
//
// (jQuery) The initial jQuery collection of elements.
// Allow the "shortcut" format $(elem).hashchange( fn ) for binding and
// $(elem).hashchange() for triggering, like jQuery does for built-in events.
$.fn[str_hashchange] = function (fn) {
return fn ? this.bind(str_hashchange, fn) : this.trigger(str_hashchange);
};
// Property: jQuery.fn.hashchange.delay
//
// The numeric interval (in milliseconds) at which the <hashchange event>
// polling loop executes. Defaults to 50.
// Property: jQuery.fn.hashchange.domain
//
// If you're setting document.domain in your JavaScript, and you want hash
// history to work in IE6/7, not only must this property be set, but you must
// also set document.domain BEFORE jQuery is loaded into the page. This
// property is only applicable if you are supporting IE6/7 (or IE8 operating
// in "IE7 compatibility" mode).
//
// In addition, the <jQuery.fn.hashchange.src> property must be set to the
// path of the included "document-domain.html" file, which can be renamed or
// modified if necessary (note that the document.domain specified must be the
// same in both your main JavaScript as well as in this file).
//
// Usage:
//
// jQuery.fn.hashchange.domain = document.domain;
// Property: jQuery.fn.hashchange.src
//
// If, for some reason, you need to specify an Iframe src file (for example,
// when setting document.domain as in <jQuery.fn.hashchange.domain>), you can
// do so using this property. Note that when using this property, history
// won't be recorded in IE6/7 until the Iframe src file loads. This property
// is only applicable if you are supporting IE6/7 (or IE8 operating in "IE7
// compatibility" mode).
//
// Usage:
//
// jQuery.fn.hashchange.src = 'path/to/file.html';
$.fn[str_hashchange].delay = 50;
/*
$.fn[ str_hashchange ].domain = null;
$.fn[ str_hashchange ].src = null;
*/
// Event: hashchange event
//
// Fired when location.hash changes. In browsers that support it, the native
// HTML5 window.onhashchange event is used, otherwise a polling loop is
// initialized, running every <jQuery.fn.hashchange.delay> milliseconds to
// see if the hash has changed. In IE6/7 (and IE8 operating in "IE7
// compatibility" mode), a hidden Iframe is created to allow the back button
// and hash-based history to work.
//
// Usage as described in <jQuery.fn.hashchange>:
//
// > // Bind an event handler.
// > jQuery(window).hashchange( function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).hashchange();
//
// A more verbose usage that allows for event namespacing:
//
// > // Bind an event handler.
// > jQuery(window).bind( 'hashchange', function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).trigger( 'hashchange' );
//
// Additional Notes:
//
// * The polling loop and Iframe are not created until at least one handler
// is actually bound to the 'hashchange' event.
// * If you need the bound handler(s) to execute immediately, in cases where
// a location.hash exists on page load, via bookmark or page refresh for
// example, use jQuery(window).hashchange() or the more verbose
// jQuery(window).trigger( 'hashchange' ).
// * The event can be bound before DOM ready, but since it won't be usable
// before then in IE6/7 (due to the necessary Iframe), recommended usage is
// to bind it inside a DOM ready handler.
// Override existing $.event.special.hashchange methods (allowing this plugin
// to be defined after jQuery BBQ in BBQ's source code).
special[str_hashchange] = $.extend(special[str_hashchange], {
// Called only when the first 'hashchange' event is bound to window.
setup: function () {
// If window.onhashchange is supported natively, there's nothing to do..
if (supports_onhashchange) {
return false;
}
// Otherwise, we need to create our own. And we don't want to call this
// until the user binds to the event, just in case they never do, since it
// will create a polling loop and possibly even a hidden Iframe.
$(fake_onhashchange.start);
},
// Called only when the last 'hashchange' event is unbound from window.
teardown: function () {
// If window.onhashchange is supported natively, there's nothing to do..
if (supports_onhashchange) {
return false;
}
// Otherwise, we need to stop ours (if possible).
$(fake_onhashchange.stop);
},
});
// fake_onhashchange does all the work of triggering the window.onhashchange
// event for browsers that don't natively support it, including creating a
// polling loop to watch for hash changes and in IE 6/7 creating a hidden
// Iframe to enable back and forward.
fake_onhashchange = (function () {
var self = {},
timeout_id,
// Remember the initial hash so it doesn't get triggered immediately.
last_hash = get_fragment(),
fn_retval = function (val) {
return val;
},
history_set = fn_retval,
history_get = fn_retval;
// Start the polling loop.
self.start = function () {
timeout_id || poll();
};
// Stop the polling loop.
self.stop = function () {
timeout_id && clearTimeout(timeout_id);
timeout_id = undefined;
};
// This polling loop checks every $.fn.hashchange.delay milliseconds to see
// if location.hash has changed, and triggers the 'hashchange' event on
// window when necessary.
function poll() {
var hash = get_fragment(),
history_hash = history_get(last_hash);
if (hash !== last_hash) {
history_set((last_hash = hash), history_hash);
$(window).trigger(str_hashchange);
} else if (history_hash !== last_hash) {
location.href = location.href.replace(/#.*/, "") + history_hash;
}
timeout_id = setTimeout(poll, $.fn[str_hashchange].delay);
}
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvv REMOVE IF NOT SUPPORTING IE6/7/8 vvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
window.attachEvent &&
!window.addEventListener &&
!supports_onhashchange &&
(function () {
// Not only do IE6/7 need the "magical" Iframe treatment, but so does IE8
// when running in "IE7 compatibility" mode.
var iframe, iframe_src;
// When the event is bound and polling starts in IE 6/7, create a hidden
// Iframe for history handling.
self.start = function () {
if (!iframe) {
iframe_src = $.fn[str_hashchange].src;
iframe_src = iframe_src && iframe_src + get_fragment();
// Create hidden Iframe. Attempt to make Iframe as hidden as possible
// by using techniques from http://www.paciellogroup.com/blog/?p=604.
iframe = $('<iframe tabindex="-1" title="empty"/>')
.hide()
// When Iframe has completely loaded, initialize the history and
// start polling.
.one("load", function () {
iframe_src || history_set(get_fragment());
poll();
})
// Load Iframe src if specified, otherwise nothing.
.attr("src", iframe_src || "javascript:0")
// Append Iframe after the end of the body to prevent unnecessary
// initial page scrolling (yes, this works).
.insertAfter("body")[0].contentWindow;
// Whenever `document.title` changes, update the Iframe's title to
// prettify the back/next history menu entries. Since IE sometimes
// errors with "Unspecified error" the very first time this is set
// (yes, very useful) wrap this with a try/catch block.
doc.onpropertychange = function () {
try {
if (event.propertyName === "title") {
iframe.document.title = doc.title;
}
} catch (e) {}
};
}
};
// Override the "stop" method since an IE6/7 Iframe was created. Even
// if there are no longer any bound event handlers, the polling loop
// is still necessary for back/next to work at all!
self.stop = fn_retval;
// Get history by looking at the hidden Iframe's location.hash.
history_get = function () {
return get_fragment(iframe.location.href);
};
// Set a new history item by opening and then closing the Iframe
// document, *then* setting its location.hash. If document.domain has
// been set, update that as well.
history_set = function (hash, history_hash) {
var iframe_doc = iframe.document,
domain = $.fn[str_hashchange].domain;
if (hash !== history_hash) {
// Update Iframe with any initial `document.title` that might be set.
iframe_doc.title = doc.title;
// Opening the Iframe's document after it has been closed is what
// actually adds a history entry.
iframe_doc.open();
// Set document.domain for the Iframe document as well, if necessary.
domain &&
iframe_doc.write(
'<script>document.domain="' + domain + '"</script>',
);
iframe_doc.close();
// Update the Iframe's hash, for great justice.
iframe.location.hash = hash;
}
};
})();
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^ REMOVE IF NOT SUPPORTING IE6/7/8 ^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self;
})();
})(jQuery, this);
(function ($, undefined) {
/*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */
window.matchMedia =
window.matchMedia ||
(function (doc, undefined) {
var bool,
docElem = doc.documentElement,
refNode = docElem.firstElementChild || docElem.firstChild,
// fakeBody required for <FF4 when executed in <head>
fakeBody = doc.createElement("body"),
div = doc.createElement("div");
div.id = "mq-test-1";
div.style.cssText = "position:absolute;top:-100em";
fakeBody.style.background = "none";
fakeBody.appendChild(div);
return function (q) {
div.innerHTML =
'­<style media="' +
q +
'"> #mq-test-1 { width: 42px; }</style>';
docElem.insertBefore(fakeBody, refNode);
bool = div.offsetWidth === 42;
docElem.removeChild(fakeBody);
return {
matches: bool,
media: q,
};
};
})(document);
// $.mobile.media uses matchMedia to return a boolean.
$.mobile.media = function (q) {
return window.matchMedia(q).matches;
};
})(jQuery);
(function ($, undefined) {
var support = {
touch: "ontouchend" in document,
};
$.mobile.support = $.mobile.support || {};
$.extend($.support, support);
$.extend($.mobile.support, support);
})(jQuery);
(function ($, undefined) {
$.extend($.support, {
orientation: "orientation" in window && "onorientationchange" in window,
});
})(jQuery);
(function ($, undefined) {
// thx Modernizr
function propExists(prop) {
var uc_prop = prop.charAt(0).toUpperCase() + prop.substr(1),
props = (prop + " " + vendors.join(uc_prop + " ") + uc_prop).split(" "),
v;
for (v in props) {
if (fbCSS[props[v]] !== undefined) {
return true;
}
}
}
var fakeBody = $("<body>").prependTo("html"),
fbCSS = fakeBody[0].style,
vendors = ["Webkit", "Moz", "O"],
webos = "palmGetResource" in window, //only used to rule out scrollTop
operamini =
window.operamini &&
{}.toString.call(window.operamini) === "[object OperaMini]",
bb = window.blackberry && !propExists("-webkit-transform"), //only used to rule out box shadow, as it's filled opaque on BB 5 and lower
nokiaLTE7_3;
// inline SVG support test
function inlineSVG() {
// Thanks Modernizr & Erik Dahlstrom
var w = window,
svg =
!!w.document.createElementNS &&
!!w.document.createElementNS("http://www.w3.org/2000/svg", "svg")
.createSVGRect &&
!(w.opera && navigator.userAgent.indexOf("Chrome") === -1),
support = function (data) {
if (!(data && svg)) {
$("html").addClass("ui-nosvg");
}
},
img = new w.Image();
img.onerror = function () {
support(false);
};
img.onload = function () {
support(img.width === 1 && img.height === 1);
};
img.src =
"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
}
function transform3dTest() {
var mqProp = "transform-3d",
// Because the `translate3d` test below throws false positives in Android:
ret = $.mobile.media(
"(-" +
vendors.join("-" + mqProp + "),(-") +
"-" +
mqProp +
"),(" +
mqProp +
")",
),
el,
transforms,
t;
if (ret) {
return !!ret;
}
el = document.createElement("div");
transforms = {
// We’re omitting Opera for the time being; MS uses unprefixed.
MozTransform: "-moz-transform",
transform: "transform",
};
fakeBody.append(el);
for (t in transforms) {
if (el.style[t] !== undefined) {
el.style[t] = "translate3d( 100px, 1px, 1px )";
ret = window.getComputedStyle(el).getPropertyValue(transforms[t]);
}
}
return !!ret && ret !== "none";
}
// Test for dynamic-updating base tag support ( allows us to avoid href,src attr rewriting )
function baseTagTest() {
var fauxBase =
location.protocol +
"//" +
location.host +
location.pathname +
"ui-dir/",
base = $("head base"),
fauxEle = null,
href = "",
link,
rebase;
if (!base.length) {
base = fauxEle = $("<base>", { href: fauxBase }).appendTo("head");
} else {
href = base.attr("href");
}
link = $("<a href='testurl' />").prependTo(fakeBody);
rebase = link[0].href;
base[0].href = href || location.pathname;
if (fauxEle) {
fauxEle.remove();
}
return rebase.indexOf(fauxBase) === 0;
}
// Thanks Modernizr
function cssPointerEventsTest() {
var element = document.createElement("x"),
documentElement = document.documentElement,
getComputedStyle = window.getComputedStyle,
supports;
if (!("pointerEvents" in element.style)) {
return false;
}
element.style.pointerEvents = "auto";
element.style.pointerEvents = "x";
documentElement.appendChild(element);
supports =
getComputedStyle &&
getComputedStyle(element, "").pointerEvents === "auto";
documentElement.removeChild(element);
return !!supports;
}
function boundingRect() {
var div = document.createElement("div");
return typeof div.getBoundingClientRect !== "undefined";
}
// non-UA-based IE version check by James Padolsey, modified by jdalton - from http://gist.github.com/527683
// allows for inclusion of IE 6+, including Windows Mobile 7
$.extend($.mobile, { browser: {} });
$.mobile.browser.oldIE = (function () {
var v = 3,
div = document.createElement("div"),
a = div.all || [];
do {
div.innerHTML = "<!--[if gt IE " + ++v + "]><br><![endif]-->";
} while (a[0]);
return v > 4 ? v : !v;
})();
function fixedPosition() {
var w = window,
ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match(/AppleWebKit\/([0-9]+)/),
wkversion = !!wkmatch && wkmatch[1],
ffmatch = ua.match(/Fennec\/([0-9]+)/),
ffversion = !!ffmatch && ffmatch[1],
operammobilematch = ua.match(/Opera Mobi\/([0-9]+)/),
omversion = !!operammobilematch && operammobilematch[1];
if (
// iOS 4.3 and older : Platform is iPhone/Pad/Touch and Webkit version is less than 534 (ios5)
((platform.indexOf("iPhone") > -1 ||
platform.indexOf("iPad") > -1 ||
platform.indexOf("iPod") > -1) &&
wkversion &&
wkversion < 534) ||
// Opera Mini
(w.operamini &&
{}.toString.call(w.operamini) === "[object OperaMini]") ||
(operammobilematch && omversion < 7458) ||
//Android lte 2.1: Platform is Android and Webkit version is less than 533 (Android 2.2)
(ua.indexOf("Android") > -1 && wkversion && wkversion < 533) ||
// Firefox Mobile before 6.0 -
(ffversion && ffversion < 6) ||
// WebOS less than 3
("palmGetResource" in window && wkversion && wkversion < 534) ||
// MeeGo
(ua.indexOf("MeeGo") > -1 && ua.indexOf("NokiaBrowser/8.5.0") > -1)
) {
return false;
}
return true;
}
$.extend($.support, {
// Note, Chrome for iOS has an extremely quirky implementation of popstate.
// We've chosen to take the shortest path to a bug fix here for issue #5426
// See the following link for information about the regex chosen
// https://developers.google.com/chrome/mobile/docs/user-agent#chrome_for_ios_user-agent
pushState:
"pushState" in history &&
"replaceState" in history &&
// When running inside a FF iframe, calling replaceState causes an error
!(
window.navigator.userAgent.indexOf("Firefox") >= 0 &&
window.top !== window
) &&
window.navigator.userAgent.search(/CriOS/) === -1,
mediaquery: $.mobile.media("only all"),
cssPseudoElement: !!propExists("content"),
touchOverflow: !!propExists("overflowScrolling"),
cssTransform3d: transform3dTest(),
boxShadow: !!propExists("boxShadow") && !bb,
fixedPosition: fixedPosition(),
scrollTop:
("pageXOffset" in window ||
"scrollTop" in document.documentElement ||
"scrollTop" in fakeBody[0]) &&
!webos &&
!operamini,
dynamicBaseTag: baseTagTest(),
cssPointerEvents: cssPointerEventsTest(),
boundingRect: boundingRect(),
inlineSVG: inlineSVG,
});
fakeBody.remove();
// $.mobile.ajaxBlacklist is used to override ajaxEnabled on platforms that have known conflicts with hash history updates (BB5, Symbian)
// or that generally work better browsing in regular http for full page refreshes (Opera Mini)
// Note: This detection below is used as a last resort.
// We recommend only using these detection methods when all other more reliable/forward-looking approaches are not possible
nokiaLTE7_3 = (function () {
var ua = window.navigator.userAgent;
//The following is an attempt to match Nokia browsers that are running Symbian/s60, with webkit, version 7.3 or older
return (
ua.indexOf("Nokia") > -1 &&
(ua.indexOf("Symbian/3") > -1 || ua.indexOf("Series60/5") > -1) &&
ua.indexOf("AppleWebKit") > -1 &&
ua.match(/(BrowserNG|NokiaBrowser)\/7\.[0-3]/)
);
})();
// Support conditions that must be met in order to proceed
// default enhanced qualifications are media query support OR IE 7+
$.mobile.gradeA = function () {
return (
(($.support.mediaquery && $.support.cssPseudoElement) ||
($.mobile.browser.oldIE && $.mobile.browser.oldIE >= 8)) &&
($.support.boundingRect ||
$.fn.jquery.match(/1\.[0-7+]\.[0-9+]?/) !== null)
);
};
$.mobile.ajaxBlacklist =
// BlackBerry browsers, pre-webkit
(window.blackberry && !window.WebKitPoint) ||
// Opera Mini
operamini ||
// Symbian webkits pre 7.3
nokiaLTE7_3;
// Lastly, this workaround is the only way we've found so far to get pre 7.3 Symbian webkit devices
// to render the stylesheets when they're referenced before this script, as we'd recommend doing.
// This simply reappends the CSS in place, which for some reason makes it apply
if (nokiaLTE7_3) {
$(function () {
$("head link[rel='stylesheet']")
.attr("rel", "alternate stylesheet")
.attr("rel", "stylesheet");
});
}
// For ruling out shadows via css
if (!$.support.boxShadow) {
$("html").addClass("ui-noboxshadow");
}
})(jQuery);
(function ($, undefined) {
var $win = $.mobile.window,
self,
dummyFnToInitNavigate = function () {};
$.event.special.beforenavigate = {
setup: function () {
$win.on("navigate", dummyFnToInitNavigate);
},
teardown: function () {
$win.off("navigate", dummyFnToInitNavigate);
},
};
$.event.special.navigate = self = {
bound: false,
pushStateEnabled: true,
originalEventName: undefined,
// If pushstate support is present and push state support is defined to
// be true on the mobile namespace.
isPushStateEnabled: function () {
return (
$.support.pushState &&
$.mobile.pushStateEnabled === true &&
this.isHashChangeEnabled()
);
},
// !! assumes mobile namespace is present
isHashChangeEnabled: function () {
return $.mobile.hashListeningEnabled === true;
},
// TODO a lot of duplication between popstate and hashchange
popstate: function (event) {
var newEvent = new $.Event("navigate"),
beforeNavigate = new $.Event("beforenavigate"),
state = event.originalEvent.state || {};
beforeNavigate.originalEvent = event;
$win.trigger(beforeNavigate);
if (beforeNavigate.isDefaultPrevented()) {
return;
}
if (event.historyState) {
$.extend(state, event.historyState);
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// NOTE we let the current stack unwind because any assignment to
// location.hash will stop the world and run this event handler. By
// doing this we create a similar behavior to hashchange on hash
// assignment
setTimeout(function () {
$win.trigger(newEvent, {
state: state,
});
}, 0);
},
hashchange: function (event /*, data */) {
var newEvent = new $.Event("navigate"),
beforeNavigate = new $.Event("beforenavigate");
beforeNavigate.originalEvent = event;
$win.trigger(beforeNavigate);
if (beforeNavigate.isDefaultPrevented()) {
return;
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// Trigger the hashchange with state provided by the user
// that altered the hash
$win.trigger(newEvent, {
// Users that want to fully normalize the two events
// will need to do history management down the stack and
// add the state to the event before this binding is fired
// TODO consider allowing for the explicit addition of callbacks
// to be fired before this value is set to avoid event timing issues
state: event.hashchangeState || {},
});
},
// TODO We really only want to set this up once
// but I'm not clear if there's a beter way to achieve
// this with the jQuery special event structure
setup: function (/* data, namespaces */) {
if (self.bound) {
return;
}
self.bound = true;
if (self.isPushStateEnabled()) {
self.originalEventName = "popstate";
$win.bind("popstate.navigate", self.popstate);
} else if (self.isHashChangeEnabled()) {
self.originalEventName = "hashchange";
$win.bind("hashchange.navigate", self.hashchange);
}
},
};
})(jQuery);
(function ($, undefined) {
var path,
$base,
dialogHashKey = "&ui-state=dialog";
$.mobile.path = path = {
uiStateKey: "&ui-state",
// This scary looking regular expression parses an absolute URL or its relative
// variants (protocol, site, document, query, and hash), into the various
// components (protocol, host, path, query, fragment, etc that make up the
// URL as well as some other commonly used sub-parts. When used with RegExp.exec()
// or String.match, it parses the URL into a results array that looks like this:
//
// [0]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread#msg-content
// [1]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread
// [2]: http://jblas:password@mycompany.com:8080/mail/inbox
// [3]: http://jblas:password@mycompany.com:8080
// [4]: http:
// [5]: //
// [6]: jblas:password@mycompany.com:8080
// [7]: jblas:password
// [8]: jblas
// [9]: password
// [10]: mycompany.com:8080
// [11]: mycompany.com
// [12]: 8080
// [13]: /mail/inbox
// [14]: /mail/
// [15]: inbox
// [16]: ?msg=1234&type=unread
// [17]: #msg-content
//
urlParseRE:
/^\s*(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
// Abstraction to address xss (Issue #4787) by removing the authority in
// browsers that auto decode it. All references to location.href should be
// replaced with a call to this method so that it can be dealt with properly here
getLocation: function (url) {
var uri = url ? this.parseUrl(url) : location,
hash = this.parseUrl(url || location.href).hash;
// mimic the browser with an empty string when the hash is empty
hash = hash === "#" ? "" : hash;
// Make sure to parse the url or the location object for the hash because using location.hash
// is autodecoded in firefox, the rest of the url should be from the object (location unless
// we're testing) to avoid the inclusion of the authority
return (
uri.protocol + "//" + uri.host + uri.pathname + uri.search + hash
);
},
//return the original document url
getDocumentUrl: function (asParsedObject) {
return asParsedObject
? $.extend({}, path.documentUrl)
: path.documentUrl.href;
},
parseLocation: function () {
return this.parseUrl(this.getLocation());
},
//Parse a URL into a structure that allows easy access to
//all of the URL components by name.
parseUrl: function (url) {
// If we're passed an object, we'll assume that it is
// a parsed url object and just return it back to the caller.
if ($.type(url) === "object") {
return url;
}
var matches = path.urlParseRE.exec(url || "") || [];
// Create an object that allows the caller to access the sub-matches
// by name. Note that IE returns an empty string instead of undefined,
// like all other browsers do, so we normalize everything so its consistent
// no matter what browser we're running on.
return {
href: matches[0] || "",
hrefNoHash: matches[1] || "",
hrefNoSearch: matches[2] || "",
domain: matches[3] || "",
protocol: matches[4] || "",
doubleSlash: matches[5] || "",
authority: matches[6] || "",
username: matches[8] || "",
password: matches[9] || "",
host: matches[10] || "",
hostname: matches[11] || "",
port: matches[12] || "",
pathname: matches[13] || "",
directory: matches[14] || "",
filename: matches[15] || "",
search: matches[16] || "",
hash: matches[17] || "",
};
},
//Turn relPath into an asbolute path. absPath is
//an optional absolute path which describes what
//relPath is relative to.
makePathAbsolute: function (relPath, absPath) {
var absStack, relStack, i, d;
if (relPath && relPath.charAt(0) === "/") {
return relPath;
}
relPath = relPath || "";
absPath = absPath ? absPath.replace(/^\/|(\/[^\/]*|[^\/]+)$/g, "") : "";
absStack = absPath ? absPath.split("/") : [];
relStack = relPath.split("/");
for (i = 0; i < relStack.length; i++) {
d = relStack[i];
switch (d) {
case ".":
break;
case "..":
if (absStack.length) {
absStack.pop();
}
break;
default:
absStack.push(d);
break;
}
}
return "/" + absStack.join("/");
},
//Returns true if both urls have the same domain.
isSameDomain: function (absUrl1, absUrl2) {
return path.parseUrl(absUrl1).domain === path.parseUrl(absUrl2).domain;
},
//Returns true for any relative variant.
isRelativeUrl: function (url) {
// All relative Url variants have one thing in common, no protocol.
return path.parseUrl(url).protocol === "";
},
//Returns true for an absolute url.
isAbsoluteUrl: function (url) {
return path.parseUrl(url).protocol !== "";
},
//Turn the specified realtive URL into an absolute one. This function
//can handle all relative variants (protocol, site, document, query, fragment).
makeUrlAbsolute: function (relUrl, absUrl) {
if (!path.isRelativeUrl(relUrl)) {
return relUrl;
}
if (absUrl === undefined) {
absUrl = this.documentBase;
}
var relObj = path.parseUrl(relUrl),
absObj = path.parseUrl(absUrl),
protocol = relObj.protocol || absObj.protocol,
doubleSlash = relObj.protocol
? relObj.doubleSlash
: relObj.doubleSlash || absObj.doubleSlash,
authority = relObj.authority || absObj.authority,
hasPath = relObj.pathname !== "",
pathname = path.makePathAbsolute(
relObj.pathname || absObj.filename,
absObj.pathname,
),
search = relObj.search || (!hasPath && absObj.search) || "",
hash = relObj.hash;
return protocol + doubleSlash + authority + pathname + search + hash;
},
//Add search (aka query) params to the specified url.
addSearchParams: function (url, params) {
var u = path.parseUrl(url),
p = typeof params === "object" ? $.param(params) : params,
s = u.search || "?";
return (
u.hrefNoSearch +
s +
(s.charAt(s.length - 1) !== "?" ? "&" : "") +
p +
(u.hash || "")
);
},
convertUrlToDataUrl: function (absUrl) {
var u = path.parseUrl(absUrl);
if (path.isEmbeddedPage(u)) {
// For embedded pages, remove the dialog hash key as in getFilePath(),
// and remove otherwise the Data Url won't match the id of the embedded Page.
return u.hash
.split(dialogHashKey)[0]
.replace(/^#/, "")
.replace(/\?.*$/, "");
} else if (path.isSameDomain(u, this.documentBase)) {
return u.hrefNoHash
.replace(this.documentBase.domain, "")
.split(dialogHashKey)[0];
}
return window.decodeURIComponent(absUrl);
},
//get path from current hash, or from a file path
get: function (newPath) {
if (newPath === undefined) {
newPath = path.parseLocation().hash;
}
return path.stripHash(newPath).replace(/[^\/]*\.[^\/*]+$/, "");
},
//set location hash to path
set: function (path) {
location.hash = path;
},
//test if a given url (string) is a path
//NOTE might be exceptionally naive
isPath: function (url) {
return /\//.test(url);
},
//return a url path with the window's location protocol/hostname/pathname removed
clean: function (url) {
return url.replace(this.documentBase.domain, "");
},
//just return the url without an initial #
stripHash: function (url) {
return url.replace(/^#/, "");
},
stripQueryParams: function (url) {
return url.replace(/\?.*$/, "");
},
//remove the preceding hash, any query params, and dialog notations
cleanHash: function (hash) {
return path.stripHash(
hash.replace(/\?.*$/, "").replace(dialogHashKey, ""),
);
},
isHashValid: function (hash) {
return /^#[^#]+$/.test(hash);
},
//check whether a url is referencing the same domain, or an external domain or different protocol
//could be mailto, etc
isExternal: function (url) {
var u = path.parseUrl(url);
return u.protocol && u.domain !== this.documentUrl.domain
? true
: false;
},
hasProtocol: function (url) {
return /^(:?\w+:)/.test(url);
},
isEmbeddedPage: function (url) {
var u = path.parseUrl(url);
//if the path is absolute, then we need to compare the url against
//both the this.documentUrl and the documentBase. The main reason for this
//is that links embedded within external documents will refer to the
//application document, whereas links embedded within the application
//document will be resolved against the document base.
if (u.protocol !== "") {
return (
!this.isPath(u.hash) &&
u.hash &&
(u.hrefNoHash === this.documentUrl.hrefNoHash ||
(this.documentBaseDiffers &&
u.hrefNoHash === this.documentBase.hrefNoHash))
);
}
return /^#/.test(u.href);
},
squash: function (url, resolutionUrl) {
var href,
cleanedUrl,
search,
stateIndex,
isPath = this.isPath(url),
uri = this.parseUrl(url),
preservedHash = uri.hash,
uiState = "";
// produce a url against which we can resole the provided path
resolutionUrl =
resolutionUrl ||
(path.isPath(url) ? path.getLocation() : path.getDocumentUrl());
// If the url is anything but a simple string, remove any preceding hash
// eg #foo/bar -> foo/bar
// #foo -> #foo
cleanedUrl = isPath ? path.stripHash(url) : url;
// If the url is a full url with a hash check if the parsed hash is a path
// if it is, strip the #, and use it otherwise continue without change
cleanedUrl = path.isPath(uri.hash)
? path.stripHash(uri.hash)
: cleanedUrl;
// Split the UI State keys off the href
stateIndex = cleanedUrl.indexOf(this.uiStateKey);
// store the ui state keys for use
if (stateIndex > -1) {
uiState = cleanedUrl.slice(stateIndex);
cleanedUrl = cleanedUrl.slice(0, stateIndex);
}
// make the cleanedUrl absolute relative to the resolution url
href = path.makeUrlAbsolute(cleanedUrl, resolutionUrl);
// grab the search from the resolved url since parsing from
// the passed url may not yield the correct result
search = this.parseUrl(href).search;
// TODO all this crap is terrible, clean it up
if (isPath) {
// reject the hash if it's a path or it's just a dialog key
if (
path.isPath(preservedHash) ||
preservedHash.replace("#", "").indexOf(this.uiStateKey) === 0
) {
preservedHash = "";
}
// Append the UI State keys where it exists and it's been removed
// from the url
if (uiState && preservedHash.indexOf(this.uiStateKey) === -1) {
preservedHash += uiState;
}
// make sure that pound is on the front of the hash
if (preservedHash.indexOf("#") === -1 && preservedHash !== "") {
preservedHash = "#" + preservedHash;
}
// reconstruct each of the pieces with the new search string and hash
href = path.parseUrl(href);
href =
href.protocol +
"//" +
href.host +
href.pathname +
search +
preservedHash;
} else {
href += href.indexOf("#") > -1 ? uiState : "#" + uiState;
}
return href;
},
isPreservableHash: function (hash) {
return hash.replace("#", "").indexOf(this.uiStateKey) === 0;
},
// Escape weird characters in the hash if it is to be used as a selector
hashToSelector: function (hash) {
var hasHash = hash.substring(0, 1) === "#";
if (hasHash) {
hash = hash.substring(1);
}
return (
(hasHash ? "#" : "") +
hash.replace(/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$1")
);
},
// return the substring of a filepath before the sub-page key, for making
// a server request
getFilePath: function (path) {
var splitkey = "&" + $.mobile.subPageUrlKey;
return path && path.split(splitkey)[0].split(dialogHashKey)[0];
},
// check if the specified url refers to the first page in the main
// application document.
isFirstPageUrl: function (url) {
// We only deal with absolute paths.
var u = path.parseUrl(path.makeUrlAbsolute(url, this.documentBase)),
// Does the url have the same path as the document?
samePath =
u.hrefNoHash === this.documentUrl.hrefNoHash ||
(this.documentBaseDiffers &&
u.hrefNoHash === this.documentBase.hrefNoHash),
// Get the first page element.
fp = $.mobile.firstPage,
// Get the id of the first page element if it has one.
fpId = fp && fp[0] ? fp[0].id : undefined;
// The url refers to the first page if the path matches the document and
// it either has no hash value, or the hash is exactly equal to the id
// of the first page element.
return (
samePath &&
(!u.hash ||
u.hash === "#" ||
(fpId && u.hash.replace(/^#/, "") === fpId))
);
},
// Some embedded browsers, like the web view in Phone Gap, allow
// cross-domain XHR requests if the document doing the request was loaded
// via the file:// protocol. This is usually to allow the application to
// "phone home" and fetch app specific data. We normally let the browser
// handle external/cross-domain urls, but if the allowCrossDomainPages
// option is true, we will allow cross-domain http/https requests to go
// through our page loading logic.
isPermittedCrossDomainRequest: function (docUrl, reqUrl) {
return (
$.mobile.allowCrossDomainPages &&
(docUrl.protocol === "file:" || docUrl.protocol === "content:") &&
reqUrl.search(/^https?:/) !== -1
);
},
};
path.documentUrl = path.parseLocation();
$base = $("head").find("base");
path.documentBase = $base.length
? path.parseUrl(
path.makeUrlAbsolute($base.attr("href"), path.documentUrl.href),
)
: path.documentUrl;
path.documentBaseDiffers =
path.documentUrl.hrefNoHash !== path.documentBase.hrefNoHash;
//return the original document base url
path.getDocumentBase = function (asParsedObject) {
return asParsedObject
? $.extend({}, path.documentBase)
: path.documentBase.href;
};
// DEPRECATED as of 1.4.0 - remove in 1.5.0
$.extend($.mobile, {
//return the original document url
getDocumentUrl: path.getDocumentUrl,
//return the original document base url
getDocumentBase: path.getDocumentBase,
});
})(jQuery);
(function ($, undefined) {
$.mobile.History = function (stack, index) {
this.stack = stack || [];
this.activeIndex = index || 0;
};
$.extend($.mobile.History.prototype, {
getActive: function () {
return this.stack[this.activeIndex];
},
getLast: function () {
return this.stack[this.previousIndex];
},
getNext: function () {
return this.stack[this.activeIndex + 1];
},
getPrev: function () {
return this.stack[this.activeIndex - 1];
},
// addNew is used whenever a new page is added
add: function (url, data) {
data = data || {};
//if there's forward history, wipe it
if (this.getNext()) {
this.clearForward();
}
// if the hash is included in the data make sure the shape
// is consistent for comparison
if (data.hash && data.hash.indexOf("#") === -1) {
data.hash = "#" + data.hash;
}
data.url = url;
this.stack.push(data);
this.activeIndex = this.stack.length - 1;
},
//wipe urls ahead of active index
clearForward: function () {
this.stack = this.stack.slice(0, this.activeIndex + 1);
},
find: function (url, stack, earlyReturn) {
stack = stack || this.stack;
var entry,
i,
length = stack.length,
index;
for (i = 0; i < length; i++) {
entry = stack[i];
if (
decodeURIComponent(url) === decodeURIComponent(entry.url) ||
decodeURIComponent(url) === decodeURIComponent(entry.hash)
) {
index = i;
if (earlyReturn) {
return index;
}
}
}
return index;
},
closest: function (url) {
var closest,
a = this.activeIndex;
// First, take the slice of the history stack before the current index and search
// for a url match. If one is found, we'll avoid avoid looking through forward history
// NOTE the preference for backward history movement is driven by the fact that
// most mobile browsers only have a dedicated back button, and users rarely use
// the forward button in desktop browser anyhow
closest = this.find(url, this.stack.slice(0, a));
// If nothing was found in backward history check forward. The `true`
// value passed as the third parameter causes the find method to break
// on the first match in the forward history slice. The starting index
// of the slice must then be added to the result to get the element index
// in the original history stack :( :(
//
// TODO this is hyper confusing and should be cleaned up (ugh so bad)
if (closest === undefined) {
closest = this.find(url, this.stack.slice(a), true);
closest = closest === undefined ? closest : closest + a;
}
return closest;
},
direct: function (opts) {
var newActiveIndex = this.closest(opts.url),
a = this.activeIndex;
// save new page index, null check to prevent falsey 0 result
// record the previous index for reference
if (newActiveIndex !== undefined) {
this.activeIndex = newActiveIndex;
this.previousIndex = a;
}
// invoke callbacks where appropriate
//
// TODO this is also convoluted and confusing
if (newActiveIndex < a) {
(opts.present || opts.back || $.noop)(this.getActive(), "back");
} else if (newActiveIndex > a) {
(opts.present || opts.forward || $.noop)(this.getActive(), "forward");
} else if (newActiveIndex === undefined && opts.missing) {
opts.missing(this.getActive());
}
},
});
})(jQuery);
(function ($, undefined) {
var path = $.mobile.path,
initialHref = location.href;
$.mobile.Navigator = function (history) {
this.history = history;
this.ignoreInitialHashChange = true;
$.mobile.window.bind({
"popstate.history": $.proxy(this.popstate, this),
"hashchange.history": $.proxy(this.hashchange, this),
});
};
$.extend($.mobile.Navigator.prototype, {
squash: function (url, data) {
var state,
href,
hash = path.isPath(url) ? path.stripHash(url) : url;
href = path.squash(url);
// make sure to provide this information when it isn't explicitly set in the
// data object that was passed to the squash method
state = $.extend(
{
hash: hash,
url: href,
},
data,
);
// replace the current url with the new href and store the state
// Note that in some cases we might be replacing an url with the
// same url. We do this anyways because we need to make sure that
// all of our history entries have a state object associated with
// them. This allows us to work around the case where $.mobile.back()
// is called to transition from an external page to an embedded page.
// In that particular case, a hashchange event is *NOT* generated by the browser.
// Ensuring each history entry has a state object means that onPopState()
// will always trigger our hashchange callback even when a hashchange event
// is not fired.
window.history.replaceState(state, state.title || document.title, href);
return state;
},
hash: function (url, href) {
var parsed, loc, hash, resolved;
// Grab the hash for recording. If the passed url is a path
// we used the parsed version of the squashed url to reconstruct,
// otherwise we assume it's a hash and store it directly
parsed = path.parseUrl(url);
loc = path.parseLocation();
if (loc.pathname + loc.search === parsed.pathname + parsed.search) {
// If the pathname and search of the passed url is identical to the current loc
// then we must use the hash. Otherwise there will be no event
// eg, url = "/foo/bar?baz#bang", location.href = "http://example.com/foo/bar?baz"
hash = parsed.hash ? parsed.hash : parsed.pathname + parsed.search;
} else if (path.isPath(url)) {
resolved = path.parseUrl(href);
// If the passed url is a path, make it domain relative and remove any trailing hash
hash =
resolved.pathname +
resolved.search +
(path.isPreservableHash(resolved.hash)
? resolved.hash.replace("#", "")
: "");
} else {
hash = url;
}
return hash;
},
// TODO reconsider name
go: function (url, data, noEvents) {
var state,
href,
hash,
popstateEvent,
isPopStateEvent = $.event.special.navigate.isPushStateEnabled();
// Get the url as it would look squashed on to the current resolution url
href = path.squash(url);
// sort out what the hash sould be from the url
hash = this.hash(url, href);
// Here we prevent the next hash change or popstate event from doing any
// history management. In the case of hashchange we don't swallow it
// if there will be no hashchange fired (since that won't reset the value)
// and will swallow the following hashchange
if (noEvents && hash !== path.stripHash(path.parseLocation().hash)) {
this.preventNextHashChange = noEvents;
}
// IMPORTANT in the case where popstate is supported the event will be triggered
// directly, stopping further execution - ie, interupting the flow of this
// method call to fire bindings at this expression. Below the navigate method
// there is a binding to catch this event and stop its propagation.
//
// We then trigger a new popstate event on the window with a null state
// so that the navigate events can conclude their work properly
//
// if the url is a path we want to preserve the query params that are available on
// the current url.
this.preventHashAssignPopState = true;
window.location.hash = hash;
// If popstate is enabled and the browser triggers `popstate` events when the hash
// is set (this often happens immediately in browsers like Chrome), then the
// this flag will be set to false already. If it's a browser that does not trigger
// a `popstate` on hash assignement or `replaceState` then we need avoid the branch
// that swallows the event created by the popstate generated by the hash assignment
// At the time of this writing this happens with Opera 12 and some version of IE
this.preventHashAssignPopState = false;
state = $.extend(
{
url: href,
hash: hash,
title: document.title,
},
data,
);
if (isPopStateEvent) {
popstateEvent = new $.Event("popstate");
popstateEvent.originalEvent = {
type: "popstate",
state: null,
};
this.squash(url, state);
// Trigger a new faux popstate event to replace the one that we
// caught that was triggered by the hash setting above.
if (!noEvents) {
this.ignorePopState = true;
$.mobile.window.trigger(popstateEvent);
}
}
// record the history entry so that the information can be included
// in hashchange event driven navigate events in a similar fashion to
// the state that's provided by popstate
this.history.add(state.url, state);
},
// This binding is intended to catch the popstate events that are fired
// when execution of the `$.navigate` method stops at window.location.hash = url;
// and completely prevent them from propagating. The popstate event will then be
// retriggered after execution resumes
//
// TODO grab the original event here and use it for the synthetic event in the
// second half of the navigate execution that will follow this binding
popstate: function (event) {
var hash, state;
// Partly to support our test suite which manually alters the support
// value to test hashchange. Partly to prevent all around weirdness
if (!$.event.special.navigate.isPushStateEnabled()) {
return;
}
// If this is the popstate triggered by the actual alteration of the hash
// prevent it completely. History is tracked manually
if (this.preventHashAssignPopState) {
this.preventHashAssignPopState = false;
event.stopImmediatePropagation();
return;
}
// if this is the popstate triggered after the `replaceState` call in the go
// method, then simply ignore it. The history entry has already been captured
if (this.ignorePopState) {
this.ignorePopState = false;
return;
}
// If there is no state, and the history stack length is one were
// probably getting the page load popstate fired by browsers like chrome
// avoid it and set the one time flag to false.
// TODO: Do we really need all these conditions? Comparing location hrefs
// should be sufficient.
if (
!event.originalEvent.state &&
this.history.stack.length === 1 &&
this.ignoreInitialHashChange
) {
this.ignoreInitialHashChange = false;
if (location.href === initialHref) {
event.preventDefault();
return;
}
}
// account for direct manipulation of the hash. That is, we will receive a popstate
// when the hash is changed by assignment, and it won't have a state associated. We
// then need to squash the hash. See below for handling of hash assignment that
// matches an existing history entry
// TODO it might be better to only add to the history stack
// when the hash is adjacent to the active history entry
hash = path.parseLocation().hash;
if (!event.originalEvent.state && hash) {
// squash the hash that's been assigned on the URL with replaceState
// also grab the resulting state object for storage
state = this.squash(hash);
// record the new hash as an additional history entry
// to match the browser's treatment of hash assignment
this.history.add(state.url, state);
// pass the newly created state information
// along with the event
event.historyState = state;
// do not alter history, we've added a new history entry
// so we know where we are
return;
}
// If all else fails this is a popstate that comes from the back or forward buttons
// make sure to set the state of our history stack properly, and record the directionality
this.history.direct({
url: (event.originalEvent.state || {}).url || hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function (historyEntry, direction) {
// make sure to create a new object to pass down as the navigate event data
event.historyState = $.extend({}, historyEntry);
event.historyState.direction = direction;
},
});
},
// NOTE must bind before `navigate` special event hashchange binding otherwise the
// navigation data won't be attached to the hashchange event in time for those
// bindings to attach it to the `navigate` special event
// TODO add a check here that `hashchange.navigate` is bound already otherwise it's
// broken (exception?)
hashchange: function (event) {
var history, hash;
// If hashchange listening is explicitly disabled or pushstate is supported
// avoid making use of the hashchange handler.
if (
!$.event.special.navigate.isHashChangeEnabled() ||
$.event.special.navigate.isPushStateEnabled()
) {
return;
}
// On occasion explicitly want to prevent the next hash from propogating because we only
// with to alter the url to represent the new state do so here
if (this.preventNextHashChange) {
this.preventNextHashChange = false;
event.stopImmediatePropagation();
return;
}
history = this.history;
hash = path.parseLocation().hash;
// If this is a hashchange caused by the back or forward button
// make sure to set the state of our history stack properly
this.history.direct({
url: hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function (historyEntry, direction) {
// make sure to create a new object to pass down as the navigate event data
event.hashchangeState = $.extend({}, historyEntry);
event.hashchangeState.direction = direction;
},
// When we don't find a hash in our history clearly we're aiming to go there
// record the entry as new for future traversal
//
// NOTE it's not entirely clear that this is the right thing to do given that we
// can't know the users intention. It might be better to explicitly _not_
// support location.hash assignment in preference to $.navigate calls
// TODO first arg to add should be the href, but it causes issues in identifying
// embeded pages
missing: function () {
history.add(hash, {
hash: hash,
title: document.title,
});
},
});
},
});
})(jQuery);
(function ($, undefined) {
// TODO consider queueing navigation activity until previous activities have completed
// so that end users don't have to think about it. Punting for now
// TODO !! move the event bindings into callbacks on the navigate event
$.mobile.navigate = function (url, data, noEvents) {
$.mobile.navigate.navigator.go(url, data, noEvents);
};
// expose the history on the navigate method in anticipation of full integration with
// existing navigation functionalty that is tightly coupled to the history information
$.mobile.navigate.history = new $.mobile.History();
// instantiate an instance of the navigator for use within the $.navigate method
$.mobile.navigate.navigator = new $.mobile.Navigator(
$.mobile.navigate.history,
);
var loc = $.mobile.path.parseLocation();
$.mobile.navigate.history.add(loc.href, { hash: loc.hash });
})(jQuery);
(function ($, undefined) {
var props = {
animation: {},
transition: {},
},
testElement = document.createElement("a"),
vendorPrefixes = ["", "webkit-", "moz-", "o-"];
$.each(["animation", "transition"], function (i, test) {
// Get correct name for test
var testName = i === 0 ? test + "-" + "name" : test;
$.each(vendorPrefixes, function (j, prefix) {
if (testElement.style[$.camelCase(prefix + testName)] !== undefined) {
props[test]["prefix"] = prefix;
return false;
}
});
// Set event and duration names for later use
props[test]["duration"] = $.camelCase(
props[test]["prefix"] + test + "-" + "duration",
);
props[test]["event"] = $.camelCase(
props[test]["prefix"] + test + "-" + "end",
);
// All lower case if not a vendor prop
if (props[test]["prefix"] === "") {
props[test]["event"] = props[test]["event"].toLowerCase();
}
});
// If a valid prefix was found then the it is supported by the browser
$.support.cssTransitions = props["transition"]["prefix"] !== undefined;
$.support.cssAnimations = props["animation"]["prefix"] !== undefined;
// Remove the testElement
$(testElement).remove();
// Animation complete callback
$.fn.animationComplete = function (callback, type, fallbackTime) {
var timer,
duration,
that = this,
animationType =
!type || type === "animation" ? "animation" : "transition";
// Make sure selected type is supported by browser
if (
($.support.cssTransitions && animationType === "transition") ||
($.support.cssAnimations && animationType === "animation")
) {
// If a fallback time was not passed set one
if (fallbackTime === undefined) {
// Make sure the was not bound to document before checking .css
if ($(this).context !== document) {
// Parse the durration since its in second multiple by 1000 for milliseconds
// Multiply by 3 to make sure we give the animation plenty of time.
duration =
parseFloat($(this).css(props[animationType].duration)) * 3000;
}
// If we could not read a duration use the default
if (duration === 0 || duration === undefined || isNaN(duration)) {
duration = $.fn.animationComplete.defaultDuration;
}
}
// Sets up the fallback if event never comes
timer = setTimeout(function () {
$(that).off(props[animationType].event);
callback.apply(that);
}, duration);
// Bind the event
return $(this).one(props[animationType].event, function () {
// Clear the timer so we dont call callback twice
clearTimeout(timer);
callback.call(this, arguments);
});
} else {
// CSS animation / transitions not supported
// Defer execution for consistency between webkit/non webkit
setTimeout($.proxy(callback, this), 0);
return $(this);
}
};
// Allow default callback to be configured on mobileInit
$.fn.animationComplete.defaultDuration = 1000;
})(jQuery);
// This plugin is an experiment for abstracting away the touch and mouse
// events so that developers don't have to worry about which method of input
// the device their document is loaded on supports.
//
// The idea here is to allow the developer to register listeners for the
// basic mouse events, such as mousedown, mousemove, mouseup, and click,
// and the plugin will take care of registering the correct listeners
// behind the scenes to invoke the listener at the fastest possible time
// for that device, while still retaining the order of event firing in
// the traditional mouse environment, should multiple handlers be registered
// on the same element for different events.
//
// The current version exposes the following virtual events to jQuery bind methods:
// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
(function ($, window, document, undefined) {
var dataPropertyName = "virtualMouseBindings",
touchTargetPropertyName = "virtualTouchID",
virtualEventNames =
"vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split(
" ",
),
touchEventProps = "clientX clientY pageX pageY screenX screenY".split(
" ",
),
mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [],
mouseEventProps = $.event.props.concat(mouseHookProps),
activeDocHandlers = {},
resetTimerID = 0,
startX = 0,
startY = 0,
didScroll = false,
clickBlockList = [],
blockMouseTriggers = false,
blockTouchTriggers = false,
eventCaptureSupported = "addEventListener" in document,
$document = $(document),
nextTouchID = 1,
lastTouchID = 0,
threshold,
i;
$.vmouse = {
moveDistanceThreshold: 10,
clickDistanceThreshold: 10,
resetTimerDuration: 1500,
};
function getNativeEvent(event) {
while (event && typeof event.originalEvent !== "undefined") {
event = event.originalEvent;
}
return event;
}
function createVirtualEvent(event, eventType) {
var t = event.type,
oe,
props,
ne,
prop,
ct,
touch,
i,
j,
len;
event = $.Event(event);
event.type = eventType;
oe = event.originalEvent;
props = $.event.props;
// addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280
// https://github.com/jquery/jquery-mobile/issues/3280
if (t.search(/^(mouse|click)/) > -1) {
props = mouseEventProps;
}
// copy original event properties over to the new event
// this would happen if we could call $.event.fix instead of $.Event
// but we don't have a way to force an event to be fixed multiple times
if (oe) {
for (i = props.length, prop; i; ) {
prop = props[--i];
event[prop] = oe[prop];
}
}
// make sure that if the mouse and click virtual events are generated
// without a .which one is defined
if (t.search(/mouse(down|up)|click/) > -1 && !event.which) {
event.which = 1;
}
if (t.search(/^touch/) !== -1) {
ne = getNativeEvent(oe);
t = ne.touches;
ct = ne.changedTouches;
touch = t && t.length ? t[0] : ct && ct.length ? ct[0] : undefined;
if (touch) {
for (j = 0, len = touchEventProps.length; j < len; j++) {
prop = touchEventProps[j];
event[prop] = touch[prop];
}
}
}
return event;
}
function getVirtualBindingFlags(element) {
var flags = {},
b,
k;
while (element) {
b = $.data(element, dataPropertyName);
for (k in b) {
if (b[k]) {
flags[k] = flags.hasVirtualBinding = true;
}
}
element = element.parentNode;
}
return flags;
}
function getClosestElementWithVirtualBinding(element, eventType) {
var b;
while (element) {
b = $.data(element, dataPropertyName);
if (b && (!eventType || b[eventType])) {
return element;
}
element = element.parentNode;
}
return null;
}
function enableTouchBindings() {
blockTouchTriggers = false;
}
function disableTouchBindings() {
blockTouchTriggers = true;
}
function enableMouseBindings() {
lastTouchID = 0;
clickBlockList.length = 0;
blockMouseTriggers = false;
// When mouse bindings are enabled, our
// touch bindings are disabled.
disableTouchBindings();
}
function disableMouseBindings() {
// When mouse bindings are disabled, our
// touch bindings are enabled.
enableTouchBindings();
}
function startResetTimer() {
clearResetTimer();
resetTimerID = setTimeout(function () {
resetTimerID = 0;
enableMouseBindings();
}, $.vmouse.resetTimerDuration);
}
function clearResetTimer() {
if (resetTimerID) {
clearTimeout(resetTimerID);
resetTimerID = 0;
}
}
function triggerVirtualEvent(eventType, event, flags) {
var ve;
if (
(flags && flags[eventType]) ||
(!flags && getClosestElementWithVirtualBinding(event.target, eventType))
) {
ve = createVirtualEvent(event, eventType);
$(event.target).trigger(ve);
}
return ve;
}
function mouseEventCallback(event) {
var touchID = $.data(event.target, touchTargetPropertyName),
ve;
if (!blockMouseTriggers && (!lastTouchID || lastTouchID !== touchID)) {
ve = triggerVirtualEvent("v" + event.type, event);
if (ve) {
if (ve.isDefaultPrevented()) {
event.preventDefault();
}
if (ve.isPropagationStopped()) {
event.stopPropagation();
}
if (ve.isImmediatePropagationStopped()) {
event.stopImmediatePropagation();
}
}
}
}
function handleTouchStart(event) {
var touches = getNativeEvent(event).touches,
target,
flags,
t;
if (touches && touches.length === 1) {
target = event.target;
flags = getVirtualBindingFlags(target);
if (flags.hasVirtualBinding) {
lastTouchID = nextTouchID++;
$.data(target, touchTargetPropertyName, lastTouchID);
clearResetTimer();
disableMouseBindings();
didScroll = false;
t = getNativeEvent(event).touches[0];
startX = t.pageX;
startY = t.pageY;
triggerVirtualEvent("vmouseover", event, flags);
triggerVirtualEvent("vmousedown", event, flags);
}
}
}
function handleScroll(event) {
if (blockTouchTriggers) {
return;
}
if (!didScroll) {
triggerVirtualEvent(
"vmousecancel",
event,
getVirtualBindingFlags(event.target),
);
}
didScroll = true;
startResetTimer();
}
function handleTouchMove(event) {
if (blockTouchTriggers) {
return;
}
var t = getNativeEvent(event).touches[0],
didCancel = didScroll,
moveThreshold = $.vmouse.moveDistanceThreshold,
flags = getVirtualBindingFlags(event.target);
didScroll =
didScroll ||
Math.abs(t.pageX - startX) > moveThreshold ||
Math.abs(t.pageY - startY) > moveThreshold;
if (didScroll && !didCancel) {
triggerVirtualEvent("vmousecancel", event, flags);
}
triggerVirtualEvent("vmousemove", event, flags);
startResetTimer();
}
function handleTouchEnd(event) {
if (blockTouchTriggers) {
return;
}
disableTouchBindings();
var flags = getVirtualBindingFlags(event.target),
ve,
t;
triggerVirtualEvent("vmouseup", event, flags);
if (!didScroll) {
ve = triggerVirtualEvent("vclick", event, flags);
if (ve && ve.isDefaultPrevented()) {
// The target of the mouse events that follow the touchend
// event don't necessarily match the target used during the
// touch. This means we need to rely on coordinates for blocking
// any click that is generated.
t = getNativeEvent(event).changedTouches[0];
clickBlockList.push({
touchID: lastTouchID,
x: t.clientX,
y: t.clientY,
});
// Prevent any mouse events that follow from triggering
// virtual event notifications.
blockMouseTriggers = true;
}
}
triggerVirtualEvent("vmouseout", event, flags);
didScroll = false;
startResetTimer();
}
function hasVirtualBindings(ele) {
var bindings = $.data(ele, dataPropertyName),
k;
if (bindings) {
for (k in bindings) {
if (bindings[k]) {
return true;
}
}
}
return false;
}
function dummyMouseHandler() {}
function getSpecialEventObject(eventType) {
var realType = eventType.substr(1);
return {
setup: function (/* data, namespace */) {
// If this is the first virtual mouse binding for this element,
// add a bindings object to its data.
if (!hasVirtualBindings(this)) {
$.data(this, dataPropertyName, {});
}
// If setup is called, we know it is the first binding for this
// eventType, so initialize the count for the eventType to zero.
var bindings = $.data(this, dataPropertyName);
bindings[eventType] = true;
// If this is the first virtual mouse event for this type,
// register a global handler on the document.
activeDocHandlers[eventType] =
(activeDocHandlers[eventType] || 0) + 1;
if (activeDocHandlers[eventType] === 1) {
$document.bind(realType, mouseEventCallback);
}
// Some browsers, like Opera Mini, won't dispatch mouse/click events
// for elements unless they actually have handlers registered on them.
// To get around this, we register dummy handlers on the elements.
$(this).bind(realType, dummyMouseHandler);
// For now, if event capture is not supported, we rely on mouse handlers.
if (eventCaptureSupported) {
// If this is the first virtual mouse binding for the document,
// register our touchstart handler on the document.
activeDocHandlers["touchstart"] =
(activeDocHandlers["touchstart"] || 0) + 1;
if (activeDocHandlers["touchstart"] === 1) {
$document
.bind("touchstart", handleTouchStart)
.bind("touchend", handleTouchEnd)
// On touch platforms, touching the screen and then dragging your finger
// causes the window content to scroll after some distance threshold is
// exceeded. On these platforms, a scroll prevents a click event from being
// dispatched, and on some platforms, even the touchend is suppressed. To
// mimic the suppression of the click event, we need to watch for a scroll
// event. Unfortunately, some platforms like iOS don't dispatch scroll
// events until *AFTER* the user lifts their finger (touchend). This means
// we need to watch both scroll and touchmove events to figure out whether
// or not a scroll happenens before the touchend event is fired.
.bind("touchmove", handleTouchMove)
.bind("scroll", handleScroll);
}
}
},
teardown: function (/* data, namespace */) {
// If this is the last virtual binding for this eventType,
// remove its global handler from the document.
--activeDocHandlers[eventType];
if (!activeDocHandlers[eventType]) {
$document.unbind(realType, mouseEventCallback);
}
if (eventCaptureSupported) {
// If this is the last virtual mouse binding in existence,
// remove our document touchstart listener.
--activeDocHandlers["touchstart"];
if (!activeDocHandlers["touchstart"]) {
$document
.unbind("touchstart", handleTouchStart)
.unbind("touchmove", handleTouchMove)
.unbind("touchend", handleTouchEnd)
.unbind("scroll", handleScroll);
}
}
var $this = $(this),
bindings = $.data(this, dataPropertyName);
// teardown may be called when an element was
// removed from the DOM. If this is the case,
// jQuery core may have already stripped the element
// of any data bindings so we need to check it before
// using it.
if (bindings) {
bindings[eventType] = false;
}
// Unregister the dummy event handler.
$this.unbind(realType, dummyMouseHandler);
// If this is the last virtual mouse binding on the
// element, remove the binding data from the element.
if (!hasVirtualBindings(this)) {
$this.removeData(dataPropertyName);
}
},
};
}
// Expose our custom events to the jQuery bind/unbind mechanism.
for (i = 0; i < virtualEventNames.length; i++) {
$.event.special[virtualEventNames[i]] = getSpecialEventObject(
virtualEventNames[i],
);
}
// Add a capture click handler to block clicks.
// Note that we require event capture support for this so if the device
// doesn't support it, we punt for now and rely solely on mouse events.
if (eventCaptureSupported) {
document.addEventListener(
"click",
function (e) {
var cnt = clickBlockList.length,
target = e.target,
x,
y,
ele,
i,
o,
touchID;
if (cnt) {
x = e.clientX;
y = e.clientY;
threshold = $.vmouse.clickDistanceThreshold;
// The idea here is to run through the clickBlockList to see if
// the current click event is in the proximity of one of our
// vclick events that had preventDefault() called on it. If we find
// one, then we block the click.
//
// Why do we have to rely on proximity?
//
// Because the target of the touch event that triggered the vclick
// can be different from the target of the click event synthesized
// by the browser. The target of a mouse/click event that is synthesized
// from a touch event seems to be implementation specific. For example,
// some browsers will fire mouse/click events for a link that is near
// a touch event, even though the target of the touchstart/touchend event
// says the user touched outside the link. Also, it seems that with most
// browsers, the target of the mouse/click event is not calculated until the
// time it is dispatched, so if you replace an element that you touched
// with another element, the target of the mouse/click will be the new
// element underneath that point.
//
// Aside from proximity, we also check to see if the target and any
// of its ancestors were the ones that blocked a click. This is necessary
// because of the strange mouse/click target calculation done in the
// Android 2.1 browser, where if you click on an element, and there is a
// mouse/click handler on one of its ancestors, the target will be the
// innermost child of the touched element, even if that child is no where
// near the point of touch.
ele = target;
while (ele) {
for (i = 0; i < cnt; i++) {
o = clickBlockList[i];
touchID = 0;
if (
(ele === target &&
Math.abs(o.x - x) < threshold &&
Math.abs(o.y - y) < threshold) ||
$.data(ele, touchTargetPropertyName) === o.touchID
) {
// XXX: We may want to consider removing matches from the block list
// instead of waiting for the reset timer to fire.
e.preventDefault();
e.stopPropagation();
return;
}
}
ele = ele.parentNode;
}
}
},
true,
);
}
})(jQuery, window, document);
(function ($, window, undefined) {
var $document = $(document),
supportTouch = $.mobile.support.touch,
scrollEvent = "touchmove scroll",
touchStartEvent = supportTouch ? "touchstart" : "mousedown",
touchStopEvent = supportTouch ? "touchend" : "mouseup",
touchMoveEvent = supportTouch ? "touchmove" : "mousemove";
// setup new event shortcuts
$.each(
(
"touchstart touchmove touchend " +
"tap taphold " +
"swipe swipeleft swiperight " +
"scrollstart scrollstop"
).split(" "),
function (i, name) {
$.fn[name] = function (fn) {
return fn ? this.bind(name, fn) : this.trigger(name);
};
// jQuery < 1.8
if ($.attrFn) {
$.attrFn[name] = true;
}
},
);
function triggerCustomEvent(obj, eventType, event, bubble) {
var originalType = event.type;
event.type = eventType;
if (bubble) {
$.event.trigger(event, undefined, obj);
} else {
$.event.dispatch.call(obj, event);
}
event.type = originalType;
}
// also handles scrollstop
$.event.special.scrollstart = {
enabled: true,
setup: function () {
var thisObject = this,
$this = $(thisObject),
scrolling,
timer;
function trigger(event, state) {
scrolling = state;
triggerCustomEvent(
thisObject,
scrolling ? "scrollstart" : "scrollstop",
event,
);
}
// iPhone triggers scroll after a small delay; use touchmove instead
$this.bind(scrollEvent, function (event) {
if (!$.event.special.scrollstart.enabled) {
return;
}
if (!scrolling) {
trigger(event, true);
}
clearTimeout(timer);
timer = setTimeout(function () {
trigger(event, false);
}, 50);
});
},
teardown: function () {
$(this).unbind(scrollEvent);
},
};
// also handles taphold
$.event.special.tap = {
tapholdThreshold: 750,
emitTapOnTaphold: true,
setup: function () {
var thisObject = this,
$this = $(thisObject),
isTaphold = false;
$this.bind("vmousedown", function (event) {
isTaphold = false;
if (event.which && event.which !== 1) {
return false;
}
var origTarget = event.target,
timer;
function clearTapTimer() {
clearTimeout(timer);
}
function clearTapHandlers() {
clearTapTimer();
$this
.unbind("vclick", clickHandler)
.unbind("vmouseup", clearTapTimer);
$document.unbind("vmousecancel", clearTapHandlers);
}
function clickHandler(event) {
clearTapHandlers();
// ONLY trigger a 'tap' event if the start target is
// the same as the stop target.
if (!isTaphold && origTarget === event.target) {
triggerCustomEvent(thisObject, "tap", event);
} else if (isTaphold) {
event.stopPropagation();
}
}
$this.bind("vmouseup", clearTapTimer).bind("vclick", clickHandler);
$document.bind("vmousecancel", clearTapHandlers);
timer = setTimeout(function () {
if (!$.event.special.tap.emitTapOnTaphold) {
isTaphold = true;
}
triggerCustomEvent(
thisObject,
"taphold",
$.Event("taphold", { target: origTarget }),
);
}, $.event.special.tap.tapholdThreshold);
});
},
teardown: function () {
$(this).unbind("vmousedown").unbind("vclick").unbind("vmouseup");
$document.unbind("vmousecancel");
},
};
// Also handles swipeleft, swiperight
$.event.special.swipe = {
// More than this horizontal displacement, and we will suppress scrolling.
scrollSupressionThreshold: 30,
// More time than this, and it isn't a swipe.
durationThreshold: 1000,
// Swipe horizontal displacement must be more than this.
horizontalDistanceThreshold: 30,
// Swipe vertical displacement must be less than this.
verticalDistanceThreshold: 30,
getLocation: function (event) {
var winPageX = window.pageXOffset,
winPageY = window.pageYOffset,
x = event.clientX,
y = event.clientY;
if (
(event.pageY === 0 && Math.floor(y) > Math.floor(event.pageY)) ||
(event.pageX === 0 && Math.floor(x) > Math.floor(event.pageX))
) {
// iOS4 clientX/clientY have the value that should have been
// in pageX/pageY. While pageX/page/ have the value 0
x = x - winPageX;
y = y - winPageY;
} else if (y < event.pageY - winPageY || x < event.pageX - winPageX) {
// Some Android browsers have totally bogus values for clientX/Y
// when scrolling/zooming a page. Detectable since clientX/clientY
// should never be smaller than pageX/pageY minus page scroll
x = event.pageX - winPageX;
y = event.pageY - winPageY;
}
return {
x: x,
y: y,
};
},
start: function (event) {
var data = event.originalEvent.touches
? event.originalEvent.touches[0]
: event,
location = $.event.special.swipe.getLocation(data);
return {
time: new Date().getTime(),
coords: [location.x, location.y],
origin: $(event.target),
};
},
stop: function (event) {
var data = event.originalEvent.touches
? event.originalEvent.touches[0]
: event,
location = $.event.special.swipe.getLocation(data);
return {
time: new Date().getTime(),
coords: [location.x, location.y],
};
},
handleSwipe: function (start, stop, thisObject, origTarget) {
if (
stop.time - start.time < $.event.special.swipe.durationThreshold &&
Math.abs(start.coords[0] - stop.coords[0]) >
$.event.special.swipe.horizontalDistanceThreshold &&
Math.abs(start.coords[1] - stop.coords[1]) <
$.event.special.swipe.verticalDistanceThreshold
) {
var direction =
start.coords[0] > stop.coords[0] ? "swipeleft" : "swiperight";
triggerCustomEvent(
thisObject,
"swipe",
$.Event("swipe", {
target: origTarget,
swipestart: start,
swipestop: stop,
}),
true,
);
triggerCustomEvent(
thisObject,
direction,
$.Event(direction, {
target: origTarget,
swipestart: start,
swipestop: stop,
}),
true,
);
return true;
}
return false;
},
// This serves as a flag to ensure that at most one swipe event event is
// in work at any given time
eventInProgress: false,
setup: function () {
var events,
thisObject = this,
$this = $(thisObject),
context = {};
// Retrieve the events data for this element and add the swipe context
events = $.data(this, "mobile-events");
if (!events) {
events = { length: 0 };
$.data(this, "mobile-events", events);
}
events.length++;
events.swipe = context;
context.start = function (event) {
// Bail if we're already working on a swipe event
if ($.event.special.swipe.eventInProgress) {
return;
}
$.event.special.swipe.eventInProgress = true;
var stop,
start = $.event.special.swipe.start(event),
origTarget = event.target,
emitted = false;
context.move = function (event) {
if (!start) {
return;
}
stop = $.event.special.swipe.stop(event);
if (!emitted) {
emitted = $.event.special.swipe.handleSwipe(
start,
stop,
thisObject,
origTarget,
);
if (emitted) {
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
}
}
// prevent scrolling
if (
Math.abs(start.coords[0] - stop.coords[0]) >
$.event.special.swipe.scrollSupressionThreshold
) {
event.preventDefault();
}
};
context.stop = function () {
emitted = true;
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
$document.off(touchMoveEvent, context.move);
context.move = null;
};
$document
.on(touchMoveEvent, context.move)
.one(touchStopEvent, context.stop);
};
$this.on(touchStartEvent, context.start);
},
teardown: function () {
var events, context;
events = $.data(this, "mobile-events");
if (events) {
context = events.swipe;
delete events.swipe;
events.length--;
if (events.length === 0) {
$.removeData(this, "mobile-events");
}
}
if (context) {
if (context.start) {
$(this).off(touchStartEvent, context.start);
}
if (context.move) {
$document.off(touchMoveEvent, context.move);
}
if (context.stop) {
$document.off(touchStopEvent, context.stop);
}
}
},
};
$.each(
{
scrollstop: "scrollstart",
taphold: "tap",
swipeleft: "swipe",
swiperight: "swipe",
},
function (event, sourceEvent) {
$.event.special[event] = {
setup: function () {
$(this).bind(sourceEvent, $.noop);
},
teardown: function () {
$(this).unbind(sourceEvent);
},
};
},
);
})(jQuery, this);
// throttled resize event
(function ($) {
$.event.special.throttledresize = {
setup: function () {
$(this).bind("resize", handler);
},
teardown: function () {
$(this).unbind("resize", handler);
},
};
var throttle = 250,
handler = function () {
curr = new Date().getTime();
diff = curr - lastCall;
if (diff >= throttle) {
lastCall = curr;
$(this).trigger("throttledresize");
} else {
if (heldCall) {
clearTimeout(heldCall);
}
// Promise a held call will still execute
heldCall = setTimeout(handler, throttle - diff);
}
},
lastCall = 0,
heldCall,
curr,
diff;
})(jQuery);
(function ($, window) {
var win = $(window),
event_name = "orientationchange",
get_orientation,
last_orientation,
initial_orientation_is_landscape,
initial_orientation_is_default,
portrait_map = { 0: true, 180: true },
ww,
wh,
landscape_threshold;
// It seems that some device/browser vendors use window.orientation values 0 and 180 to
// denote the "default" orientation. For iOS devices, and most other smart-phones tested,
// the default orientation is always "portrait", but in some Android and RIM based tablets,
// the default orientation is "landscape". The following code attempts to use the window
// dimensions to figure out what the current orientation is, and then makes adjustments
// to the to the portrait_map if necessary, so that we can properly decode the
// window.orientation value whenever get_orientation() is called.
//
// Note that we used to use a media query to figure out what the orientation the browser
// thinks it is in:
//
// initial_orientation_is_landscape = $.mobile.media("all and (orientation: landscape)");
//
// but there was an iPhone/iPod Touch bug beginning with iOS 4.2, up through iOS 5.1,
// where the browser *ALWAYS* applied the landscape media query. This bug does not
// happen on iPad.
if ($.support.orientation) {
// Check the window width and height to figure out what the current orientation
// of the device is at this moment. Note that we've initialized the portrait map
// values to 0 and 180, *AND* we purposely check for landscape so that if we guess
// wrong, , we default to the assumption that portrait is the default orientation.
// We use a threshold check below because on some platforms like iOS, the iPhone
// form-factor can report a larger width than height if the user turns on the
// developer console. The actual threshold value is somewhat arbitrary, we just
// need to make sure it is large enough to exclude the developer console case.
ww = window.innerWidth || win.width();
wh = window.innerHeight || win.height();
landscape_threshold = 50;
initial_orientation_is_landscape =
ww > wh && ww - wh > landscape_threshold;
// Now check to see if the current window.orientation is 0 or 180.
initial_orientation_is_default = portrait_map[window.orientation];
// If the initial orientation is landscape, but window.orientation reports 0 or 180, *OR*
// if the initial orientation is portrait, but window.orientation reports 90 or -90, we
// need to flip our portrait_map values because landscape is the default orientation for
// this device/browser.
if (
(initial_orientation_is_landscape && initial_orientation_is_default) ||
(!initial_orientation_is_landscape && !initial_orientation_is_default)
) {
portrait_map = { "-90": true, 90: true };
}
}
$.event.special.orientationchange = $.extend(
{},
$.event.special.orientationchange,
{
setup: function () {
// If the event is supported natively, return false so that jQuery
// will bind to the event using DOM methods.
if (
$.support.orientation &&
!$.event.special.orientationchange.disabled
) {
return false;
}
// Get the current orientation to avoid initial double-triggering.
last_orientation = get_orientation();
// Because the orientationchange event doesn't exist, simulate the
// event by testing window dimensions on resize.
win.bind("throttledresize", handler);
},
teardown: function () {
// If the event is not supported natively, return false so that
// jQuery will unbind the event using DOM methods.
if (
$.support.orientation &&
!$.event.special.orientationchange.disabled
) {
return false;
}
// Because the orientationchange event doesn't exist, unbind the
// resize event handler.
win.unbind("throttledresize", handler);
},
add: function (handleObj) {
// Save a reference to the bound event handler.
var old_handler = handleObj.handler;
handleObj.handler = function (event) {
// Modify event object, adding the .orientation property.
event.orientation = get_orientation();
// Call the originally-bound event handler and return its result.
return old_handler.apply(this, arguments);
};
},
},
);
// If the event is not supported natively, this handler will be bound to
// the window resize event to simulate the orientationchange event.
function handler() {
// Get the current orientation.
var orientation = get_orientation();
if (orientation !== last_orientation) {
// The orientation has changed, so trigger the orientationchange event.
last_orientation = orientation;
win.trigger(event_name);
}
}
// Get the current page orientation. This method is exposed publicly, should it
// be needed, as jQuery.event.special.orientationchange.orientation()
$.event.special.orientationchange.orientation = get_orientation =
function () {
var isPortrait = true,
elem = document.documentElement;
// prefer window orientation to the calculation based on screensize as
// the actual screen resize takes place before or after the orientation change event
// has been fired depending on implementation (eg android 2.3 is before, iphone after).
// More testing is required to determine if a more reliable method of determining the new screensize
// is possible when orientationchange is fired. (eg, use media queries + element + opacity)
if ($.support.orientation) {
// if the window orientation registers as 0 or 180 degrees report
// portrait, otherwise landscape
isPortrait = portrait_map[window.orientation];
} else {
isPortrait = elem && elem.clientWidth / elem.clientHeight < 1.1;
}
return isPortrait ? "portrait" : "landscape";
};
$.fn[event_name] = function (fn) {
return fn ? this.bind(event_name, fn) : this.trigger(event_name);
};
// jQuery < 1.8
if ($.attrFn) {
$.attrFn[event_name] = true;
}
})(jQuery, this);
(function ($, undefined) {
// existing base tag?
var baseElement = $("head").children("base"),
// base element management, defined depending on dynamic base tag support
// TODO move to external widget
base = {
// define base element, for use in routing asset urls that are referenced
// in Ajax-requested markup
element: baseElement.length
? baseElement
: $("<base>", {
href: $.mobile.path.documentBase.hrefNoHash,
}).prependTo($("head")),
linkSelector:
"[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]",
// set the generated BASE element's href to a new page's base path
set: function (href) {
// we should do nothing if the user wants to manage their url base
// manually
if (!$.mobile.dynamicBaseEnabled) {
return;
}
// we should use the base tag if we can manipulate it dynamically
if ($.support.dynamicBaseTag) {
base.element.attr(
"href",
$.mobile.path.makeUrlAbsolute(href, $.mobile.path.documentBase),
);
}
},
rewrite: function (href, page) {
var newPath = $.mobile.path.get(href);
page.find(base.linkSelector).each(function (i, link) {
var thisAttr = $(link).is("[href]")
? "href"
: $(link).is("[src]")
? "src"
: "action",
thisUrl = $(link).attr(thisAttr);
// XXX_jblas: We need to fix this so that it removes the document
// base URL, and then prepends with the new page URL.
// if full path exists and is same, chop it - helps IE out
thisUrl = thisUrl.replace(
location.protocol + "//" + location.host + location.pathname,
"",
);
if (!/^(\w+:|#|\/)/.test(thisUrl)) {
$(link).attr(thisAttr, newPath + thisUrl);
}
});
},
// set the generated BASE element's href to a new page's base path
reset: function (/* href */) {
base.element.attr("href", $.mobile.path.documentBase.hrefNoSearch);
},
};
$.mobile.base = base;
})(jQuery);
(function ($, undefined) {
$.mobile.widgets = {};
var originalWidget = $.widget,
// Record the original, non-mobileinit-modified version of $.mobile.keepNative
// so we can later determine whether someone has modified $.mobile.keepNative
keepNativeFactoryDefault = $.mobile.keepNative;
$.widget = (function (orig) {
return function () {
var constructor = orig.apply(this, arguments),
name = constructor.prototype.widgetName;
constructor.initSelector =
constructor.prototype.initSelector !== undefined
? constructor.prototype.initSelector
: ":jqmData(role='" + name + "')";
$.mobile.widgets[name] = constructor;
return constructor;
};
})($.widget);
// Make sure $.widget still has bridge and extend methods
$.extend($.widget, originalWidget);
// For backcompat remove in 1.5
$.mobile.document.on("create", function (event) {
$(event.target).enhanceWithin();
});
$.widget("mobile.page", {
options: {
theme: "a",
domCache: false,
// Deprecated in 1.4 remove in 1.5
keepNativeDefault: $.mobile.keepNative,
// Deprecated in 1.4 remove in 1.5
contentTheme: null,
enhanced: false,
},
// DEPRECATED for > 1.4
// TODO remove at 1.5
_createWidget: function () {
$.Widget.prototype._createWidget.apply(this, arguments);
this._trigger("init");
},
_create: function () {
// If false is returned by the callbacks do not create the page
if (this._trigger("beforecreate") === false) {
return false;
}
if (!this.options.enhanced) {
this._enhance();
}
this._on(this.element, {
pagebeforehide: "removeContainerBackground",
pagebeforeshow: "_handlePageBeforeShow",
});
this.element.enhanceWithin();
// Dialog widget is deprecated in 1.4 remove this in 1.5
if (
$.mobile.getAttribute(this.element[0], "role") === "dialog" &&
$.mobile.dialog
) {
this.element.dialog();
}
},
_enhance: function () {
var attrPrefix = "data-" + $.mobile.ns,
self = this;
if (this.options.role) {
this.element.attr("data-" + $.mobile.ns + "role", this.options.role);
}
this.element
.attr("tabindex", "0")
.addClass("ui-page ui-page-theme-" + this.options.theme);
// Manipulation of content os Deprecated as of 1.4 remove in 1.5
this.element
.find("[" + attrPrefix + "role='content']")
.each(function () {
var $this = $(this),
theme = this.getAttribute(attrPrefix + "theme") || undefined;
self.options.contentTheme =
theme ||
self.options.contentTheme ||
(self.options.dialog && self.options.theme) ||
(self.element.jqmData("role") === "dialog" && self.options.theme);
$this.addClass("ui-content");
if (self.options.contentTheme) {
$this.addClass("ui-body-" + self.options.contentTheme);
}
// Add ARIA role
$this.attr("role", "main").addClass("ui-content");
});
},
bindRemove: function (callback) {
var page = this.element;
// when dom caching is not enabled or the page is embedded bind to remove the page on hide
if (
!page.data("mobile-page").options.domCache &&
page.is(":jqmData(external-page='true')")
) {
// TODO use _on - that is, sort out why it doesn't work in this case
page.bind(
"pagehide.remove",
callback ||
function (e, data) {
//check if this is a same page transition and if so don't remove the page
if (!data.samePage) {
var $this = $(this),
prEvent = new $.Event("pageremove");
$this.trigger(prEvent);
if (!prEvent.isDefaultPrevented()) {
$this.removeWithDependents();
}
}
},
);
}
},
_setOptions: function (o) {
if (o.theme !== undefined) {
this.element
.removeClass("ui-page-theme-" + this.options.theme)
.addClass("ui-page-theme-" + o.theme);
}
if (o.contentTheme !== undefined) {
this.element
.find("[data-" + $.mobile.ns + "='content']")
.removeClass("ui-body-" + this.options.contentTheme)
.addClass("ui-body-" + o.contentTheme);
}
},
_handlePageBeforeShow: function (/* e */) {
this.setContainerBackground();
},
// Deprecated in 1.4 remove in 1.5
removeContainerBackground: function () {
this.element
.closest(":mobile-pagecontainer")
.pagecontainer({ theme: "none" });
},
// Deprecated in 1.4 remove in 1.5
// set the page container background to the page theme
setContainerBackground: function (theme) {
this.element
.parent()
.pagecontainer({ theme: theme || this.options.theme });
},
// Deprecated in 1.4 remove in 1.5
keepNativeSelector: function () {
var options = this.options,
keepNative = $.trim(options.keepNative || ""),
globalValue = $.trim($.mobile.keepNative),
optionValue = $.trim(options.keepNativeDefault),
// Check if $.mobile.keepNative has changed from the factory default
newDefault =
keepNativeFactoryDefault === globalValue ? "" : globalValue,
// If $.mobile.keepNative has not changed, use options.keepNativeDefault
oldDefault = newDefault === "" ? optionValue : "";
// Concatenate keepNative selectors from all sources where the value has
// changed or, if nothing has changed, return the default
return (keepNative ? [keepNative] : [])
.concat(newDefault ? [newDefault] : [])
.concat(oldDefault ? [oldDefault] : [])
.join(", ");
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.pagecontainer", {
options: {
theme: "a",
},
initSelector: false,
_create: function () {
this.setLastScrollEnabled = true;
this._on(this.window, {
// disable an scroll setting when a hashchange has been fired,
// this only works because the recording of the scroll position
// is delayed for 100ms after the browser might have changed the
// position because of the hashchange
navigate: "_disableRecordScroll",
// bind to scrollstop for the first page, "pagechange" won't be
// fired in that case
scrollstop: "_delayedRecordScroll",
});
// TODO consider moving the navigation handler OUT of widget into
// some other object as glue between the navigate event and the
// content widget load and change methods
this._on(this.window, { navigate: "_filterNavigateEvents" });
// TODO move from page* events to content* events
this._on({ pagechange: "_afterContentChange" });
// handle initial hashchange from chrome :(
this.window.one(
"navigate",
$.proxy(function () {
this.setLastScrollEnabled = true;
}, this),
);
},
_setOptions: function (options) {
if (options.theme !== undefined && options.theme !== "none") {
this.element
.removeClass("ui-overlay-" + this.options.theme)
.addClass("ui-overlay-" + options.theme);
} else if (options.theme !== undefined) {
this.element.removeClass("ui-overlay-" + this.options.theme);
}
this._super(options);
},
_disableRecordScroll: function () {
this.setLastScrollEnabled = false;
},
_enableRecordScroll: function () {
this.setLastScrollEnabled = true;
},
// TODO consider the name here, since it's purpose specific
_afterContentChange: function () {
// once the page has changed, re-enable the scroll recording
this.setLastScrollEnabled = true;
// remove any binding that previously existed on the get scroll
// which may or may not be different than the scroll element
// determined for this page previously
this._off(this.window, "scrollstop");
// determine and bind to the current scoll element which may be the
// window or in the case of touch overflow the element touch overflow
this._on(this.window, { scrollstop: "_delayedRecordScroll" });
},
_recordScroll: function () {
// this barrier prevents setting the scroll value based on
// the browser scrolling the window based on a hashchange
if (!this.setLastScrollEnabled) {
return;
}
var active = this._getActiveHistory(),
currentScroll,
minScroll,
defaultScroll;
if (active) {
currentScroll = this._getScroll();
minScroll = this._getMinScroll();
defaultScroll = this._getDefaultScroll();
// Set active page's lastScroll prop. If the location we're
// scrolling to is less than minScrollBack, let it go.
active.lastScroll =
currentScroll < minScroll ? defaultScroll : currentScroll;
}
},
_delayedRecordScroll: function () {
setTimeout($.proxy(this, "_recordScroll"), 100);
},
_getScroll: function () {
return this.window.scrollTop();
},
_getMinScroll: function () {
return $.mobile.minScrollBack;
},
_getDefaultScroll: function () {
return $.mobile.defaultHomeScroll;
},
_filterNavigateEvents: function (e, data) {
var url;
if (e.originalEvent && e.originalEvent.isDefaultPrevented()) {
return;
}
url =
e.originalEvent.type.indexOf("hashchange") > -1
? data.state.hash
: data.state.url;
if (!url) {
url = this._getHash();
}
if (
!url ||
url === "#" ||
url.indexOf("#" + $.mobile.path.uiStateKey) === 0
) {
url = location.href;
}
this._handleNavigate(url, data.state);
},
_getHash: function () {
return $.mobile.path.parseLocation().hash;
},
// TODO active page should be managed by the container (ie, it should be a property)
getActivePage: function () {
return this.activePage;
},
// TODO the first page should be a property set during _create using the logic
// that currently resides in init
_getInitialContent: function () {
return $.mobile.firstPage;
},
// TODO each content container should have a history object
_getHistory: function () {
return $.mobile.navigate.history;
},
// TODO use _getHistory
_getActiveHistory: function () {
return $.mobile.navigate.history.getActive();
},
// TODO the document base should be determined at creation
_getDocumentBase: function () {
return $.mobile.path.documentBase;
},
back: function () {
this.go(-1);
},
forward: function () {
this.go(1);
},
go: function (steps) {
//if hashlistening is enabled use native history method
if ($.mobile.hashListeningEnabled) {
window.history.go(steps);
} else {
//we are not listening to the hash so handle history internally
var activeIndex = $.mobile.navigate.history.activeIndex,
index = activeIndex + parseInt(steps, 10),
url = $.mobile.navigate.history.stack[index].url,
direction = steps >= 1 ? "forward" : "back";
//update the history object
$.mobile.navigate.history.activeIndex = index;
$.mobile.navigate.history.previousIndex = activeIndex;
//change to the new page
this.change(url, {
direction: direction,
changeHash: false,
fromHashChange: true,
});
}
},
// TODO rename _handleDestination
_handleDestination: function (to) {
var history;
// clean the hash for comparison if it's a url
if ($.type(to) === "string") {
to = $.mobile.path.stripHash(to);
}
if (to) {
history = this._getHistory();
// At this point, 'to' can be one of 3 things, a cached page
// element from a history stack entry, an id, or site-relative /
// absolute URL. If 'to' is an id, we need to resolve it against
// the documentBase, not the location.href, since the hashchange
// could've been the result of a forward/backward navigation
// that crosses from an external page/dialog to an internal
// page/dialog.
//
// TODO move check to history object or path object?
to = !$.mobile.path.isPath(to)
? $.mobile.path.makeUrlAbsolute("#" + to, this._getDocumentBase())
: to;
// If we're about to go to an initial URL that contains a
// reference to a non-existent internal page, go to the first
// page instead. We know that the initial hash refers to a
// non-existent page, because the initial hash did not end
// up in the initial history entry
// TODO move check to history object?
if (
to ===
$.mobile.path.makeUrlAbsolute(
"#" + history.initialDst,
this._getDocumentBase(),
) &&
history.stack.length &&
history.stack[0].url !==
history.initialDst.replace($.mobile.dialogHashKey, "")
) {
to = this._getInitialContent();
}
}
return to || this._getInitialContent();
},
_handleDialog: function (changePageOptions, data) {
var to,
active,
activeContent = this.getActivePage();
// If current active page is not a dialog skip the dialog and continue
// in the same direction
if (activeContent && !activeContent.hasClass("ui-dialog")) {
// determine if we're heading forward or backward and continue
// accordingly past the current dialog
if (data.direction === "back") {
this.back();
} else {
this.forward();
}
// prevent changePage call
return false;
} else {
// if the current active page is a dialog and we're navigating
// to a dialog use the dialog objected saved in the stack
to = data.pageUrl;
active = this._getActiveHistory();
// make sure to set the role, transition and reversal
// as most of this is lost by the domCache cleaning
$.extend(changePageOptions, {
role: active.role,
transition: active.transition,
reverse: data.direction === "back",
});
}
return to;
},
_handleNavigate: function (url, data) {
//find first page via hash
// TODO stripping the hash twice with handleUrl
var to = $.mobile.path.stripHash(url),
history = this._getHistory(),
// transition is false if it's the first page, undefined
// otherwise (and may be overridden by default)
transition = history.stack.length === 0 ? "none" : undefined,
// default options for the changPage calls made after examining
// the current state of the page and the hash, NOTE that the
// transition is derived from the previous history entry
changePageOptions = {
changeHash: false,
fromHashChange: true,
reverse: data.direction === "back",
};
$.extend(changePageOptions, data, {
transition: (history.getLast() || {}).transition || transition,
});
// TODO move to _handleDestination ?
// If this isn't the first page, if the current url is a dialog hash
// key, and the initial destination isn't equal to the current target
// page, use the special dialog handling
if (
history.activeIndex > 0 &&
to.indexOf($.mobile.dialogHashKey) > -1 &&
history.initialDst !== to
) {
to = this._handleDialog(changePageOptions, data);
if (to === false) {
return;
}
}
this._changeContent(this._handleDestination(to), changePageOptions);
},
_changeContent: function (to, opts) {
$.mobile.changePage(to, opts);
},
_getBase: function () {
return $.mobile.base;
},
_getNs: function () {
return $.mobile.ns;
},
_enhance: function (content, role) {
// TODO consider supporting a custom callback, and passing in
// the settings which includes the role
return content.page({ role: role });
},
_include: function (page, settings) {
// append to page and enhance
page.appendTo(this.element);
// use the page widget to enhance
this._enhance(page, settings.role);
// remove page on hide
page.page("bindRemove");
},
_find: function (absUrl) {
// TODO consider supporting a custom callback
var fileUrl = this._createFileUrl(absUrl),
dataUrl = this._createDataUrl(absUrl),
page,
initialContent = this._getInitialContent();
// Check to see if the page already exists in the DOM.
// NOTE do _not_ use the :jqmData pseudo selector because parenthesis
// are a valid url char and it breaks on the first occurence
page = this.element.children(
"[data-" + this._getNs() + "url='" + dataUrl + "']",
);
// If we failed to find the page, check to see if the url is a
// reference to an embedded page. If so, it may have been dynamically
// injected by a developer, in which case it would be lacking a
// data-url attribute and in need of enhancement.
if (page.length === 0 && dataUrl && !$.mobile.path.isPath(dataUrl)) {
page = this.element
.children($.mobile.path.hashToSelector("#" + dataUrl))
.attr("data-" + this._getNs() + "url", dataUrl)
.jqmData("url", dataUrl);
}
// If we failed to find a page in the DOM, check the URL to see if it
// refers to the first page in the application. Also check to make sure
// our cached-first-page is actually in the DOM. Some user deployed
// apps are pruning the first page from the DOM for various reasons.
// We check for this case here because we don't want a first-page with
// an id falling through to the non-existent embedded page error case.
if (
page.length === 0 &&
$.mobile.path.isFirstPageUrl(fileUrl) &&
initialContent &&
initialContent.parent().length
) {
page = $(initialContent);
}
return page;
},
_getLoader: function () {
return $.mobile.loading();
},
_showLoading: function (delay, theme, msg, textonly) {
// This configurable timeout allows cached pages a brief
// delay to load without showing a message
if (this._loadMsg) {
return;
}
this._loadMsg = setTimeout(
$.proxy(function () {
this._getLoader().loader("show", theme, msg, textonly);
this._loadMsg = 0;
}, this),
delay,
);
},
_hideLoading: function () {
// Stop message show timer
clearTimeout(this._loadMsg);
this._loadMsg = 0;
// Hide loading message
this._getLoader().loader("hide");
},
_showError: function () {
// make sure to remove the current loading message
this._hideLoading();
// show the error message
this._showLoading(
0,
$.mobile.pageLoadErrorMessageTheme,
$.mobile.pageLoadErrorMessage,
true,
);
// hide the error message after a delay
// TODO configuration
setTimeout($.proxy(this, "_hideLoading"), 1500);
},
_parse: function (html, fileUrl) {
// TODO consider allowing customization of this method. It's very JQM specific
var page,
all = $("<div></div>");
//workaround to allow scripts to execute when included in page divs
all.get(0).innerHTML = html;
page = all
.find(":jqmData(role='page'), :jqmData(role='dialog')")
.first();
//if page elem couldn't be found, create one and insert the body element's contents
if (!page.length) {
page = $(
"<div data-" +
this._getNs() +
"role='page'>" +
(html.split(/<\/?body[^>]*>/gim)[1] || "") +
"</div>",
);
}
// TODO tagging a page with external to make sure that embedded pages aren't
// removed by the various page handling code is bad. Having page handling code
// in many places is bad. Solutions post 1.0
page
.attr(
"data-" + this._getNs() + "url",
$.mobile.path.convertUrlToDataUrl(fileUrl),
)
.attr("data-" + this._getNs() + "external-page", true);
return page;
},
_setLoadedTitle: function (page, html) {
//page title regexp
var newPageTitle = html.match(/<title[^>]*>([^<]*)/) && RegExp.$1;
if (newPageTitle && !page.jqmData("title")) {
newPageTitle = $("<div>" + newPageTitle + "</div>").text();
page.jqmData("title", newPageTitle);
}
},
_isRewritableBaseTag: function () {
return $.mobile.dynamicBaseEnabled && !$.support.dynamicBaseTag;
},
_createDataUrl: function (absoluteUrl) {
return $.mobile.path.convertUrlToDataUrl(absoluteUrl);
},
_createFileUrl: function (absoluteUrl) {
return $.mobile.path.getFilePath(absoluteUrl);
},
_triggerWithDeprecated: function (name, data, page) {
var deprecatedEvent = $.Event("page" + name),
newEvent = $.Event(this.widgetName + name);
// DEPRECATED
// trigger the old deprecated event on the page if it's provided
(page || this.element).trigger(deprecatedEvent, data);
// use the widget trigger method for the new content* event
this.element.trigger(newEvent, data);
return {
deprecatedEvent: deprecatedEvent,
event: newEvent,
};
},
// TODO it would be nice to split this up more but everything appears to be "one off"
// or require ordering such that other bits are sprinkled in between parts that
// could be abstracted out as a group
_loadSuccess: function (absUrl, triggerData, settings, deferred) {
var fileUrl = this._createFileUrl(absUrl),
dataUrl = this._createDataUrl(absUrl);
return $.proxy(function (html, textStatus, xhr) {
//pre-parse html to check for a data-url,
//use it as the new fileUrl, base path, etc
var content,
// TODO handle dialogs again
pageElemRegex = new RegExp(
"(<[^>]+\\bdata-" +
this._getNs() +
"role=[\"']?page[\"']?[^>]*>)",
),
dataUrlRegex = new RegExp(
"\\bdata-" + this._getNs() + "url=[\"']?([^\"'>]*)[\"']?",
);
// data-url must be provided for the base tag so resource requests
// can be directed to the correct url. loading into a temprorary
// element makes these requests immediately
if (
pageElemRegex.test(html) &&
RegExp.$1 &&
dataUrlRegex.test(RegExp.$1) &&
RegExp.$1
) {
fileUrl = $.mobile.path.getFilePath(
$("<div>" + RegExp.$1 + "</div>").text(),
);
}
//dont update the base tag if we are prefetching
if (settings.prefetch === undefined) {
this._getBase().set(fileUrl);
}
content = this._parse(html, fileUrl);
this._setLoadedTitle(content, html);
// Add the content reference and xhr to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
// DEPRECATED
triggerData.page = content;
triggerData.content = content;
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if (!this._trigger("load", undefined, triggerData)) {
return;
}
// rewrite src and href attrs to use a base url if the base tag won't work
if (this._isRewritableBaseTag() && content) {
this._getBase().rewrite(fileUrl, content);
}
this._include(content, settings);
// Enhancing the content may result in new dialogs/sub content being inserted
// into the DOM. If the original absUrl refers to a sub-content, that is the
// real content we are interested in.
if (absUrl.indexOf("&" + $.mobile.subPageUrlKey) > -1) {
content = this.element.children(
"[data-" + this._getNs() + "url='" + dataUrl + "']",
);
}
// Remove loading message.
if (settings.showLoadMsg) {
this._hideLoading();
}
// BEGIN DEPRECATED ---------------------------------------------------
// Let listeners know the content loaded successfully.
this.element.trigger("pageload");
// END DEPRECATED -----------------------------------------------------
deferred.resolve(absUrl, settings, content);
}, this);
},
_loadDefaults: {
type: "get",
data: undefined,
// DEPRECATED
reloadPage: false,
reload: false,
// By default we rely on the role defined by the @data-role attribute.
role: undefined,
showLoadMsg: false,
// This delay allows loads that pull from browser cache to
// occur without showing the loading message.
loadMsgDelay: 50,
},
load: function (url, options) {
// This function uses deferred notifications to let callers
// know when the content is done loading, or if an error has occurred.
var deferred = (options && options.deferred) || $.Deferred(),
// The default load options with overrides specified by the caller.
settings = $.extend({}, this._loadDefaults, options),
// The DOM element for the content after it has been loaded.
content = null,
// The absolute version of the URL passed into the function. This
// version of the URL may contain dialog/subcontent params in it.
absUrl = $.mobile.path.makeUrlAbsolute(
url,
this._findBaseWithDefault(),
),
fileUrl,
dataUrl,
pblEvent,
triggerData;
// DEPRECATED reloadPage
settings.reload = settings.reloadPage;
// If the caller provided data, and we're using "get" request,
// append the data to the URL.
if (settings.data && settings.type === "get") {
absUrl = $.mobile.path.addSearchParams(absUrl, settings.data);
settings.data = undefined;
}
// If the caller is using a "post" request, reload must be true
if (settings.data && settings.type === "post") {
settings.reload = true;
}
// The absolute version of the URL minus any dialog/subcontent params.
// In otherwords the real URL of the content to be loaded.
fileUrl = this._createFileUrl(absUrl);
// The version of the Url actually stored in the data-url attribute of
// the content. For embedded content, it is just the id of the page. For
// content within the same domain as the document base, it is the site
// relative path. For cross-domain content (Phone Gap only) the entire
// absolute Url is used to load the content.
dataUrl = this._createDataUrl(absUrl);
content = this._find(absUrl);
// If it isn't a reference to the first content and refers to missing
// embedded content reject the deferred and return
if (
content.length === 0 &&
$.mobile.path.isEmbeddedPage(fileUrl) &&
!$.mobile.path.isFirstPageUrl(fileUrl)
) {
deferred.reject(absUrl, settings);
return;
}
// Reset base to the default document base
// TODO figure out why we doe this
this._getBase().reset();
// If the content we are interested in is already in the DOM,
// and the caller did not indicate that we should force a
// reload of the file, we are done. Resolve the deferrred so that
// users can bind to .done on the promise
if (content.length && !settings.reload) {
this._enhance(content, settings.role);
deferred.resolve(absUrl, settings, content);
//if we are reloading the content make sure we update
// the base if its not a prefetch
if (!settings.prefetch) {
this._getBase().set(url);
}
return;
}
triggerData = {
url: url,
absUrl: absUrl,
dataUrl: dataUrl,
deferred: deferred,
options: settings,
};
// Let listeners know we're about to load content.
pblEvent = this._triggerWithDeprecated("beforeload", triggerData);
// If the default behavior is prevented, stop here!
if (
pblEvent.deprecatedEvent.isDefaultPrevented() ||
pblEvent.event.isDefaultPrevented()
) {
return;
}
if (settings.showLoadMsg) {
this._showLoading(settings.loadMsgDelay);
}
// Reset base to the default document base.
// only reset if we are not prefetching
if (settings.prefetch === undefined) {
this._getBase().reset();
}
if (
!(
$.mobile.allowCrossDomainPages ||
$.mobile.path.isSameDomain($.mobile.path.documentUrl, absUrl)
)
) {
deferred.reject(absUrl, settings);
return;
}
// Load the new content.
$.ajax({
url: fileUrl,
type: settings.type,
data: settings.data,
contentType: settings.contentType,
dataType: "html",
success: this._loadSuccess(absUrl, triggerData, settings, deferred),
error: this._loadError(absUrl, triggerData, settings, deferred),
});
},
_loadError: function (absUrl, triggerData, settings, deferred) {
return $.proxy(function (xhr, textStatus, errorThrown) {
//set base back to current path
this._getBase().set($.mobile.path.get());
// Add error info to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
triggerData.errorThrown = errorThrown;
// Let listeners know the page load failed.
var plfEvent = this._triggerWithDeprecated("loadfailed", triggerData);
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if (
plfEvent.deprecatedEvent.isDefaultPrevented() ||
plfEvent.event.isDefaultPrevented()
) {
return;
}
// Remove loading message.
if (settings.showLoadMsg) {
this._showError();
}
deferred.reject(absUrl, settings);
}, this);
},
_getTransitionHandler: function (transition) {
transition = $.mobile._maybeDegradeTransition(transition);
//find the transition handler for the specified transition. If there
//isn't one in our transitionHandlers dictionary, use the default one.
//call the handler immediately to kick-off the transition.
return (
$.mobile.transitionHandlers[transition] ||
$.mobile.defaultTransitionHandler
);
},
// TODO move into transition handlers?
_triggerCssTransitionEvents: function (to, from, prefix) {
var samePage = false;
prefix = prefix || "";
// TODO decide if these events should in fact be triggered on the container
if (from) {
//Check if this is a same page transition and tell the handler in page
if (to[0] === from[0]) {
samePage = true;
}
//trigger before show/hide events
// TODO deprecate nextPage in favor of next
this._triggerWithDeprecated(
prefix + "hide",
{ nextPage: to, samePage: samePage },
from,
);
}
// TODO deprecate prevPage in favor of previous
this._triggerWithDeprecated(
prefix + "show",
{ prevPage: from || $("") },
to,
);
},
// TODO make private once change has been defined in the widget
_cssTransition: function (to, from, options) {
var transition = options.transition,
reverse = options.reverse,
deferred = options.deferred,
TransitionHandler,
promise;
this._triggerCssTransitionEvents(to, from, "before");
// TODO put this in a binding to events *outside* the widget
this._hideLoading();
TransitionHandler = this._getTransitionHandler(transition);
promise = new TransitionHandler(
transition,
reverse,
to,
from,
).transition();
// TODO temporary accomodation of argument deferred
promise.done(function () {
deferred.resolve.apply(deferred, arguments);
});
promise.done(
$.proxy(function () {
this._triggerCssTransitionEvents(to, from);
}, this),
);
},
_releaseTransitionLock: function () {
//release transition lock so navigation is free again
isPageTransitioning = false;
if (pageTransitionQueue.length > 0) {
$.mobile.changePage.apply(null, pageTransitionQueue.pop());
}
},
_removeActiveLinkClass: function (force) {
//clear out the active button state
$.mobile.removeActiveLinkClass(force);
},
_loadUrl: function (to, triggerData, settings) {
// preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params
// from the hash this is so that users who want to use query
// params have access to them in the event bindings for the page
// life cycle See issue #5085
settings.target = to;
settings.deferred = $.Deferred();
this.load(to, settings);
settings.deferred.done(
$.proxy(function (url, options, content) {
isPageTransitioning = false;
// store the original absolute url so that it can be provided
// to events in the triggerData of the subsequent changePage call
options.absUrl = triggerData.absUrl;
this.transition(content, triggerData, options);
}, this),
);
settings.deferred.fail(
$.proxy(
function (/* url, options */) {
this._removeActiveLinkClass(true);
this._releaseTransitionLock();
this._triggerWithDeprecated("changefailed", triggerData);
},
this,
),
);
},
_triggerPageBeforeChange: function (to, triggerData, settings) {
var pbcEvent = new $.Event("pagebeforechange");
$.extend(triggerData, { toPage: to, options: settings });
// NOTE: preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params from
// the hash this is so that users who want to use query params have
// access to them in the event bindings for the page life cycle
// See issue #5085
if ($.type(to) === "string") {
// if the toPage is a string simply convert it
triggerData.absUrl = $.mobile.path.makeUrlAbsolute(
to,
this._findBaseWithDefault(),
);
} else {
// if the toPage is a jQuery object grab the absolute url stored
// in the loadPage callback where it exists
triggerData.absUrl = settings.absUrl;
}
// Let listeners know we're about to change the current page.
this.element.trigger(pbcEvent, triggerData);
// If the default behavior is prevented, stop here!
if (pbcEvent.isDefaultPrevented()) {
return false;
}
return true;
},
change: function (to, options) {
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if (isPageTransitioning) {
pageTransitionQueue.unshift(arguments);
return;
}
var settings = $.extend({}, $.mobile.changePage.defaults, options),
triggerData = {};
// Make sure we have a fromPage.
settings.fromPage = settings.fromPage || this.activePage;
// if the page beforechange default is prevented return early
if (!this._triggerPageBeforeChange(to, triggerData, settings)) {
return;
}
// We allow "pagebeforechange" observers to modify the to in
// the trigger data to allow for redirects. Make sure our to is
// updated. We also need to re-evaluate whether it is a string,
// because an object can also be replaced by a string
to = triggerData.toPage;
// If the caller passed us a url, call loadPage()
// to make sure it is loaded into the DOM. We'll listen
// to the promise object it returns so we know when
// it is done loading or if an error ocurred.
if ($.type(to) === "string") {
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
this._loadUrl(to, triggerData, settings);
} else {
this.transition(to, triggerData, settings);
}
},
transition: function (toPage, triggerData, settings) {
var fromPage,
url,
pageUrl,
fileUrl,
active,
activeIsInitialPage,
historyDir,
pageTitle,
isDialog,
alreadyThere,
newPageTitle,
params,
cssTransitionDeferred,
beforeTransition;
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if (isPageTransitioning) {
// make sure to only queue the to and settings values so the arguments
// work with a call to the change method
pageTransitionQueue.unshift([toPage, settings]);
return;
}
// DEPRECATED - this call only, in favor of the before transition
// if the page beforechange default is prevented return early
if (!this._triggerPageBeforeChange(toPage, triggerData, settings)) {
return;
}
// if the (content|page)beforetransition default is prevented return early
// Note, we have to check for both the deprecated and new events
beforeTransition = this._triggerWithDeprecated(
"beforetransition",
triggerData,
);
if (
beforeTransition.deprecatedEvent.isDefaultPrevented() ||
beforeTransition.event.isDefaultPrevented()
) {
return;
}
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
// If we are going to the first-page of the application, we need to make
// sure settings.dataUrl is set to the application document url. This allows
// us to avoid generating a document url with an id hash in the case where the
// first-page of the document has an id attribute specified.
if (toPage[0] === $.mobile.firstPage[0] && !settings.dataUrl) {
settings.dataUrl = $.mobile.path.documentUrl.hrefNoHash;
}
// The caller passed us a real page DOM element. Update our
// internal state and then trigger a transition to the page.
fromPage = settings.fromPage;
url =
(settings.dataUrl &&
$.mobile.path.convertUrlToDataUrl(settings.dataUrl)) ||
toPage.jqmData("url");
// The pageUrl var is usually the same as url, except when url is obscured
// as a dialog url. pageUrl always contains the file path
pageUrl = url;
fileUrl = $.mobile.path.getFilePath(url);
active = $.mobile.navigate.history.getActive();
activeIsInitialPage = $.mobile.navigate.history.activeIndex === 0;
historyDir = 0;
pageTitle = document.title;
isDialog =
(settings.role === "dialog" || toPage.jqmData("role") === "dialog") &&
toPage.jqmData("dialog") !== true;
// By default, we prevent changePage requests when the fromPage and toPage
// are the same element, but folks that generate content
// manually/dynamically and reuse pages want to be able to transition to
// the same page. To allow this, they will need to change the default
// value of allowSamePageTransition to true, *OR*, pass it in as an
// option when they manually call changePage(). It should be noted that
// our default transition animations assume that the formPage and toPage
// are different elements, so they may behave unexpectedly. It is up to
// the developer that turns on the allowSamePageTransitiona option to
// either turn off transition animations, or make sure that an appropriate
// animation transition is used.
if (
fromPage &&
fromPage[0] === toPage[0] &&
!settings.allowSamePageTransition
) {
isPageTransitioning = false;
this._triggerWithDeprecated("transition", triggerData);
this.element.trigger("pagechange", triggerData);
// Even if there is no page change to be done, we should keep the
// urlHistory in sync with the hash changes
if (settings.fromHashChange) {
$.mobile.navigate.history.direct({ url: url });
}
return;
}
// We need to make sure the page we are given has already been enhanced.
toPage.page({ role: settings.role });
// If the changePage request was sent from a hashChange event, check to
// see if the page is already within the urlHistory stack. If so, we'll
// assume the user hit the forward/back button and will try to match the
// transition accordingly.
if (settings.fromHashChange) {
historyDir = settings.direction === "back" ? -1 : 1;
}
// Kill the keyboard.
// XXX_jblas: We need to stop crawling the entire document to kill focus.
// Instead, we should be tracking focus with a delegate()
// handler so we already have the element in hand at this
// point.
// Wrap this in a try/catch block since IE9 throw "Unspecified error" if
// document.activeElement is undefined when we are in an IFrame.
try {
if (
document.activeElement &&
document.activeElement.nodeName.toLowerCase() !== "body"
) {
$(document.activeElement).blur();
} else {
$("input:focus, textarea:focus, select:focus").blur();
}
} catch (e) {}
// Record whether we are at a place in history where a dialog used to be -
// if so, do not add a new history entry and do not change the hash either
alreadyThere = false;
// If we're displaying the page as a dialog, we don't want the url
// for the dialog content to be used in the hash. Instead, we want
// to append the dialogHashKey to the url of the current page.
if (isDialog && active) {
// on the initial page load active.url is undefined and in that case
// should be an empty string. Moving the undefined -> empty string back
// into urlHistory.addNew seemed imprudent given undefined better
// represents the url state
// If we are at a place in history that once belonged to a dialog, reuse
// this state without adding to urlHistory and without modifying the
// hash. However, if a dialog is already displayed at this point, and
// we're about to display another dialog, then we must add another hash
// and history entry on top so that one may navigate back to the
// original dialog
if (
active.url &&
active.url.indexOf($.mobile.dialogHashKey) > -1 &&
this.activePage &&
!this.activePage.hasClass("ui-dialog") &&
$.mobile.navigate.history.activeIndex > 0
) {
settings.changeHash = false;
alreadyThere = true;
}
// Normally, we tack on a dialog hash key, but if this is the location
// of a stale dialog, we reuse the URL from the entry
url = active.url || "";
// account for absolute urls instead of just relative urls use as hashes
if (!alreadyThere && url.indexOf("#") > -1) {
url += $.mobile.dialogHashKey;
} else {
url += "#" + $.mobile.dialogHashKey;
}
// tack on another dialogHashKey if this is the same as the initial hash
// this makes sure that a history entry is created for this dialog
if (
$.mobile.navigate.history.activeIndex === 0 &&
url === $.mobile.navigate.history.initialDst
) {
url += $.mobile.dialogHashKey;
}
}
// if title element wasn't found, try the page div data attr too
// If this is a deep-link or a reload ( active === undefined ) then just
// use pageTitle
newPageTitle = !active
? pageTitle
: toPage.jqmData("title") ||
toPage.children(":jqmData(role='header')").find(".ui-title").text();
if (!!newPageTitle && pageTitle === document.title) {
pageTitle = newPageTitle;
}
if (!toPage.jqmData("title")) {
toPage.jqmData("title", pageTitle);
}
// Make sure we have a transition defined.
settings.transition =
settings.transition ||
(historyDir && !activeIsInitialPage
? active.transition
: undefined) ||
(isDialog
? $.mobile.defaultDialogTransition
: $.mobile.defaultPageTransition);
//add page to history stack if it's not back or forward
if (!historyDir && alreadyThere) {
$.mobile.navigate.history.getActive().pageUrl = pageUrl;
}
// Set the location hash.
if (url && !settings.fromHashChange) {
// rebuilding the hash here since we loose it earlier on
// TODO preserve the originally passed in path
if (!$.mobile.path.isPath(url) && url.indexOf("#") < 0) {
url = "#" + url;
}
// TODO the property names here are just silly
params = {
transition: settings.transition,
title: pageTitle,
pageUrl: pageUrl,
role: settings.role,
};
if (settings.changeHash !== false && $.mobile.hashListeningEnabled) {
$.mobile.navigate(url, params, true);
} else if (toPage[0] !== $.mobile.firstPage[0]) {
$.mobile.navigate.history.add(url, params);
}
}
//set page title
document.title = pageTitle;
//set "toPage" as activePage deprecated in 1.4 remove in 1.5
$.mobile.activePage = toPage;
//new way to handle activePage
this.activePage = toPage;
// If we're navigating back in the URL history, set reverse accordingly.
settings.reverse = settings.reverse || historyDir < 0;
cssTransitionDeferred = $.Deferred();
this._cssTransition(toPage, fromPage, {
transition: settings.transition,
reverse: settings.reverse,
deferred: cssTransitionDeferred,
});
cssTransitionDeferred.done(
$.proxy(function (name, reverse, $to, $from, alreadyFocused) {
$.mobile.removeActiveLinkClass();
//if there's a duplicateCachedPage, remove it from the DOM now that it's hidden
if (settings.duplicateCachedPage) {
settings.duplicateCachedPage.remove();
}
// despite visibility: hidden addresses issue #2965
// https://github.com/jquery/jquery-mobile/issues/2965
if (!alreadyFocused) {
$.mobile.focusPage(toPage);
}
this._releaseTransitionLock();
this.element.trigger("pagechange", triggerData);
this._triggerWithDeprecated("transition", triggerData);
}, this),
);
},
// determine the current base url
_findBaseWithDefault: function () {
var closestBase =
this.activePage && $.mobile.getClosestBaseUrl(this.activePage);
return closestBase || $.mobile.path.documentBase.hrefNoHash;
},
});
// The following handlers should be bound after mobileinit has been triggered
// the following deferred is resolved in the init file
$.mobile.navreadyDeferred = $.Deferred();
//these variables make all page containers use the same queue and only navigate one at a time
// queue to hold simultanious page transitions
var pageTransitionQueue = [],
// indicates whether or not page is in process of transitioning
isPageTransitioning = false;
})(jQuery);
(function ($, undefined) {
// resolved on domready
var domreadyDeferred = $.Deferred(),
// resolved and nulled on window.load()
loadDeferred = $.Deferred(),
documentUrl = $.mobile.path.documentUrl,
// used to track last vclicked element to make sure its value is added to form data
$lastVClicked = null;
/* Event Bindings - hashchange, submit, and click */
function findClosestLink(ele) {
while (ele) {
// Look for the closest element with a nodeName of "a".
// Note that we are checking if we have a valid nodeName
// before attempting to access it. This is because the
// node we get called with could have originated from within
// an embedded SVG document where some symbol instance elements
// don't have nodeName defined on them, or strings are of type
// SVGAnimatedString.
if (
typeof ele.nodeName === "string" &&
ele.nodeName.toLowerCase() === "a"
) {
break;
}
ele = ele.parentNode;
}
return ele;
}
$.mobile.loadPage = function (url, opts) {
var container;
opts = opts || {};
container = opts.pageContainer || $.mobile.pageContainer;
// create the deferred that will be supplied to loadPage callers
// and resolved by the content widget's load method
opts.deferred = $.Deferred();
// Preferring to allow exceptions for uninitialized opts.pageContainer
// widgets so we know if we need to force init here for users
container.pagecontainer("load", url, opts);
// provide the deferred
return opts.deferred.promise();
};
//define vars for interal use
/* internal utility functions */
// NOTE Issue #4950 Android phonegap doesn't navigate back properly
// when a full page refresh has taken place. It appears that hashchange
// and replacestate history alterations work fine but we need to support
// both forms of history traversal in our code that uses backward history
// movement
$.mobile.back = function () {
var nav = window.navigator;
// if the setting is on and the navigator object is
// available use the phonegap navigation capability
if (
this.phonegapNavigationEnabled &&
nav &&
nav.app &&
nav.app.backHistory
) {
nav.app.backHistory();
} else {
$.mobile.pageContainer.pagecontainer("back");
}
};
// Direct focus to the page title, or otherwise first focusable element
$.mobile.focusPage = function (page) {
var autofocus = page.find("[autofocus]"),
pageTitle = page.find(".ui-title:eq(0)");
if (autofocus.length) {
autofocus.focus();
return;
}
if (pageTitle.length) {
pageTitle.focus();
} else {
page.focus();
}
};
// No-op implementation of transition degradation
$.mobile._maybeDegradeTransition =
$.mobile._maybeDegradeTransition ||
function (transition) {
return transition;
};
// Exposed $.mobile methods
$.mobile.changePage = function (to, options) {
$.mobile.pageContainer.pagecontainer("change", to, options);
};
$.mobile.changePage.defaults = {
transition: undefined,
reverse: false,
changeHash: true,
fromHashChange: false,
role: undefined, // By default we rely on the role defined by the @data-role attribute.
duplicateCachedPage: undefined,
pageContainer: undefined,
showLoadMsg: true, //loading message shows by default when pages are being fetched during changePage
dataUrl: undefined,
fromPage: undefined,
allowSamePageTransition: false,
};
$.mobile._registerInternalEvents = function () {
var getAjaxFormData = function ($form, calculateOnly) {
var url,
ret = true,
formData,
vclickedName,
method;
if (
!$.mobile.ajaxEnabled ||
// test that the form is, itself, ajax false
$form.is(":jqmData(ajax='false')") ||
// test that $.mobile.ignoreContentEnabled is set and
// the form or one of it's parents is ajax=false
!$form.jqmHijackable().length ||
$form.attr("target")
) {
return false;
}
url =
($lastVClicked && $lastVClicked.attr("formaction")) ||
$form.attr("action");
method = ($form.attr("method") || "get").toLowerCase();
// If no action is specified, browsers default to using the
// URL of the document containing the form. Since we dynamically
// pull in pages from external documents, the form should submit
// to the URL for the source document of the page containing
// the form.
if (!url) {
// Get the @data-url for the page containing the form.
url = $.mobile.getClosestBaseUrl($form);
// NOTE: If the method is "get", we need to strip off the query string
// because it will get replaced with the new form data. See issue #5710.
if (method === "get") {
url = $.mobile.path.parseUrl(url).hrefNoSearch;
}
if (url === $.mobile.path.documentBase.hrefNoHash) {
// The url we got back matches the document base,
// which means the page must be an internal/embedded page,
// so default to using the actual document url as a browser
// would.
url = documentUrl.hrefNoSearch;
}
}
url = $.mobile.path.makeUrlAbsolute(
url,
$.mobile.getClosestBaseUrl($form),
);
if (
$.mobile.path.isExternal(url) &&
!$.mobile.path.isPermittedCrossDomainRequest(documentUrl, url)
) {
return false;
}
if (!calculateOnly) {
formData = $form.serializeArray();
if ($lastVClicked && $lastVClicked[0].form === $form[0]) {
vclickedName = $lastVClicked.attr("name");
if (vclickedName) {
// Make sure the last clicked element is included in the form
$.each(formData, function (key, value) {
if (value.name === vclickedName) {
// Unset vclickedName - we've found it in the serialized data already
vclickedName = "";
return false;
}
});
if (vclickedName) {
formData.push({
name: vclickedName,
value: $lastVClicked.attr("value"),
});
}
}
}
ret = {
url: url,
options: {
type: method,
data: $.param(formData),
transition: $form.jqmData("transition"),
reverse: $form.jqmData("direction") === "reverse",
reloadPage: true,
},
};
}
return ret;
};
//bind to form submit events, handle with Ajax
$.mobile.document.delegate("form", "submit", function (event) {
var formData;
if (!event.isDefaultPrevented()) {
formData = getAjaxFormData($(this));
if (formData) {
$.mobile.changePage(formData.url, formData.options);
event.preventDefault();
}
}
});
//add active state on vclick
$.mobile.document.bind("vclick", function (event) {
var $btn,
btnEls,
target = event.target,
needClosest = false;
// if this isn't a left click we don't care. Its important to note
// that when the virtual event is generated it will create the which attr
if (event.which > 1 || !$.mobile.linkBindingEnabled) {
return;
}
// Record that this element was clicked, in case we need it for correct
// form submission during the "submit" handler above
$lastVClicked = $(target);
// Try to find a target element to which the active class will be applied
if ($.data(target, "mobile-button")) {
// If the form will not be submitted via AJAX, do not add active class
if (!getAjaxFormData($(target).closest("form"), true)) {
return;
}
// We will apply the active state to this button widget - the parent
// of the input that was clicked will have the associated data
if (target.parentNode) {
target = target.parentNode;
}
} else {
target = findClosestLink(target);
if (
!(
target &&
$.mobile.path.parseUrl(target.getAttribute("href") || "#")
.hash !== "#"
)
) {
return;
}
// TODO teach $.mobile.hijackable to operate on raw dom elements so the
// link wrapping can be avoided
if (!$(target).jqmHijackable().length) {
return;
}
}
// Avoid calling .closest by using the data set during .buttonMarkup()
// List items have the button data in the parent of the element clicked
if (!!~target.className.indexOf("ui-link-inherit")) {
if (target.parentNode) {
btnEls = $.data(target.parentNode, "buttonElements");
}
// Otherwise, look for the data on the target itself
} else {
btnEls = $.data(target, "buttonElements");
}
// If found, grab the button's outer element
if (btnEls) {
target = btnEls.outer;
} else {
needClosest = true;
}
$btn = $(target);
// If the outer element wasn't found by the our heuristics, use .closest()
if (needClosest) {
$btn = $btn.closest(".ui-btn");
}
if (
$btn.length > 0 &&
!$btn.hasClass(
"ui-state-disabled" ||
// DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
$btn.hasClass("ui-disabled"),
)
) {
$.mobile.removeActiveLinkClass(true);
$.mobile.activeClickedLink = $btn;
$.mobile.activeClickedLink.addClass($.mobile.activeBtnClass);
}
});
// click routing - direct to HTTP or Ajax, accordingly
$.mobile.document.bind("click", function (event) {
if (!$.mobile.linkBindingEnabled || event.isDefaultPrevented()) {
return;
}
var link = findClosestLink(event.target),
$link = $(link),
//remove active link class if external (then it won't be there if you come back)
httpCleanup = function () {
window.setTimeout(function () {
$.mobile.removeActiveLinkClass(true);
}, 200);
},
baseUrl,
href,
useDefaultUrlHandling,
isExternal,
transition,
reverse,
role;
// If a button was clicked, clean up the active class added by vclick above
if (
$.mobile.activeClickedLink &&
$.mobile.activeClickedLink[0] === event.target.parentNode
) {
httpCleanup();
}
// If there is no link associated with the click or its not a left
// click we want to ignore the click
// TODO teach $.mobile.hijackable to operate on raw dom elements so the link wrapping
// can be avoided
if (!link || event.which > 1 || !$link.jqmHijackable().length) {
return;
}
//if there's a data-rel=back attr, go back in history
if ($link.is(":jqmData(rel='back')")) {
$.mobile.back();
return false;
}
baseUrl = $.mobile.getClosestBaseUrl($link);
//get href, if defined, otherwise default to empty hash
href = $.mobile.path.makeUrlAbsolute(
$link.attr("href") || "#",
baseUrl,
);
//if ajax is disabled, exit early
if (!$.mobile.ajaxEnabled && !$.mobile.path.isEmbeddedPage(href)) {
httpCleanup();
//use default click handling
return;
}
// XXX_jblas: Ideally links to application pages should be specified as
// an url to the application document with a hash that is either
// the site relative path or id to the page. But some of the
// internal code that dynamically generates sub-pages for nested
// lists and select dialogs, just write a hash in the link they
// create. This means the actual URL path is based on whatever
// the current value of the base tag is at the time this code
// is called. For now we are just assuming that any url with a
// hash in it is an application page reference.
if (href.search("#") !== -1) {
href = href.replace(/[^#]*#/, "");
if (!href) {
//link was an empty hash meant purely
//for interaction, so we ignore it.
event.preventDefault();
return;
} else if ($.mobile.path.isPath(href)) {
//we have apath so make it the href we want to load.
href = $.mobile.path.makeUrlAbsolute(href, baseUrl);
} else {
//we have a simple id so use the documentUrl as its base.
href = $.mobile.path.makeUrlAbsolute(
"#" + href,
documentUrl.hrefNoHash,
);
}
}
// Should we handle this link, or let the browser deal with it?
useDefaultUrlHandling =
$link.is("[rel='external']") ||
$link.is(":jqmData(ajax='false')") ||
$link.is("[target]");
// Some embedded browsers, like the web view in Phone Gap, allow cross-domain XHR
// requests if the document doing the request was loaded via the file:// protocol.
// This is usually to allow the application to "phone home" and fetch app specific
// data. We normally let the browser handle external/cross-domain urls, but if the
// allowCrossDomainPages option is true, we will allow cross-domain http/https
// requests to go through our page loading logic.
//check for protocol or rel and its not an embedded page
//TODO overlap in logic from isExternal, rel=external check should be
// moved into more comprehensive isExternalLink
isExternal =
useDefaultUrlHandling ||
($.mobile.path.isExternal(href) &&
!$.mobile.path.isPermittedCrossDomainRequest(documentUrl, href));
if (isExternal) {
httpCleanup();
//use default click handling
return;
}
//use ajax
transition = $link.jqmData("transition");
reverse =
$link.jqmData("direction") === "reverse" ||
// deprecated - remove by 1.0
$link.jqmData("back");
//this may need to be more specific as we use data-rel more
role = $link.attr("data-" + $.mobile.ns + "rel") || undefined;
$.mobile.changePage(href, {
transition: transition,
reverse: reverse,
role: role,
link: $link,
});
event.preventDefault();
});
//prefetch pages when anchors with data-prefetch are encountered
$.mobile.document.delegate(".ui-page", "pageshow.prefetch", function () {
var urls = [];
$(this)
.find("a:jqmData(prefetch)")
.each(function () {
var $link = $(this),
url = $link.attr("href");
if (url && $.inArray(url, urls) === -1) {
urls.push(url);
$.mobile.loadPage(url, {
role: $link.attr("data-" + $.mobile.ns + "rel"),
prefetch: true,
});
}
});
});
// TODO ensure that the navigate binding in the content widget happens at the right time
$.mobile.pageContainer.pagecontainer();
//set page min-heights to be device specific
$.mobile.document.bind("pageshow", function () {
// We need to wait for window.load to make sure that styles have already been rendered,
// otherwise heights of external toolbars will have the wrong value
if (loadDeferred) {
loadDeferred.done($.mobile.resetActivePageHeight);
} else {
$.mobile.resetActivePageHeight();
}
});
$.mobile.window.bind("throttledresize", $.mobile.resetActivePageHeight);
}; //navreadyDeferred done callback
$(function () {
domreadyDeferred.resolve();
});
$.mobile.window.load(function () {
// Resolve and null the deferred
loadDeferred.resolve();
loadDeferred = null;
});
$.when(domreadyDeferred, $.mobile.navreadyDeferred).done(function () {
$.mobile._registerInternalEvents();
});
})(jQuery);
(function ($, window, undefined) {
// TODO remove direct references to $.mobile and properties, we should
// favor injection with params to the constructor
$.mobile.Transition = function () {
this.init.apply(this, arguments);
};
$.extend($.mobile.Transition.prototype, {
toPreClass: " ui-page-pre-in",
init: function (name, reverse, $to, $from) {
$.extend(this, {
name: name,
reverse: reverse,
$to: $to,
$from: $from,
deferred: new $.Deferred(),
});
},
cleanFrom: function () {
this.$from
.removeClass(
$.mobile.activePageClass + " out in reverse " + this.name,
)
.height("");
},
// NOTE overridden by child object prototypes, noop'd here as defaults
beforeDoneIn: function () {},
beforeDoneOut: function () {},
beforeStartOut: function () {},
doneIn: function () {
this.beforeDoneIn();
this.$to.removeClass("out in reverse " + this.name).height("");
this.toggleViewportClass();
// In some browsers (iOS5), 3D transitions block the ability to scroll to the desired location during transition
// This ensures we jump to that spot after the fact, if we aren't there already.
if ($.mobile.window.scrollTop() !== this.toScroll) {
this.scrollPage();
}
if (!this.sequential) {
this.$to.addClass($.mobile.activePageClass);
}
this.deferred.resolve(
this.name,
this.reverse,
this.$to,
this.$from,
true,
);
},
doneOut: function (screenHeight, reverseClass, none, preventFocus) {
this.beforeDoneOut();
this.startIn(screenHeight, reverseClass, none, preventFocus);
},
hideIn: function (callback) {
// Prevent flickering in phonegap container: see comments at #4024 regarding iOS
this.$to.css("z-index", -10);
callback.call(this);
this.$to.css("z-index", "");
},
scrollPage: function () {
// By using scrollTo instead of silentScroll, we can keep things better in order
// Just to be precautios, disable scrollstart listening like silentScroll would
$.event.special.scrollstart.enabled = false;
//if we are hiding the url bar or the page was previously scrolled scroll to hide or return to position
if (
$.mobile.hideUrlBar ||
this.toScroll !== $.mobile.defaultHomeScroll
) {
window.scrollTo(0, this.toScroll);
}
// reenable scrollstart listening like silentScroll would
setTimeout(function () {
$.event.special.scrollstart.enabled = true;
}, 150);
},
startIn: function (screenHeight, reverseClass, none, preventFocus) {
this.hideIn(function () {
this.$to.addClass($.mobile.activePageClass + this.toPreClass);
// Send focus to page as it is now display: block
if (!preventFocus) {
$.mobile.focusPage(this.$to);
}
// Set to page height
this.$to.height(screenHeight + this.toScroll);
if (!none) {
this.scrollPage();
}
});
this.$to
.removeClass(this.toPreClass)
.addClass(this.name + " in " + reverseClass);
if (!none) {
this.$to.animationComplete(
$.proxy(function () {
this.doneIn();
}, this),
);
} else {
this.doneIn();
}
},
startOut: function (screenHeight, reverseClass, none) {
this.beforeStartOut(screenHeight, reverseClass, none);
// Set the from page's height and start it transitioning out
// Note: setting an explicit height helps eliminate tiling in the transitions
this.$from
.height(screenHeight + $.mobile.window.scrollTop())
.addClass(this.name + " out" + reverseClass);
},
toggleViewportClass: function () {
$.mobile.pageContainer.toggleClass(
"ui-mobile-viewport-transitioning viewport-" + this.name,
);
},
transition: function () {
// NOTE many of these could be calculated/recorded in the constructor, it's my
// opinion that binding them as late as possible has value with regards to
// better transitions with fewer bugs. Ie, it's not guaranteed that the
// object will be created and transition will be run immediately after as
// it is today. So we wait until transition is invoked to gather the following
var none,
reverseClass = this.reverse ? " reverse" : "",
screenHeight = $.mobile.getScreenHeight(),
maxTransitionOverride =
$.mobile.maxTransitionWidth !== false &&
$.mobile.window.width() > $.mobile.maxTransitionWidth;
this.toScroll =
$.mobile.navigate.history.getActive().lastScroll ||
$.mobile.defaultHomeScroll;
none =
!$.support.cssTransitions ||
!$.support.cssAnimations ||
maxTransitionOverride ||
!this.name ||
this.name === "none" ||
Math.max($.mobile.window.scrollTop(), this.toScroll) >
$.mobile.getMaxScrollForTransition();
this.toggleViewportClass();
if (this.$from && !none) {
this.startOut(screenHeight, reverseClass, none);
} else {
this.doneOut(screenHeight, reverseClass, none, true);
}
return this.deferred.promise();
},
});
})(jQuery, this);
(function ($) {
$.mobile.SerialTransition = function () {
this.init.apply(this, arguments);
};
$.extend(
$.mobile.SerialTransition.prototype,
$.mobile.Transition.prototype,
{
sequential: true,
beforeDoneOut: function () {
if (this.$from) {
this.cleanFrom();
}
},
beforeStartOut: function (screenHeight, reverseClass, none) {
this.$from.animationComplete(
$.proxy(function () {
this.doneOut(screenHeight, reverseClass, none);
}, this),
);
},
},
);
})(jQuery);
(function ($) {
$.mobile.ConcurrentTransition = function () {
this.init.apply(this, arguments);
};
$.extend(
$.mobile.ConcurrentTransition.prototype,
$.mobile.Transition.prototype,
{
sequential: false,
beforeDoneIn: function () {
if (this.$from) {
this.cleanFrom();
}
},
beforeStartOut: function (screenHeight, reverseClass, none) {
this.doneOut(screenHeight, reverseClass, none);
},
},
);
})(jQuery);
(function ($) {
// generate the handlers from the above
var defaultGetMaxScrollForTransition = function () {
return $.mobile.getScreenHeight() * 3;
};
//transition handler dictionary for 3rd party transitions
$.mobile.transitionHandlers = {
sequential: $.mobile.SerialTransition,
simultaneous: $.mobile.ConcurrentTransition,
};
// Make our transition handler the public default.
$.mobile.defaultTransitionHandler = $.mobile.transitionHandlers.sequential;
$.mobile.transitionFallbacks = {};
// If transition is defined, check if css 3D transforms are supported, and if not, if a fallback is specified
$.mobile._maybeDegradeTransition = function (transition) {
if (
transition &&
!$.support.cssTransform3d &&
$.mobile.transitionFallbacks[transition]
) {
transition = $.mobile.transitionFallbacks[transition];
}
return transition;
};
// Set the getMaxScrollForTransition to default if no implementation was set by user
$.mobile.getMaxScrollForTransition =
$.mobile.getMaxScrollForTransition || defaultGetMaxScrollForTransition;
})(jQuery);
/*
* fallback transition for flip in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.flip = "fade";
})(jQuery, this);
/*
* fallback transition for flow in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.flow = "fade";
})(jQuery, this);
/*
* fallback transition for pop in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.pop = "fade";
})(jQuery, this);
/*
* fallback transition for slide in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
// Use the simultaneous transitions handler for slide transitions
$.mobile.transitionHandlers.slide =
$.mobile.transitionHandlers.simultaneous;
// Set the slide transitions's fallback to "fade"
$.mobile.transitionFallbacks.slide = "fade";
})(jQuery, this);
/*
* fallback transition for slidedown in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.slidedown = "fade";
})(jQuery, this);
/*
* fallback transition for slidefade in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
// Set the slide transitions's fallback to "fade"
$.mobile.transitionFallbacks.slidefade = "fade";
})(jQuery, this);
/*
* fallback transition for slideup in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.slideup = "fade";
})(jQuery, this);
/*
* fallback transition for turn in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function ($, window, undefined) {
$.mobile.transitionFallbacks.turn = "fade";
})(jQuery, this);
(function ($, undefined) {
$.mobile.degradeInputs = {
color: false,
date: false,
datetime: false,
"datetime-local": false,
email: false,
month: false,
number: false,
range: "number",
search: "text",
tel: false,
time: false,
url: false,
week: false,
};
// Backcompat remove in 1.5
$.mobile.page.prototype.options.degradeInputs = $.mobile.degradeInputs;
// Auto self-init widgets
$.mobile.degradeInputsWithin = function (target) {
target = $(target);
// Degrade inputs to avoid poorly implemented native functionality
target
.find("input")
.not($.mobile.page.prototype.keepNativeSelector())
.each(function () {
var element = $(this),
type = this.getAttribute("type"),
optType = $.mobile.degradeInputs[type] || "text",
html,
hasType,
findstr,
repstr;
if ($.mobile.degradeInputs[type]) {
html = $("<div>").html(element.clone()).html();
// In IE browsers, the type sometimes doesn't exist in the cloned markup, so we replace the closing tag instead
hasType = html.indexOf(" type=") > -1;
findstr = hasType ? /\s+type=["']?\w+['"]?/ : /\/?>/;
repstr =
' type="' +
optType +
'" data-' +
$.mobile.ns +
'type="' +
type +
'"' +
(hasType ? "" : ">");
element.replaceWith(html.replace(findstr, repstr));
}
});
};
})(jQuery);
(function ($, window, undefined) {
$.widget("mobile.page", $.mobile.page, {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: true,
dialog: false,
},
_create: function () {
this._super();
if (this.options.dialog) {
$.extend(this, {
_inner: this.element.children(),
_headerCloseButton: null,
});
if (!this.options.enhanced) {
this._setCloseBtn(this.options.closeBtn);
}
}
},
_enhance: function () {
this._super();
// Class the markup for dialog styling and wrap interior
if (this.options.dialog) {
this.element.addClass("ui-dialog").wrapInner(
$("<div/>", {
// ARIA role
role: "dialog",
class:
"ui-dialog-contain ui-overlay-shadow" +
(this.options.corners ? " ui-corner-all" : ""),
}),
);
}
},
_setOptions: function (options) {
var closeButtonLocation,
closeButtonText,
currentOpts = this.options;
if (options.corners !== undefined) {
this._inner.toggleClass("ui-corner-all", !!options.corners);
}
if (options.overlayTheme !== undefined) {
if ($.mobile.activePage[0] === this.element[0]) {
currentOpts.overlayTheme = options.overlayTheme;
this._handlePageBeforeShow();
}
}
if (options.closeBtnText !== undefined) {
closeButtonLocation = currentOpts.closeBtn;
closeButtonText = options.closeBtnText;
}
if (options.closeBtn !== undefined) {
closeButtonLocation = options.closeBtn;
}
if (closeButtonLocation) {
this._setCloseBtn(closeButtonLocation, closeButtonText);
}
this._super(options);
},
_handlePageBeforeShow: function () {
if (this.options.overlayTheme && this.options.dialog) {
this.removeContainerBackground();
this.setContainerBackground(this.options.overlayTheme);
} else {
this._super();
}
},
_setCloseBtn: function (location, text) {
var dst,
btn = this._headerCloseButton;
// Sanitize value
location =
"left" === location
? "left"
: "right" === location
? "right"
: "none";
if ("none" === location) {
if (btn) {
btn.remove();
btn = null;
}
} else if (btn) {
btn
.removeClass("ui-btn-left ui-btn-right")
.addClass("ui-btn-" + location);
if (text) {
btn.text(text);
}
} else {
dst = this._inner.find(":jqmData(role='header')").first();
btn = $("<a></a>", {
href: "#",
class:
"ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" +
location,
})
.attr("data-" + $.mobile.ns + "rel", "back")
.text(text || this.options.closeBtnText || "")
.prependTo(dst);
}
this._headerCloseButton = btn;
},
});
})(jQuery, this);
(function ($, window, undefined) {
$.widget("mobile.dialog", {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: true,
},
// Override the theme set by the page plugin on pageshow
_handlePageBeforeShow: function () {
this._isCloseable = true;
if (this.options.overlayTheme) {
this.element
.page("removeContainerBackground")
.page("setContainerBackground", this.options.overlayTheme);
}
},
_handlePageBeforeHide: function () {
this._isCloseable = false;
},
// click and submit events:
// - clicks and submits should use the closing transition that the dialog
// opened with unless a data-transition is specified on the link/form
// - if the click was on the close button, or the link has a data-rel="back"
// it'll go back in history naturally
_handleVClickSubmit: function (event) {
var attrs,
$target = $(event.target).closest(
event.type === "vclick" ? "a" : "form",
);
if ($target.length && !$target.jqmData("transition")) {
attrs = {};
attrs["data-" + $.mobile.ns + "transition"] =
($.mobile.navigate.history.getActive() || {})["transition"] ||
$.mobile.defaultDialogTransition;
attrs["data-" + $.mobile.ns + "direction"] = "reverse";
$target.attr(attrs);
}
},
_create: function () {
var elem = this.element,
opts = this.options;
// Class the markup for dialog styling and wrap interior
elem.addClass("ui-dialog").wrapInner(
$("<div/>", {
// ARIA role
role: "dialog",
class:
"ui-dialog-contain ui-overlay-shadow" +
(!!opts.corners ? " ui-corner-all" : ""),
}),
);
$.extend(this, {
_isCloseable: false,
_inner: elem.children(),
_headerCloseButton: null,
});
this._on(elem, {
vclick: "_handleVClickSubmit",
submit: "_handleVClickSubmit",
pagebeforeshow: "_handlePageBeforeShow",
pagebeforehide: "_handlePageBeforeHide",
});
this._setCloseBtn(opts.closeBtn);
},
_setOptions: function (options) {
var closeButtonLocation,
closeButtonText,
currentOpts = this.options;
if (options.corners !== undefined) {
this._inner.toggleClass("ui-corner-all", !!options.corners);
}
if (options.overlayTheme !== undefined) {
if ($.mobile.activePage[0] === this.element[0]) {
currentOpts.overlayTheme = options.overlayTheme;
this._handlePageBeforeShow();
}
}
if (options.closeBtnText !== undefined) {
closeButtonLocation = currentOpts.closeBtn;
closeButtonText = options.closeBtnText;
}
if (options.closeBtn !== undefined) {
closeButtonLocation = options.closeBtn;
}
if (closeButtonLocation) {
this._setCloseBtn(closeButtonLocation, closeButtonText);
}
this._super(options);
},
_setCloseBtn: function (location, text) {
var dst,
btn = this._headerCloseButton;
// Sanitize value
location =
"left" === location
? "left"
: "right" === location
? "right"
: "none";
if ("none" === location) {
if (btn) {
btn.remove();
btn = null;
}
} else if (btn) {
btn
.removeClass("ui-btn-left ui-btn-right")
.addClass("ui-btn-" + location);
if (text) {
btn.text(text);
}
} else {
dst = this._inner.find(":jqmData(role='header')").first();
btn = $("<a></a>", {
role: "button",
href: "#",
class:
"ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" +
location,
})
.text(text || this.options.closeBtnText || "")
.prependTo(dst);
this._on(btn, { click: "close" });
}
this._headerCloseButton = btn;
},
// Close method goes back in history
close: function () {
var hist = $.mobile.navigate.history;
if (this._isCloseable) {
this._isCloseable = false;
// If the hash listening is enabled and there is at least one preceding history
// entry it's ok to go back. Initial pages with the dialog hash state are an example
// where the stack check is necessary
if ($.mobile.hashListeningEnabled && hist.activeIndex > 0) {
$.mobile.back();
} else {
$.mobile.pageContainer.pagecontainer("back");
}
}
},
});
})(jQuery, this);
(function ($, undefined) {
var rInitialLetter = /([A-Z])/g,
// Construct iconpos class from iconpos value
iconposClass = function (iconpos) {
return "ui-btn-icon-" + (iconpos === null ? "left" : iconpos);
};
$.widget("mobile.collapsible", {
options: {
enhanced: false,
expandCueText: null,
collapseCueText: null,
collapsed: true,
heading: "h1,h2,h3,h4,h5,h6,legend",
collapsedIcon: null,
expandedIcon: null,
iconpos: null,
theme: null,
contentTheme: null,
inset: null,
corners: null,
mini: null,
},
_create: function () {
var elem = this.element,
ui = {
accordion: elem
.closest(
":jqmData(role='collapsible-set')," +
":jqmData(role='collapsibleset')" +
($.mobile.collapsibleset ? ", :mobile-collapsibleset" : ""),
)
.addClass("ui-collapsible-set"),
};
this._ui = ui;
this._renderedOptions = this._getOptions(this.options);
if (this.options.enhanced) {
ui.heading = $(".ui-collapsible-heading", this.element[0]);
ui.content = ui.heading.next();
ui.anchor = $("a", ui.heading[0]).first();
ui.status = ui.anchor.children(".ui-collapsible-heading-status");
} else {
this._enhance(elem, ui);
}
this._on(ui.heading, {
tap: function () {
ui.heading.find("a").first().addClass($.mobile.activeBtnClass);
},
click: function (event) {
this._handleExpandCollapse(
!ui.heading.hasClass("ui-collapsible-heading-collapsed"),
);
event.preventDefault();
event.stopPropagation();
},
});
},
// Adjust the keys inside options for inherited values
_getOptions: function (options) {
var key,
accordion = this._ui.accordion,
accordionWidget = this._ui.accordionWidget;
// Copy options
options = $.extend({}, options);
if (accordion.length && !accordionWidget) {
this._ui.accordionWidget = accordionWidget = accordion.data(
"mobile-collapsibleset",
);
}
for (key in options) {
// Retrieve the option value first from the options object passed in and, if
// null, from the parent accordion or, if that's null too, or if there's no
// parent accordion, then from the defaults.
options[key] =
options[key] != null
? options[key]
: accordionWidget
? accordionWidget.options[key]
: accordion.length
? $.mobile.getAttribute(
accordion[0],
key.replace(rInitialLetter, "-$1").toLowerCase(),
)
: null;
if (null == options[key]) {
options[key] = $.mobile.collapsible.defaults[key];
}
}
return options;
},
_themeClassFromOption: function (prefix, value) {
return value ? (value === "none" ? "" : prefix + value) : "";
},
_enhance: function (elem, ui) {
var iconclass,
opts = this._renderedOptions,
contentThemeClass = this._themeClassFromOption(
"ui-body-",
opts.contentTheme,
);
elem.addClass(
"ui-collapsible " +
(opts.inset ? "ui-collapsible-inset " : "") +
(opts.inset && opts.corners ? "ui-corner-all " : "") +
(contentThemeClass ? "ui-collapsible-themed-content " : ""),
);
(ui.originalHeading = elem.children(this.options.heading).first()),
(ui.content = elem
.wrapInner(
"<div " +
"class='ui-collapsible-content " +
contentThemeClass +
"'></div>",
)
.children(".ui-collapsible-content")),
(ui.heading = ui.originalHeading);
// Replace collapsibleHeading if it's a legend
if (ui.heading.is("legend")) {
ui.heading = $("<div role='heading'>" + ui.heading.html() + "</div>");
ui.placeholder = $(
"<div><!-- placeholder for legend --></div>",
).insertBefore(ui.originalHeading);
ui.originalHeading.remove();
}
iconclass = opts.collapsed
? opts.collapsedIcon
? "ui-icon-" + opts.collapsedIcon
: ""
: opts.expandedIcon
? "ui-icon-" + opts.expandedIcon
: "";
ui.status = $("<span class='ui-collapsible-heading-status'></span>");
ui.anchor = ui.heading
.detach()
//modify markup & attributes
.addClass("ui-collapsible-heading")
.append(ui.status)
.wrapInner("<a href='#' class='ui-collapsible-heading-toggle'></a>")
.find("a")
.first()
.addClass(
"ui-btn " +
(iconclass ? iconclass + " " : "") +
(iconclass ? iconposClass(opts.iconpos) + " " : "") +
this._themeClassFromOption("ui-btn-", opts.theme) +
" " +
(opts.mini ? "ui-mini " : ""),
);
//drop heading in before content
ui.heading.insertBefore(ui.content);
this._handleExpandCollapse(this.options.collapsed);
return ui;
},
refresh: function () {
this._applyOptions(this.options);
this._renderedOptions = this._getOptions(this.options);
},
_applyOptions: function (options) {
var isCollapsed,
newTheme,
oldTheme,
hasCorners,
hasIcon,
elem = this.element,
currentOpts = this._renderedOptions,
ui = this._ui,
anchor = ui.anchor,
status = ui.status,
opts = this._getOptions(options);
// First and foremost we need to make sure the collapsible is in the proper
// state, in case somebody decided to change the collapsed option at the
// same time as another option
if (options.collapsed !== undefined) {
this._handleExpandCollapse(options.collapsed);
}
isCollapsed = elem.hasClass("ui-collapsible-collapsed");
// We only need to apply the cue text for the current state right away.
// The cue text for the alternate state will be stored in the options
// and applied the next time the collapsible's state is toggled
if (isCollapsed) {
if (opts.expandCueText !== undefined) {
status.text(opts.expandCueText);
}
} else {
if (opts.collapseCueText !== undefined) {
status.text(opts.collapseCueText);
}
}
// Update icon
// Is it supposed to have an icon?
hasIcon =
// If the collapsedIcon is being set, consult that
opts.collapsedIcon !== undefined
? opts.collapsedIcon !== false
: // Otherwise consult the existing option value
currentOpts.collapsedIcon !== false;
// If any icon-related options have changed, make sure the new icon
// state is reflected by first removing all icon-related classes
// reflecting the current state and then adding all icon-related
// classes for the new state
if (
!(
opts.iconpos === undefined &&
opts.collapsedIcon === undefined &&
opts.expandedIcon === undefined
)
) {
// Remove all current icon-related classes
anchor.removeClass(
[iconposClass(currentOpts.iconpos)]
.concat(
currentOpts.expandedIcon
? ["ui-icon-" + currentOpts.expandedIcon]
: [],
)
.concat(
currentOpts.collapsedIcon
? ["ui-icon-" + currentOpts.collapsedIcon]
: [],
)
.join(" "),
);
// Add new classes if an icon is supposed to be present
if (hasIcon) {
anchor.addClass(
[
iconposClass(
opts.iconpos !== undefined
? opts.iconpos
: currentOpts.iconpos,
),
]
.concat(
isCollapsed
? [
"ui-icon-" +
(opts.collapsedIcon !== undefined
? opts.collapsedIcon
: currentOpts.collapsedIcon),
]
: [
"ui-icon-" +
(opts.expandedIcon !== undefined
? opts.expandedIcon
: currentOpts.expandedIcon),
],
)
.join(" "),
);
}
}
if (opts.theme !== undefined) {
oldTheme = this._themeClassFromOption("ui-btn-", currentOpts.theme);
newTheme = this._themeClassFromOption("ui-btn-", opts.theme);
anchor.removeClass(oldTheme).addClass(newTheme);
}
if (opts.contentTheme !== undefined) {
oldTheme = this._themeClassFromOption(
"ui-body-",
currentOpts.contentTheme,
);
newTheme = this._themeClassFromOption("ui-body-", opts.contentTheme);
ui.content.removeClass(oldTheme).addClass(newTheme);
}
if (opts.inset !== undefined) {
elem.toggleClass("ui-collapsible-inset", opts.inset);
hasCorners = !!(opts.inset && (opts.corners || currentOpts.corners));
}
if (opts.corners !== undefined) {
hasCorners = !!(opts.corners && (opts.inset || currentOpts.inset));
}
if (hasCorners !== undefined) {
elem.toggleClass("ui-corner-all", hasCorners);
}
if (opts.mini !== undefined) {
anchor.toggleClass("ui-mini", opts.mini);
}
},
_setOptions: function (options) {
this._applyOptions(options);
this._super(options);
this._renderedOptions = this._getOptions(this.options);
},
_handleExpandCollapse: function (isCollapse) {
var opts = this._renderedOptions,
ui = this._ui;
ui.status.text(isCollapse ? opts.expandCueText : opts.collapseCueText);
ui.heading
.toggleClass("ui-collapsible-heading-collapsed", isCollapse)
.find("a")
.first()
.toggleClass("ui-icon-" + opts.expandedIcon, !isCollapse)
// logic or cause same icon for expanded/collapsed state would remove the ui-icon-class
.toggleClass(
"ui-icon-" + opts.collapsedIcon,
isCollapse || opts.expandedIcon === opts.collapsedIcon,
)
.removeClass($.mobile.activeBtnClass);
this.element.toggleClass("ui-collapsible-collapsed", isCollapse);
ui.content
.toggleClass("ui-collapsible-content-collapsed", isCollapse)
.attr("aria-hidden", isCollapse)
.trigger("updatelayout");
this.options.collapsed = isCollapse;
this._trigger(isCollapse ? "collapse" : "expand");
},
expand: function () {
this._handleExpandCollapse(false);
},
collapse: function () {
this._handleExpandCollapse(true);
},
_destroy: function () {
var ui = this._ui,
opts = this.options;
if (opts.enhanced) {
return;
}
if (ui.placeholder) {
ui.originalHeading.insertBefore(ui.placeholder);
ui.placeholder.remove();
ui.heading.remove();
} else {
ui.status.remove();
ui.heading
.removeClass(
"ui-collapsible-heading ui-collapsible-heading-collapsed",
)
.children()
.contents()
.unwrap();
}
ui.anchor.contents().unwrap();
ui.content.contents().unwrap();
this.element.removeClass(
"ui-collapsible ui-collapsible-collapsed " +
"ui-collapsible-themed-content ui-collapsible-inset ui-corner-all",
);
},
});
// Defaults to be used by all instances of collapsible if per-instance values
// are unset or if nothing is specified by way of inheritance from an accordion.
// Note that this hash does not contain options "collapsed" or "heading",
// because those are not inheritable.
$.mobile.collapsible.defaults = {
expandCueText: " click to expand contents",
collapseCueText: " click to collapse contents",
collapsedIcon: "plus",
contentTheme: "inherit",
expandedIcon: "minus",
iconpos: "left",
inset: true,
corners: true,
theme: "inherit",
mini: false,
};
})(jQuery);
(function ($, undefined) {
$.mobile.behaviors.addFirstLastClasses = {
_getVisibles: function ($els, create) {
var visibles;
if (create) {
visibles = $els.not(".ui-screen-hidden");
} else {
visibles = $els.filter(":visible");
if (visibles.length === 0) {
visibles = $els.not(".ui-screen-hidden");
}
}
return visibles;
},
_addFirstLastClasses: function ($els, $visibles, create) {
$els.removeClass("ui-first-child ui-last-child");
$visibles
.eq(0)
.addClass("ui-first-child")
.end()
.last()
.addClass("ui-last-child");
if (!create) {
this.element.trigger("updatelayout");
}
},
_removeFirstLastClasses: function ($els) {
$els.removeClass("ui-first-child ui-last-child");
},
};
})(jQuery);
(function ($, undefined) {
var childCollapsiblesSelector =
":mobile-collapsible, " + $.mobile.collapsible.initSelector;
$.widget(
"mobile.collapsibleset",
$.extend(
{
// The initSelector is deprecated as of 1.4.0. In 1.5.0 we will use
// :jqmData(role='collapsibleset') which will allow us to get rid of the line
// below altogether, because the autoinit will generate such an initSelector
initSelector:
":jqmData(role='collapsible-set'),:jqmData(role='collapsibleset')",
options: $.extend(
{
enhanced: false,
},
$.mobile.collapsible.defaults,
),
_handleCollapsibleExpand: function (event) {
var closestCollapsible = $(event.target).closest(".ui-collapsible");
if (
closestCollapsible
.parent()
.is(":mobile-collapsibleset, :jqmData(role='collapsible-set')")
) {
closestCollapsible
.siblings(".ui-collapsible:not(.ui-collapsible-collapsed)")
.collapsible("collapse");
}
},
_create: function () {
var elem = this.element,
opts = this.options;
$.extend(this, {
_classes: "",
});
if (!opts.enhanced) {
elem.addClass(
"ui-collapsible-set " +
this._themeClassFromOption("ui-group-theme-", opts.theme) +
" " +
(opts.corners && opts.inset ? "ui-corner-all " : ""),
);
this.element
.find($.mobile.collapsible.initSelector)
.collapsible();
}
this._on(elem, { collapsibleexpand: "_handleCollapsibleExpand" });
},
_themeClassFromOption: function (prefix, value) {
return value ? (value === "none" ? "" : prefix + value) : "";
},
_init: function () {
this._refresh(true);
// Because the corners are handled by the collapsible itself and the default state is collapsed
// That was causing https://github.com/jquery/jquery-mobile/issues/4116
this.element
.children(childCollapsiblesSelector)
.filter(":jqmData(collapsed='false')")
.collapsible("expand");
},
_setOptions: function (options) {
var ret,
hasCorners,
elem = this.element,
themeClass = this._themeClassFromOption(
"ui-group-theme-",
options.theme,
);
if (themeClass) {
elem
.removeClass(
this._themeClassFromOption(
"ui-group-theme-",
this.options.theme,
),
)
.addClass(themeClass);
}
if (options.inset !== undefined) {
hasCorners = !!(
options.inset &&
(options.corners || this.options.corners)
);
}
if (options.corners !== undefined) {
hasCorners = !!(
options.corners &&
(options.inset || this.options.inset)
);
}
if (hasCorners !== undefined) {
elem.toggleClass("ui-corner-all", hasCorners);
}
ret = this._super(options);
this.element.children(":mobile-collapsible").collapsible("refresh");
return ret;
},
_destroy: function () {
var el = this.element;
this._removeFirstLastClasses(
el.children(childCollapsiblesSelector),
);
el.removeClass(
"ui-collapsible-set ui-corner-all " +
this._themeClassFromOption(
"ui-group-theme-",
this.options.theme,
),
)
.children(":mobile-collapsible")
.collapsible("destroy");
},
_refresh: function (create) {
var collapsiblesInSet = this.element.children(
childCollapsiblesSelector,
);
this.element
.find($.mobile.collapsible.initSelector)
.not(".ui-collapsible")
.collapsible();
this._addFirstLastClasses(
collapsiblesInSet,
this._getVisibles(collapsiblesInSet, create),
create,
);
},
refresh: function () {
this._refresh(false);
},
},
$.mobile.behaviors.addFirstLastClasses,
),
);
})(jQuery);
(function ($, undefined) {
// Deprecated in 1.4
$.fn.fieldcontain = function (/* options */) {
return this.addClass("ui-field-contain");
};
})(jQuery);
(function ($, undefined) {
$.fn.grid = function (options) {
return this.each(function () {
var $this = $(this),
o = $.extend(
{
grid: null,
},
options,
),
$kids = $this.children(),
gridCols = { solo: 1, a: 2, b: 3, c: 4, d: 5 },
grid = o.grid,
iterator,
letter;
if (!grid) {
if ($kids.length <= 5) {
for (letter in gridCols) {
if (gridCols[letter] === $kids.length) {
grid = letter;
}
}
} else {
grid = "a";
$this.addClass("ui-grid-duo");
}
}
iterator = gridCols[grid];
$this.addClass("ui-grid-" + grid);
$kids.filter(":nth-child(" + iterator + "n+1)").addClass("ui-block-a");
if (iterator > 1) {
$kids
.filter(":nth-child(" + iterator + "n+2)")
.addClass("ui-block-b");
}
if (iterator > 2) {
$kids
.filter(":nth-child(" + iterator + "n+3)")
.addClass("ui-block-c");
}
if (iterator > 3) {
$kids
.filter(":nth-child(" + iterator + "n+4)")
.addClass("ui-block-d");
}
if (iterator > 4) {
$kids
.filter(":nth-child(" + iterator + "n+5)")
.addClass("ui-block-e");
}
});
};
})(jQuery);
(function ($, undefined) {
$.widget("mobile.navbar", {
options: {
iconpos: "top",
grid: null,
},
_create: function () {
var $navbar = this.element,
$navbtns = $navbar.find("a"),
iconpos = $navbtns.filter(":jqmData(icon)").length
? this.options.iconpos
: undefined;
$navbar
.addClass("ui-navbar")
.attr("role", "navigation")
.find("ul")
.jqmEnhanceable()
.grid({ grid: this.options.grid });
$navbtns.each(function () {
var icon = $.mobile.getAttribute(this, "icon"),
theme = $.mobile.getAttribute(this, "theme"),
classes = "ui-btn";
if (theme) {
classes += " ui-btn-" + theme;
}
if (icon) {
classes += " ui-icon-" + icon + " ui-btn-icon-" + iconpos;
}
$(this).addClass(classes);
});
$navbar.delegate("a", "vclick", function (/* event */) {
var activeBtn = $(this);
if (
!(
activeBtn.hasClass("ui-state-disabled") ||
// DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
activeBtn.hasClass("ui-disabled") ||
activeBtn.hasClass($.mobile.activeBtnClass)
)
) {
$navbtns.removeClass($.mobile.activeBtnClass);
activeBtn.addClass($.mobile.activeBtnClass);
// The code below is a workaround to fix #1181
$(document).one("pagehide", function () {
activeBtn.removeClass($.mobile.activeBtnClass);
});
}
});
// Buttons in the navbar with ui-state-persist class should regain their active state before page show
$navbar.closest(".ui-page").bind("pagebeforeshow", function () {
$navbtns
.filter(".ui-state-persist")
.addClass($.mobile.activeBtnClass);
});
},
});
})(jQuery);
(function ($, undefined) {
var getAttr = $.mobile.getAttribute;
$.widget(
"mobile.listview",
$.extend(
{
options: {
theme: null,
countTheme: null /* Deprecated in 1.4 */,
dividerTheme: null,
icon: "carat-r",
splitIcon: "carat-r",
splitTheme: null,
corners: true,
shadow: true,
inset: false,
},
_create: function () {
var t = this,
listviewClasses = "";
listviewClasses += t.options.inset ? " ui-listview-inset" : "";
if (!!t.options.inset) {
listviewClasses += t.options.corners ? " ui-corner-all" : "";
listviewClasses += t.options.shadow ? " ui-shadow" : "";
}
// create listview markup
t.element.addClass(" ui-listview" + listviewClasses);
t.refresh(true);
},
// TODO: Remove in 1.5
_findFirstElementByTagName: function (ele, nextProp, lcName, ucName) {
var dict = {};
dict[lcName] = dict[ucName] = true;
while (ele) {
if (dict[ele.nodeName]) {
return ele;
}
ele = ele[nextProp];
}
return null;
},
// TODO: Remove in 1.5
_addThumbClasses: function (containers) {
var i,
img,
len = containers.length;
for (i = 0; i < len; i++) {
img = $(
this._findFirstElementByTagName(
containers[i].firstChild,
"nextSibling",
"img",
"IMG",
),
);
if (img.length) {
$(
this._findFirstElementByTagName(
img[0].parentNode,
"parentNode",
"li",
"LI",
),
).addClass(
img.hasClass("ui-li-icon")
? "ui-li-has-icon"
: "ui-li-has-thumb",
);
}
}
},
_getChildrenByTagName: function (ele, lcName, ucName) {
var results = [],
dict = {};
dict[lcName] = dict[ucName] = true;
ele = ele.firstChild;
while (ele) {
if (dict[ele.nodeName]) {
results.push(ele);
}
ele = ele.nextSibling;
}
return $(results);
},
_beforeListviewRefresh: $.noop,
_afterListviewRefresh: $.noop,
refresh: function (create) {
var buttonClass,
pos,
numli,
item,
itemClass,
itemTheme,
itemIcon,
icon,
a,
isDivider,
startCount,
newStartCount,
value,
last,
splittheme,
splitThemeClass,
spliticon,
altButtonClass,
dividerTheme,
li,
o = this.options,
$list = this.element,
ol = !!$.nodeName($list[0], "ol"),
start = $list.attr("start"),
itemClassDict = {},
countBubbles = $list.find(".ui-li-count"),
countTheme =
getAttr($list[0], "counttheme") || this.options.countTheme,
countThemeClass = countTheme
? "ui-body-" + countTheme
: "ui-body-inherit";
if (o.theme) {
$list.addClass("ui-group-theme-" + o.theme);
}
// Check if a start attribute has been set while taking a value of 0 into account
if (ol && (start || start === 0)) {
startCount = parseInt(start, 10) - 1;
$list.css("counter-reset", "listnumbering " + startCount);
}
this._beforeListviewRefresh();
li = this._getChildrenByTagName($list[0], "li", "LI");
for (pos = 0, numli = li.length; pos < numli; pos++) {
item = li.eq(pos);
itemClass = "";
if (
create ||
item[0].className.search(/\bui-li-static\b|\bui-li-divider\b/) <
0
) {
a = this._getChildrenByTagName(item[0], "a", "A");
isDivider = getAttr(item[0], "role") === "list-divider";
value = item.attr("value");
itemTheme = getAttr(item[0], "theme");
if (
a.length &&
a[0].className.search(/\bui-btn\b/) < 0 &&
!isDivider
) {
itemIcon = getAttr(item[0], "icon");
icon = itemIcon === false ? false : itemIcon || o.icon;
// TODO: Remove in 1.5 together with links.js (links.js / .ui-link deprecated in 1.4)
a.removeClass("ui-link");
buttonClass = "ui-btn";
if (itemTheme) {
buttonClass += " ui-btn-" + itemTheme;
}
if (a.length > 1) {
itemClass = "ui-li-has-alt";
last = a.last();
splittheme =
getAttr(last[0], "theme") ||
o.splitTheme ||
getAttr(item[0], "theme", true);
splitThemeClass = splittheme ? " ui-btn-" + splittheme : "";
spliticon =
getAttr(last[0], "icon") ||
getAttr(item[0], "icon") ||
o.splitIcon;
altButtonClass =
"ui-btn ui-btn-icon-notext ui-icon-" +
spliticon +
splitThemeClass;
last
.attr("title", $.trim(last.getEncodedText()))
.addClass(altButtonClass)
.empty();
} else if (icon) {
buttonClass += " ui-btn-icon-right ui-icon-" + icon;
}
a.first().addClass(buttonClass);
} else if (isDivider) {
dividerTheme =
getAttr(item[0], "theme") || o.dividerTheme || o.theme;
itemClass =
"ui-li-divider ui-bar-" +
(dividerTheme ? dividerTheme : "inherit");
item.attr("role", "heading");
} else if (a.length <= 0) {
itemClass =
"ui-li-static ui-body-" +
(itemTheme ? itemTheme : "inherit");
}
if (ol && value) {
newStartCount = parseInt(value, 10) - 1;
item.css("counter-reset", "listnumbering " + newStartCount);
}
}
// Instead of setting item class directly on the list item
// at this point in time, push the item into a dictionary
// that tells us what class to set on it so we can do this after this
// processing loop is finished.
if (!itemClassDict[itemClass]) {
itemClassDict[itemClass] = [];
}
itemClassDict[itemClass].push(item[0]);
}
// Set the appropriate listview item classes on each list item.
// The main reason we didn't do this
// in the for-loop above is because we can eliminate per-item function overhead
// by calling addClass() and children() once or twice afterwards. This
// can give us a significant boost on platforms like WP7.5.
for (itemClass in itemClassDict) {
$(itemClassDict[itemClass]).addClass(itemClass);
}
countBubbles.each(function () {
$(this).closest("li").addClass("ui-li-has-count");
});
if (countThemeClass) {
countBubbles.addClass(countThemeClass);
}
// Deprecated in 1.4. From 1.5 you have to add class ui-li-has-thumb or ui-li-has-icon to the LI.
this._addThumbClasses(li);
this._addThumbClasses(li.find(".ui-btn"));
this._afterListviewRefresh();
this._addFirstLastClasses(
li,
this._getVisibles(li, create),
create,
);
},
},
$.mobile.behaviors.addFirstLastClasses,
),
);
})(jQuery);
(function ($, undefined) {
function defaultAutodividersSelector(elt) {
// look for the text in the given element
var text = $.trim(elt.text()) || null;
if (!text) {
return null;
}
// create the text for the divider (first uppercased letter)
text = text.slice(0, 1).toUpperCase();
return text;
}
$.widget("mobile.listview", $.mobile.listview, {
options: {
autodividers: false,
autodividersSelector: defaultAutodividersSelector,
},
_beforeListviewRefresh: function () {
if (this.options.autodividers) {
this._replaceDividers();
this._superApply(arguments);
}
},
_replaceDividers: function () {
var i,
lis,
li,
dividerText,
lastDividerText = null,
list = this.element,
divider;
list.children("li:jqmData(role='list-divider')").remove();
lis = list.children("li");
for (i = 0; i < lis.length; i++) {
li = lis[i];
dividerText = this.options.autodividersSelector($(li));
if (dividerText && lastDividerText !== dividerText) {
divider = document.createElement("li");
divider.appendChild(document.createTextNode(dividerText));
divider.setAttribute(
"data-" + $.mobile.ns + "role",
"list-divider",
);
li.parentNode.insertBefore(divider, li);
}
lastDividerText = dividerText;
}
},
});
})(jQuery);
(function ($, undefined) {
var rdivider = /(^|\s)ui-li-divider($|\s)/,
rhidden = /(^|\s)ui-screen-hidden($|\s)/;
$.widget("mobile.listview", $.mobile.listview, {
options: {
hideDividers: false,
},
_afterListviewRefresh: function () {
var items,
idx,
item,
hideDivider = true;
this._superApply(arguments);
if (this.options.hideDividers) {
items = this._getChildrenByTagName(this.element[0], "li", "LI");
for (idx = items.length - 1; idx > -1; idx--) {
item = items[idx];
if (item.className.match(rdivider)) {
if (hideDivider) {
item.className = item.className + " ui-screen-hidden";
}
hideDivider = true;
} else {
if (!item.className.match(rhidden)) {
hideDivider = false;
}
}
}
}
},
});
})(jQuery);
(function ($, undefined) {
$.mobile.nojs = function (target) {
$(":jqmData(role='nojs')", target).addClass("ui-nojs");
};
})(jQuery);
(function ($, undefined) {
$.mobile.behaviors.formReset = {
_handleFormReset: function () {
this._on(this.element.closest("form"), {
reset: function () {
this._delay("_reset");
},
});
},
};
})(jQuery);
/*
* "checkboxradio" plugin
*/
(function ($, undefined) {
var escapeId = $.mobile.path.hashToSelector;
$.widget(
"mobile.checkboxradio",
$.extend(
{
initSelector:
"input:not( :jqmData(role='flipswitch' ) )[type='checkbox'],input[type='radio']:not( :jqmData(role='flipswitch' ))",
options: {
theme: "inherit",
mini: false,
wrapperClass: null,
enhanced: false,
iconpos: "left",
},
_create: function () {
var input = this.element,
o = this.options,
inheritAttr = function (input, dataAttr) {
return (
input.jqmData(dataAttr) ||
input.closest("form, fieldset").jqmData(dataAttr)
);
},
// NOTE: Windows Phone could not find the label through a selector
// filter works though.
parentLabel = input.closest("label"),
label = parentLabel.length
? parentLabel
: input
.closest(
"form, fieldset, :jqmData(role='page'), :jqmData(role='dialog')",
)
.find("label")
.filter("[for='" + escapeId(input[0].id) + "']")
.first(),
inputtype = input[0].type,
checkedClass = "ui-" + inputtype + "-on",
uncheckedClass = "ui-" + inputtype + "-off";
if (inputtype !== "checkbox" && inputtype !== "radio") {
return;
}
if (this.element[0].disabled) {
this.options.disabled = true;
}
(o.iconpos =
inheritAttr(input, "iconpos") ||
label.attr("data-" + $.mobile.ns + "iconpos") ||
o.iconpos),
// Establish options
(o.mini = inheritAttr(input, "mini") || o.mini);
// Expose for other methods
$.extend(this, {
input: input,
label: label,
parentLabel: parentLabel,
inputtype: inputtype,
checkedClass: checkedClass,
uncheckedClass: uncheckedClass,
});
if (!this.options.enhanced) {
this._enhance();
}
this._on(label, {
vmouseover: "_handleLabelVMouseOver",
vclick: "_handleLabelVClick",
});
this._on(input, {
vmousedown: "_cacheVals",
vclick: "_handleInputVClick",
focus: "_handleInputFocus",
blur: "_handleInputBlur",
});
this._handleFormReset();
this.refresh();
},
_enhance: function () {
this.label.addClass("ui-btn ui-corner-all");
if (this.parentLabel.length > 0) {
this.input.add(this.label).wrapAll(this._wrapper());
} else {
//this.element.replaceWith( this.input.add( this.label ).wrapAll( this._wrapper() ) );
this.element.wrap(this._wrapper());
this.element.parent().prepend(this.label);
}
// Wrap the input + label in a div
this._setOptions({
theme: this.options.theme,
iconpos: this.options.iconpos,
mini: this.options.mini,
});
},
_wrapper: function () {
return $(
"<div class='" +
(this.options.wrapperClass ? this.options.wrapperClass : "") +
" ui-" +
this.inputtype +
(this.options.disabled ? " ui-state-disabled" : "") +
"' ></div>",
);
},
_handleInputFocus: function () {
this.label.addClass($.mobile.focusClass);
},
_handleInputBlur: function () {
this.label.removeClass($.mobile.focusClass);
},
_handleInputVClick: function () {
// Adds checked attribute to checked input when keyboard is used
this.element.prop("checked", this.element.is(":checked"));
this._getInputSet().not(this.element).prop("checked", false);
this._updateAll();
},
_handleLabelVMouseOver: function (event) {
if (this.label.parent().hasClass("ui-state-disabled")) {
event.stopPropagation();
}
},
_handleLabelVClick: function (event) {
var input = this.element;
if (input.is(":disabled")) {
event.preventDefault();
return;
}
this._cacheVals();
input.prop(
"checked",
(this.inputtype === "radio" && true) || !input.prop("checked"),
);
// trigger click handler's bound directly to the input as a substitute for
// how label clicks behave normally in the browsers
// TODO: it would be nice to let the browser's handle the clicks and pass them
// through to the associate input. we can swallow that click at the parent
// wrapper element level
input.triggerHandler("click");
// Input set for common radio buttons will contain all the radio
// buttons, but will not for checkboxes. clearing the checked status
// of other radios ensures the active button state is applied properly
this._getInputSet().not(input).prop("checked", false);
this._updateAll();
return false;
},
_cacheVals: function () {
this._getInputSet().each(function () {
$(this).attr("data-" + $.mobile.ns + "cacheVal", this.checked);
});
},
// Returns those radio buttons that are supposed to be in the same group as
// this radio button. In the case of a checkbox or a radio lacking a name
// attribute, it returns this.element.
_getInputSet: function () {
var selector,
formId,
radio = this.element[0],
name = radio.name,
form = radio.form,
doc = this.element.parents().last().get(0),
// A radio is always a member of its own group
radios = this.element;
// Only start running selectors if this is an attached radio button with a name
if (name && this.inputtype === "radio" && doc) {
selector = "input[type='radio'][name='" + escapeId(name) + "']";
// If we're inside a form
if (form) {
formId = form.id;
// If the form has an ID, collect radios scattered throught the document which
// nevertheless are part of the form by way of the value of their form attribute
if (formId) {
radios = $(
selector + "[form='" + escapeId(formId) + "']",
doc,
);
}
// Also add to those the radios in the form itself
radios = $(form)
.find(selector)
.filter(function () {
// Some radios inside the form may belong to some other form by virtue of
// having a form attribute defined on them, so we must filter them out here
return this.form === form;
})
.add(radios);
// If we're outside a form
} else {
// Collect all those radios which are also outside of a form and match our name
radios = $(selector, doc).filter(function () {
return !this.form;
});
}
}
return radios;
},
_updateAll: function () {
var self = this;
this._getInputSet()
.each(function () {
var $this = $(this);
if (this.checked || self.inputtype === "checkbox") {
$this.trigger("change");
}
})
.checkboxradio("refresh");
},
_reset: function () {
this.refresh();
},
// Is the widget supposed to display an icon?
_hasIcon: function () {
var controlgroup,
controlgroupWidget,
controlgroupConstructor = $.mobile.controlgroup;
// If the controlgroup widget is defined ...
if (controlgroupConstructor) {
controlgroup = this.element.closest(
":mobile-controlgroup," +
controlgroupConstructor.prototype.initSelector,
);
// ... and the checkbox is in a controlgroup ...
if (controlgroup.length > 0) {
// ... look for a controlgroup widget instance, and ...
controlgroupWidget = $.data(
controlgroup[0],
"mobile-controlgroup",
);
// ... if found, decide based on the option value, ...
return (
(controlgroupWidget
? controlgroupWidget.options.type
: // ... otherwise decide based on the "type" data attribute.
controlgroup.attr("data-" + $.mobile.ns + "type")) !==
"horizontal"
);
}
}
// Normally, the widget displays an icon.
return true;
},
refresh: function () {
var hasIcon = this._hasIcon(),
isChecked = this.element[0].checked,
active = $.mobile.activeBtnClass,
iconposClass = "ui-btn-icon-" + this.options.iconpos,
addClasses = [],
removeClasses = [];
if (hasIcon) {
removeClasses.push(active);
addClasses.push(iconposClass);
} else {
removeClasses.push(iconposClass);
(isChecked ? addClasses : removeClasses).push(active);
}
if (isChecked) {
addClasses.push(this.checkedClass);
removeClasses.push(this.uncheckedClass);
} else {
addClasses.push(this.uncheckedClass);
removeClasses.push(this.checkedClass);
}
this.label
.addClass(addClasses.join(" "))
.removeClass(removeClasses.join(" "));
},
widget: function () {
return this.label.parent();
},
_setOptions: function (options) {
var label = this.label,
currentOptions = this.options,
outer = this.widget(),
hasIcon = this._hasIcon();
if (options.disabled !== undefined) {
this.input.prop("disabled", !!options.disabled);
outer.toggleClass("ui-state-disabled", !!options.disabled);
}
if (options.mini !== undefined) {
outer.toggleClass("ui-mini", !!options.mini);
}
if (options.theme !== undefined) {
label
.removeClass("ui-btn-" + currentOptions.theme)
.addClass("ui-btn-" + options.theme);
}
if (options.wrapperClass !== undefined) {
outer
.removeClass(currentOptions.wrapperClass)
.addClass(options.wrapperClass);
}
if (options.iconpos !== undefined && hasIcon) {
label
.removeClass("ui-btn-icon-" + currentOptions.iconpos)
.addClass("ui-btn-icon-" + options.iconpos);
} else if (!hasIcon) {
label.removeClass("ui-btn-icon-" + currentOptions.iconpos);
}
this._super(options);
},
},
$.mobile.behaviors.formReset,
),
);
})(jQuery);
(function ($, undefined) {
$.widget("mobile.button", {
initSelector:
"input[type='button'], input[type='submit'], input[type='reset']",
options: {
theme: null,
icon: null,
iconpos: "left",
iconshadow: false /* TODO: Deprecated in 1.4, remove in 1.5. */,
corners: true,
shadow: true,
inline: null,
mini: null,
wrapperClass: null,
enhanced: false,
},
_create: function () {
if (this.element.is(":disabled")) {
this.options.disabled = true;
}
if (!this.options.enhanced) {
this._enhance();
}
$.extend(this, {
wrapper: this.element.parent(),
});
this._on({
focus: function () {
this.widget().addClass($.mobile.focusClass);
},
blur: function () {
this.widget().removeClass($.mobile.focusClass);
},
});
this.refresh(true);
},
_enhance: function () {
this.element.wrap(this._button());
},
_button: function () {
var options = this.options,
iconClasses = this._getIconClasses(this.options);
return $(
"<div class='ui-btn ui-input-btn" +
(options.wrapperClass ? " " + options.wrapperClass : "") +
(options.theme ? " ui-btn-" + options.theme : "") +
(options.corners ? " ui-corner-all" : "") +
(options.shadow ? " ui-shadow" : "") +
(options.inline ? " ui-btn-inline" : "") +
(options.mini ? " ui-mini" : "") +
(options.disabled ? " ui-state-disabled" : "") +
(iconClasses ? " " + iconClasses : "") +
"' >" +
this.element.val() +
"</div>",
);
},
widget: function () {
return this.wrapper;
},
_destroy: function () {
this.element.insertBefore(this.button);
this.button.remove();
},
_getIconClasses: function (options) {
return options.icon
? "ui-icon-" +
options.icon +
(options.iconshadow
? " ui-shadow-icon"
: "") /* TODO: Deprecated in 1.4, remove in 1.5. */ +
" ui-btn-icon-" +
options.iconpos
: "";
},
_setOptions: function (options) {
var outer = this.widget();
if (options.theme !== undefined) {
outer
.removeClass(this.options.theme)
.addClass("ui-btn-" + options.theme);
}
if (options.corners !== undefined) {
outer.toggleClass("ui-corner-all", options.corners);
}
if (options.shadow !== undefined) {
outer.toggleClass("ui-shadow", options.shadow);
}
if (options.inline !== undefined) {
outer.toggleClass("ui-btn-inline", options.inline);
}
if (options.mini !== undefined) {
outer.toggleClass("ui-mini", options.mini);
}
if (options.disabled !== undefined) {
this.element.prop("disabled", options.disabled);
outer.toggleClass("ui-state-disabled", options.disabled);
}
if (
options.icon !== undefined ||
options.iconshadow !==
undefined /* TODO: Deprecated in 1.4, remove in 1.5. */ ||
options.iconpos !== undefined
) {
outer
.removeClass(this._getIconClasses(this.options))
.addClass(
this._getIconClasses($.extend({}, this.options, options)),
);
}
this._super(options);
},
refresh: function (create) {
var originalElement,
isDisabled = this.element.prop("disabled");
if (
this.options.icon &&
this.options.iconpos === "notext" &&
this.element.attr("title")
) {
this.element.attr("title", this.element.val());
}
if (!create) {
originalElement = this.element.detach();
$(this.wrapper).text(this.element.val()).append(originalElement);
}
if (this.options.disabled !== isDisabled) {
this._setOptions({ disabled: isDisabled });
}
},
});
})(jQuery);
(function ($) {
var meta = $("meta[name=viewport]"),
initialContent = meta.attr("content"),
disabledZoom = initialContent + ",maximum-scale=1, user-scalable=no",
enabledZoom = initialContent + ",maximum-scale=10, user-scalable=yes",
disabledInitially =
/(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test(
initialContent,
);
$.mobile.zoom = $.extend(
{},
{
enabled: !disabledInitially,
locked: false,
disable: function (lock) {
if (!disabledInitially && !$.mobile.zoom.locked) {
meta.attr("content", disabledZoom);
$.mobile.zoom.enabled = false;
$.mobile.zoom.locked = lock || false;
}
},
enable: function (unlock) {
if (
!disabledInitially &&
(!$.mobile.zoom.locked || unlock === true)
) {
meta.attr("content", enabledZoom);
$.mobile.zoom.enabled = true;
$.mobile.zoom.locked = false;
}
},
restore: function () {
if (!disabledInitially) {
meta.attr("content", initialContent);
$.mobile.zoom.enabled = true;
}
},
},
);
})(jQuery);
(function ($, undefined) {
$.widget("mobile.textinput", {
initSelector:
"input[type='text']," +
"input[type='search']," +
":jqmData(type='search')," +
"input[type='number']," +
":jqmData(type='number')," +
"input[type='password']," +
"input[type='email']," +
"input[type='url']," +
"input[type='tel']," +
"textarea," +
"input[type='time']," +
"input[type='date']," +
"input[type='month']," +
"input[type='week']," +
"input[type='datetime']," +
"input[type='datetime-local']," +
"input[type='color']," +
"input:not([type])," +
"input[type='file']",
options: {
theme: null,
corners: true,
mini: false,
// This option defaults to true on iOS devices.
preventFocusZoom:
/iPhone|iPad|iPod/.test(navigator.platform) &&
navigator.userAgent.indexOf("AppleWebKit") > -1,
wrapperClass: "",
enhanced: false,
},
_create: function () {
var options = this.options,
isSearch = this.element.is(
"[type='search'], :jqmData(type='search')",
),
isTextarea = this.element[0].tagName === "TEXTAREA",
isRange = this.element.is(
"[data-" + ($.mobile.ns || "") + "type='range']",
),
inputNeedsWrap =
(this.element.is("input") ||
this.element.is(
"[data-" + ($.mobile.ns || "") + "type='search']",
)) &&
!isRange;
if (this.element.prop("disabled")) {
options.disabled = true;
}
$.extend(this, {
classes: this._classesFromOptions(),
isSearch: isSearch,
isTextarea: isTextarea,
isRange: isRange,
inputNeedsWrap: inputNeedsWrap,
});
this._autoCorrect();
if (!options.enhanced) {
this._enhance();
}
this._on({
focus: "_handleFocus",
blur: "_handleBlur",
});
},
refresh: function () {
this.setOptions({
disabled: this.element.is(":disabled"),
});
},
_enhance: function () {
var elementClasses = [];
if (this.isTextarea) {
elementClasses.push("ui-input-text");
}
if (this.isTextarea || this.isRange) {
elementClasses.push("ui-shadow-inset");
}
//"search" and "text" input widgets
if (this.inputNeedsWrap) {
this.element.wrap(this._wrap());
} else {
elementClasses = elementClasses.concat(this.classes);
}
this.element.addClass(elementClasses.join(" "));
},
widget: function () {
return this.inputNeedsWrap ? this.element.parent() : this.element;
},
_classesFromOptions: function () {
var options = this.options,
classes = [];
classes.push(
"ui-body-" + (options.theme === null ? "inherit" : options.theme),
);
if (options.corners) {
classes.push("ui-corner-all");
}
if (options.mini) {
classes.push("ui-mini");
}
if (options.disabled) {
classes.push("ui-state-disabled");
}
if (options.wrapperClass) {
classes.push(options.wrapperClass);
}
return classes;
},
_wrap: function () {
return $(
"<div class='" +
(this.isSearch ? "ui-input-search " : "ui-input-text ") +
this.classes.join(" ") +
" " +
"ui-shadow-inset'></div>",
);
},
_autoCorrect: function () {
// XXX: Temporary workaround for issue 785 (Apple bug 8910589).
// Turn off autocorrect and autocomplete on non-iOS 5 devices
// since the popup they use can't be dismissed by the user. Note
// that we test for the presence of the feature by looking for
// the autocorrect property on the input element. We currently
// have no test for iOS 5 or newer so we're temporarily using
// the touchOverflow support flag for jQM 1.0. Yes, I feel dirty.
// - jblas
if (
typeof this.element[0].autocorrect !== "undefined" &&
!$.support.touchOverflow
) {
// Set the attribute instead of the property just in case there
// is code that attempts to make modifications via HTML.
this.element[0].setAttribute("autocorrect", "off");
this.element[0].setAttribute("autocomplete", "off");
}
},
_handleBlur: function () {
this.widget().removeClass($.mobile.focusClass);
if (this.options.preventFocusZoom) {
$.mobile.zoom.enable(true);
}
},
_handleFocus: function () {
// In many situations, iOS will zoom into the input upon tap, this
// prevents that from happening
if (this.options.preventFocusZoom) {
$.mobile.zoom.disable(true);
}
this.widget().addClass($.mobile.focusClass);
},
_setOptions: function (options) {
var outer = this.widget();
this._super(options);
if (
!(
options.disabled === undefined &&
options.mini === undefined &&
options.corners === undefined &&
options.theme === undefined &&
options.wrapperClass === undefined
)
) {
outer.removeClass(this.classes.join(" "));
this.classes = this._classesFromOptions();
outer.addClass(this.classes.join(" "));
}
if (options.disabled !== undefined) {
this.element.prop("disabled", !!options.disabled);
}
},
_destroy: function () {
if (this.options.enhanced) {
return;
}
if (this.inputNeedsWrap) {
this.element.unwrap();
}
this.element.removeClass("ui-input-text " + this.classes.join(" "));
},
});
})(jQuery);
(function ($, undefined) {
$.widget(
"mobile.slider",
$.extend(
{
initSelector:
"input[type='range'], :jqmData(type='range'), :jqmData(role='slider')",
widgetEventPrefix: "slide",
options: {
theme: null,
trackTheme: null,
corners: true,
mini: false,
highlight: false,
},
_create: function () {
// TODO: Each of these should have comments explain what they're for
var self = this,
control = this.element,
trackTheme =
this.options.trackTheme ||
$.mobile.getAttribute(control[0], "theme"),
trackThemeClass = trackTheme
? " ui-bar-" + trackTheme
: " ui-bar-inherit",
cornerClass =
this.options.corners || control.jqmData("corners")
? " ui-corner-all"
: "",
miniClass =
this.options.mini || control.jqmData("mini") ? " ui-mini" : "",
cType = control[0].nodeName.toLowerCase(),
isToggleSwitch = cType === "select",
isRangeslider = control
.parent()
.is(":jqmData(role='rangeslider')"),
selectClass = isToggleSwitch ? "ui-slider-switch" : "",
controlID = control.attr("id"),
$label = $("[for='" + controlID + "']"),
labelID = $label.attr("id") || controlID + "-label",
min = !isToggleSwitch ? parseFloat(control.attr("min")) : 0,
max = !isToggleSwitch
? parseFloat(control.attr("max"))
: control.find("option").length - 1,
step = window.parseFloat(control.attr("step") || 1),
domHandle = document.createElement("a"),
handle = $(domHandle),
domSlider = document.createElement("div"),
slider = $(domSlider),
valuebg =
this.options.highlight && !isToggleSwitch
? (function () {
var bg = document.createElement("div");
bg.className = "ui-slider-bg " + $.mobile.activeBtnClass;
return $(bg).prependTo(slider);
})()
: false,
options,
wrapper,
j,
length,
i,
optionsCount,
origTabIndex,
side,
activeClass,
sliderImg;
$label.attr("id", labelID);
this.isToggleSwitch = isToggleSwitch;
domHandle.setAttribute("href", "#");
domSlider.setAttribute("role", "application");
domSlider.className = [
this.isToggleSwitch
? "ui-slider ui-slider-track ui-shadow-inset "
: "ui-slider-track ui-shadow-inset ",
selectClass,
trackThemeClass,
cornerClass,
miniClass,
].join("");
domHandle.className = "ui-slider-handle";
domSlider.appendChild(domHandle);
handle.attr({
role: "slider",
"aria-valuemin": min,
"aria-valuemax": max,
"aria-valuenow": this._value(),
"aria-valuetext": this._value(),
title: this._value(),
"aria-labelledby": labelID,
});
$.extend(this, {
slider: slider,
handle: handle,
control: control,
type: cType,
step: step,
max: max,
min: min,
valuebg: valuebg,
isRangeslider: isRangeslider,
dragging: false,
beforeStart: null,
userModified: false,
mouseMoved: false,
});
if (isToggleSwitch) {
// TODO: restore original tabindex (if any) in a destroy method
origTabIndex = control.attr("tabindex");
if (origTabIndex) {
handle.attr("tabindex", origTabIndex);
}
control.attr("tabindex", "-1").focus(function () {
$(this).blur();
handle.focus();
});
wrapper = document.createElement("div");
wrapper.className = "ui-slider-inneroffset";
for (
j = 0, length = domSlider.childNodes.length;
j < length;
j++
) {
wrapper.appendChild(domSlider.childNodes[j]);
}
domSlider.appendChild(wrapper);
// slider.wrapInner( "<div class='ui-slider-inneroffset'></div>" );
// make the handle move with a smooth transition
handle.addClass("ui-slider-handle-snapping");
options = control.find("option");
for (
i = 0, optionsCount = options.length;
i < optionsCount;
i++
) {
side = !i ? "b" : "a";
activeClass = !i ? "" : " " + $.mobile.activeBtnClass;
sliderImg = document.createElement("span");
sliderImg.className = [
"ui-slider-label ui-slider-label-",
side,
activeClass,
].join("");
sliderImg.setAttribute("role", "img");
sliderImg.appendChild(
document.createTextNode(options[i].innerHTML),
);
$(sliderImg).prependTo(slider);
}
self._labels = $(".ui-slider-label", slider);
}
// monitor the input for updated values
control.addClass(
isToggleSwitch ? "ui-slider-switch" : "ui-slider-input",
);
this._on(control, {
change: "_controlChange",
keyup: "_controlKeyup",
blur: "_controlBlur",
vmouseup: "_controlVMouseUp",
});
slider
.bind("vmousedown", $.proxy(this._sliderVMouseDown, this))
.bind("vclick", false);
// We have to instantiate a new function object for the unbind to work properly
// since the method itself is defined in the prototype (causing it to unbind everything)
this._on(document, { vmousemove: "_preventDocumentDrag" });
this._on(slider.add(document), { vmouseup: "_sliderVMouseUp" });
slider.insertAfter(control);
// wrap in a div for styling purposes
if (!isToggleSwitch && !isRangeslider) {
wrapper = this.options.mini
? "<div class='ui-slider ui-mini'>"
: "<div class='ui-slider'>";
control.add(slider).wrapAll(wrapper);
}
// bind the handle event callbacks and set the context to the widget instance
this._on(this.handle, {
vmousedown: "_handleVMouseDown",
keydown: "_handleKeydown",
keyup: "_handleKeyup",
});
this.handle.bind("vclick", false);
this._handleFormReset();
this.refresh(undefined, undefined, true);
},
_setOptions: function (options) {
if (options.theme !== undefined) {
this._setTheme(options.theme);
}
if (options.trackTheme !== undefined) {
this._setTrackTheme(options.trackTheme);
}
if (options.corners !== undefined) {
this._setCorners(options.corners);
}
if (options.mini !== undefined) {
this._setMini(options.mini);
}
if (options.highlight !== undefined) {
this._setHighlight(options.highlight);
}
if (options.disabled !== undefined) {
this._setDisabled(options.disabled);
}
this._super(options);
},
_controlChange: function (event) {
// if the user dragged the handle, the "change" event was triggered from inside refresh(); don't call refresh() again
if (this._trigger("controlchange", event) === false) {
return false;
}
if (!this.mouseMoved) {
this.refresh(this._value(), true);
}
},
_controlKeyup: function (/* event */) {
// necessary?
this.refresh(this._value(), true, true);
},
_controlBlur: function (/* event */) {
this.refresh(this._value(), true);
},
// it appears the clicking the up and down buttons in chrome on
// range/number inputs doesn't trigger a change until the field is
// blurred. Here we check thif the value has changed and refresh
_controlVMouseUp: function (/* event */) {
this._checkedRefresh();
},
// NOTE force focus on handle
_handleVMouseDown: function (/* event */) {
this.handle.focus();
},
_handleKeydown: function (event) {
var index = this._value();
if (this.options.disabled) {
return;
}
// In all cases prevent the default and mark the handle as active
switch (event.keyCode) {
case $.mobile.keyCode.HOME:
case $.mobile.keyCode.END:
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
event.preventDefault();
if (!this._keySliding) {
this._keySliding = true;
this.handle.addClass(
"ui-state-active",
); /* TODO: We don't use this class for styling. Do we need to add it? */
}
break;
}
// move the slider according to the keypress
switch (event.keyCode) {
case $.mobile.keyCode.HOME:
this.refresh(this.min);
break;
case $.mobile.keyCode.END:
this.refresh(this.max);
break;
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
this.refresh(index + this.step);
break;
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
this.refresh(index - this.step);
break;
}
}, // remove active mark
_handleKeyup: function (/* event */) {
if (this._keySliding) {
this._keySliding = false;
this.handle.removeClass(
"ui-state-active",
); /* See comment above. */
}
},
_sliderVMouseDown: function (event) {
// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
if (
this.options.disabled ||
!(
event.which === 1 ||
event.which === 0 ||
event.which === undefined
)
) {
return false;
}
if (this._trigger("beforestart", event) === false) {
return false;
}
this.dragging = true;
this.userModified = false;
this.mouseMoved = false;
if (this.isToggleSwitch) {
this.beforeStart = this.element[0].selectedIndex;
}
this.refresh(event);
this._trigger("start");
return false;
},
_sliderVMouseUp: function () {
if (this.dragging) {
this.dragging = false;
if (this.isToggleSwitch) {
// make the handle move with a smooth transition
this.handle.addClass("ui-slider-handle-snapping");
if (this.mouseMoved) {
// this is a drag, change the value only if user dragged enough
if (this.userModified) {
this.refresh(this.beforeStart === 0 ? 1 : 0);
} else {
this.refresh(this.beforeStart);
}
} else {
// this is just a click, change the value
this.refresh(this.beforeStart === 0 ? 1 : 0);
}
}
this.mouseMoved = false;
this._trigger("stop");
return false;
}
},
_preventDocumentDrag: function (event) {
// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
if (this._trigger("drag", event) === false) {
return false;
}
if (this.dragging && !this.options.disabled) {
// this.mouseMoved must be updated before refresh() because it will be used in the control "change" event
this.mouseMoved = true;
if (this.isToggleSwitch) {
// make the handle move in sync with the mouse
this.handle.removeClass("ui-slider-handle-snapping");
}
this.refresh(event);
// only after refresh() you can calculate this.userModified
this.userModified =
this.beforeStart !== this.element[0].selectedIndex;
return false;
}
},
_checkedRefresh: function () {
if (this.value !== this._value()) {
this.refresh(this._value());
}
},
_value: function () {
return this.isToggleSwitch
? this.element[0].selectedIndex
: parseFloat(this.element.val());
},
_reset: function () {
this.refresh(undefined, false, true);
},
refresh: function (val, isfromControl, preventInputUpdate) {
// NOTE: we don't return here because we want to support programmatic
// alteration of the input value, which should still update the slider
var self = this,
parentTheme = $.mobile.getAttribute(this.element[0], "theme"),
theme = this.options.theme || parentTheme,
themeClass = theme ? " ui-btn-" + theme : "",
trackTheme = this.options.trackTheme || parentTheme,
trackThemeClass = trackTheme
? " ui-bar-" + trackTheme
: " ui-bar-inherit",
cornerClass = this.options.corners ? " ui-corner-all" : "",
miniClass = this.options.mini ? " ui-mini" : "",
left,
width,
data,
tol,
pxStep,
percent,
control,
isInput,
optionElements,
min,
max,
step,
newval,
valModStep,
alignValue,
percentPerStep,
handlePercent,
aPercent,
bPercent,
valueChanged;
self.slider[0].className = [
this.isToggleSwitch
? "ui-slider ui-slider-switch ui-slider-track ui-shadow-inset"
: "ui-slider-track ui-shadow-inset",
trackThemeClass,
cornerClass,
miniClass,
].join("");
if (this.options.disabled || this.element.prop("disabled")) {
this.disable();
}
// set the stored value for comparison later
this.value = this._value();
if (
this.options.highlight &&
!this.isToggleSwitch &&
this.slider.find(".ui-slider-bg").length === 0
) {
this.valuebg = (function () {
var bg = document.createElement("div");
bg.className = "ui-slider-bg " + $.mobile.activeBtnClass;
return $(bg).prependTo(self.slider);
})();
}
this.handle.addClass("ui-btn" + themeClass + " ui-shadow");
control = this.element;
isInput = !this.isToggleSwitch;
optionElements = isInput ? [] : control.find("option");
min = isInput ? parseFloat(control.attr("min")) : 0;
max = isInput
? parseFloat(control.attr("max"))
: optionElements.length - 1;
step =
isInput && parseFloat(control.attr("step")) > 0
? parseFloat(control.attr("step"))
: 1;
if (typeof val === "object") {
data = val;
// a slight tolerance helped get to the ends of the slider
tol = 8;
left = this.slider.offset().left;
width = this.slider.width();
pxStep = width / ((max - min) / step);
if (
!this.dragging ||
data.pageX < left - tol ||
data.pageX > left + width + tol
) {
return;
}
if (pxStep > 1) {
percent = ((data.pageX - left) / width) * 100;
} else {
percent = Math.round(((data.pageX - left) / width) * 100);
}
} else {
if (val == null) {
val = isInput
? parseFloat(control.val() || 0)
: control[0].selectedIndex;
}
percent = ((parseFloat(val) - min) / (max - min)) * 100;
}
if (isNaN(percent)) {
return;
}
newval = (percent / 100) * (max - min) + min;
//from jQuery UI slider, the following source will round to the nearest step
valModStep = (newval - min) % step;
alignValue = newval - valModStep;
if (Math.abs(valModStep) * 2 >= step) {
alignValue += valModStep > 0 ? step : -step;
}
percentPerStep = 100 / ((max - min) / step);
// Since JavaScript has problems with large floats, round
// the final value to 5 digits after the decimal point (see jQueryUI: #4124)
newval = parseFloat(alignValue.toFixed(5));
if (typeof pxStep === "undefined") {
pxStep = width / ((max - min) / step);
}
if (pxStep > 1 && isInput) {
percent = (newval - min) * percentPerStep * (1 / step);
}
if (percent < 0) {
percent = 0;
}
if (percent > 100) {
percent = 100;
}
if (newval < min) {
newval = min;
}
if (newval > max) {
newval = max;
}
this.handle.css("left", percent + "%");
this.handle[0].setAttribute(
"aria-valuenow",
isInput ? newval : optionElements.eq(newval).attr("value"),
);
this.handle[0].setAttribute(
"aria-valuetext",
isInput ? newval : optionElements.eq(newval).getEncodedText(),
);
this.handle[0].setAttribute(
"title",
isInput ? newval : optionElements.eq(newval).getEncodedText(),
);
if (this.valuebg) {
this.valuebg.css("width", percent + "%");
}
// drag the label widths
if (this._labels) {
handlePercent = (this.handle.width() / this.slider.width()) * 100;
aPercent =
percent &&
handlePercent + ((100 - handlePercent) * percent) / 100;
bPercent =
percent === 100
? 0
: Math.min(handlePercent + 100 - aPercent, 100);
this._labels.each(function () {
var ab = $(this).hasClass("ui-slider-label-a");
$(this).width((ab ? aPercent : bPercent) + "%");
});
}
if (!preventInputUpdate) {
valueChanged = false;
// update control"s value
if (isInput) {
valueChanged = control.val() !== newval;
control.val(newval);
} else {
valueChanged = control[0].selectedIndex !== newval;
control[0].selectedIndex = newval;
}
if (this._trigger("beforechange", val) === false) {
return false;
}
if (!isfromControl && valueChanged) {
control.trigger("change");
}
}
},
_setHighlight: function (value) {
value = !!value;
if (value) {
this.options.highlight = !!value;
this.refresh();
} else if (this.valuebg) {
this.valuebg.remove();
this.valuebg = false;
}
},
_setTheme: function (value) {
this.handle
.removeClass("ui-btn-" + this.options.theme)
.addClass("ui-btn-" + value);
var currentTheme = this.options.theme
? this.options.theme
: "inherit",
newTheme = value ? value : "inherit";
this.control
.removeClass("ui-body-" + currentTheme)
.addClass("ui-body-" + newTheme);
},
_setTrackTheme: function (value) {
var currentTrackTheme = this.options.trackTheme
? this.options.trackTheme
: "inherit",
newTrackTheme = value ? value : "inherit";
this.slider
.removeClass("ui-body-" + currentTrackTheme)
.addClass("ui-body-" + newTrackTheme);
},
_setMini: function (value) {
value = !!value;
if (!this.isToggleSwitch && !this.isRangeslider) {
this.slider.parent().toggleClass("ui-mini", value);
this.element.toggleClass("ui-mini", value);
}
this.slider.toggleClass("ui-mini", value);
},
_setCorners: function (value) {
this.slider.toggleClass("ui-corner-all", value);
if (!this.isToggleSwitch) {
this.control.toggleClass("ui-corner-all", value);
}
},
_setDisabled: function (value) {
value = !!value;
this.element.prop("disabled", value);
this.slider
.toggleClass("ui-state-disabled", value)
.attr("aria-disabled", value);
},
},
$.mobile.behaviors.formReset,
),
);
})(jQuery);
(function ($, undefined) {
var popup;
function getPopup() {
if (!popup) {
popup = $("<div></div>", {
class: "ui-slider-popup ui-shadow ui-corner-all",
});
}
return popup.clone();
}
$.widget("mobile.slider", $.mobile.slider, {
options: {
popupEnabled: false,
showValue: false,
},
_create: function () {
this._super();
$.extend(this, {
_currentValue: null,
_popup: null,
_popupVisible: false,
});
this._setOption("popupEnabled", this.options.popupEnabled);
this._on(this.handle, { vmousedown: "_showPopup" });
this._on(this.slider.add(this.document), { vmouseup: "_hidePopup" });
this._refresh();
},
// position the popup centered 5px above the handle
_positionPopup: function () {
var dstOffset = this.handle.offset();
this._popup.offset({
left:
dstOffset.left + (this.handle.width() - this._popup.width()) / 2,
top: dstOffset.top - this._popup.outerHeight() - 5,
});
},
_setOption: function (key, value) {
this._super(key, value);
if (key === "showValue") {
this.handle.html(value && !this.options.mini ? this._value() : "");
} else if (key === "popupEnabled") {
if (value && !this._popup) {
this._popup = getPopup()
.addClass("ui-body-" + (this.options.theme || "a"))
.hide()
.insertBefore(this.element);
}
}
},
// show value on the handle and in popup
refresh: function () {
this._super.apply(this, arguments);
this._refresh();
},
_refresh: function () {
var o = this.options,
newValue;
if (o.popupEnabled) {
// remove the title attribute from the handle (which is
// responsible for the annoying tooltip); NB we have
// to do it here as the jqm slider sets it every time
// the slider's value changes :(
this.handle.removeAttr("title");
}
newValue = this._value();
if (newValue === this._currentValue) {
return;
}
this._currentValue = newValue;
if (o.popupEnabled && this._popup) {
this._positionPopup();
this._popup.html(newValue);
} else if (o.showValue && !this.options.mini) {
this.handle.html(newValue);
}
},
_showPopup: function () {
if (this.options.popupEnabled && !this._popupVisible) {
this.handle.html("");
this._popup.show();
this._positionPopup();
this._popupVisible = true;
}
},
_hidePopup: function () {
var o = this.options;
if (o.popupEnabled && this._popupVisible) {
if (o.showValue && !o.mini) {
this.handle.html(this._value());
}
this._popup.hide();
this._popupVisible = false;
}
},
});
})(jQuery);
(function ($, undefined) {
$.widget(
"mobile.flipswitch",
$.extend(
{
options: {
onText: "On",
offText: "Off",
theme: null,
enhanced: false,
wrapperClass: null,
corners: true,
mini: false,
},
_create: function () {
if (!this.options.enhanced) {
this._enhance();
} else {
$.extend(this, {
flipswitch: this.element.parent(),
on: this.element.find(".ui-flipswitch-on").eq(0),
off: this.element.find(".ui-flipswitch-off").eq(0),
type: this.element.get(0).tagName,
});
}
this._handleFormReset();
// Transfer tabindex to "on" element and make input unfocusable
this._originalTabIndex = this.element.attr("tabindex");
if (this._originalTabIndex != null) {
this.on.attr("tabindex", this._originalTabIndex);
}
this.element.attr("tabindex", "-1");
this._on({
focus: "_handleInputFocus",
});
if (this.element.is(":disabled")) {
this._setOptions({
disabled: true,
});
}
this._on(this.flipswitch, {
click: "_toggle",
swipeleft: "_left",
swiperight: "_right",
});
this._on(this.on, {
keydown: "_keydown",
});
this._on({
change: "refresh",
});
},
_handleInputFocus: function () {
this.on.focus();
},
widget: function () {
return this.flipswitch;
},
_left: function () {
this.flipswitch.removeClass("ui-flipswitch-active");
if (this.type === "SELECT") {
this.element.get(0).selectedIndex = 0;
} else {
this.element.prop("checked", false);
}
this.element.trigger("change");
},
_right: function () {
this.flipswitch.addClass("ui-flipswitch-active");
if (this.type === "SELECT") {
this.element.get(0).selectedIndex = 1;
} else {
this.element.prop("checked", true);
}
this.element.trigger("change");
},
_enhance: function () {
var flipswitch = $("<div>"),
options = this.options,
element = this.element,
theme = options.theme ? options.theme : "inherit",
// The "on" button is an anchor so it's focusable
on = $("<a></a>", {
href: "#",
}),
off = $("<span></span>"),
type = element.get(0).tagName,
onText =
type === "INPUT"
? options.onText
: element.find("option").eq(1).text(),
offText =
type === "INPUT"
? options.offText
: element.find("option").eq(0).text();
on.addClass(
"ui-flipswitch-on ui-btn ui-shadow ui-btn-inherit",
).text(onText);
off.addClass("ui-flipswitch-off").text(offText);
flipswitch
.addClass(
"ui-flipswitch ui-shadow-inset " +
"ui-bar-" +
theme +
" " +
(options.wrapperClass ? options.wrapperClass : "") +
" " +
(element.is(":checked") ||
element.find("option").eq(1).is(":selected")
? "ui-flipswitch-active"
: "") +
(element.is(":disabled") ? " ui-state-disabled" : "") +
(options.corners ? " ui-corner-all" : "") +
(options.mini ? " ui-mini" : ""),
)
.append(on, off);
element
.addClass("ui-flipswitch-input")
.after(flipswitch)
.appendTo(flipswitch);
$.extend(this, {
flipswitch: flipswitch,
on: on,
off: off,
type: type,
});
},
_reset: function () {
this.refresh();
},
refresh: function () {
var direction,
existingDirection = this.flipswitch.hasClass(
"ui-flipswitch-active",
)
? "_right"
: "_left";
if (this.type === "SELECT") {
direction =
this.element.get(0).selectedIndex > 0 ? "_right" : "_left";
} else {
direction = this.element.prop("checked") ? "_right" : "_left";
}
if (direction !== existingDirection) {
this[direction]();
}
},
_toggle: function () {
var direction = this.flipswitch.hasClass("ui-flipswitch-active")
? "_left"
: "_right";
this[direction]();
},
_keydown: function (e) {
if (e.which === $.mobile.keyCode.LEFT) {
this._left();
} else if (e.which === $.mobile.keyCode.RIGHT) {
this._right();
} else if (e.which === $.mobile.keyCode.SPACE) {
this._toggle();
e.preventDefault();
}
},
_setOptions: function (options) {
if (options.theme !== undefined) {
var currentTheme = options.theme ? options.theme : "inherit",
newTheme = options.theme ? options.theme : "inherit";
this.widget()
.removeClass("ui-bar-" + currentTheme)
.addClass("ui-bar-" + newTheme);
}
if (options.onText !== undefined) {
this.on.text(options.onText);
}
if (options.offText !== undefined) {
this.off.text(options.offText);
}
if (options.disabled !== undefined) {
this.widget().toggleClass("ui-state-disabled", options.disabled);
}
if (options.mini !== undefined) {
this.widget().toggleClass("ui-mini", options.mini);
}
if (options.corners !== undefined) {
this.widget().toggleClass("ui-corner-all", options.corners);
}
this._super(options);
},
_destroy: function () {
if (this.options.enhanced) {
return;
}
if (this._originalTabIndex != null) {
this.element.attr("tabindex", this._originalTabIndex);
} else {
this.element.removeAttr("tabindex");
}
this.on.remove();
this.off.remove();
this.element.unwrap();
this.flipswitch.remove();
this.removeClass("ui-flipswitch-input");
},
},
$.mobile.behaviors.formReset,
),
);
})(jQuery);
(function ($, undefined) {
$.widget(
"mobile.rangeslider",
$.extend(
{
options: {
theme: null,
trackTheme: null,
corners: true,
mini: false,
highlight: true,
},
_create: function () {
var $el = this.element,
elClass = this.options.mini
? "ui-rangeslider ui-mini"
: "ui-rangeslider",
_inputFirst = $el.find("input").first(),
_inputLast = $el.find("input").last(),
_label = $el.find("label").first(),
_sliderWidgetFirst =
$.data(_inputFirst.get(0), "mobile-slider") ||
$.data(_inputFirst.slider().get(0), "mobile-slider"),
_sliderWidgetLast =
$.data(_inputLast.get(0), "mobile-slider") ||
$.data(_inputLast.slider().get(0), "mobile-slider"),
_sliderFirst = _sliderWidgetFirst.slider,
_sliderLast = _sliderWidgetLast.slider,
firstHandle = _sliderWidgetFirst.handle,
_sliders = $("<div class='ui-rangeslider-sliders' />").appendTo(
$el,
);
_inputFirst.addClass("ui-rangeslider-first");
_inputLast.addClass("ui-rangeslider-last");
$el.addClass(elClass);
_sliderFirst.appendTo(_sliders);
_sliderLast.appendTo(_sliders);
_label.insertBefore($el);
firstHandle.prependTo(_sliderLast);
$.extend(this, {
_inputFirst: _inputFirst,
_inputLast: _inputLast,
_sliderFirst: _sliderFirst,
_sliderLast: _sliderLast,
_label: _label,
_targetVal: null,
_sliderTarget: false,
_sliders: _sliders,
_proxy: false,
});
this.refresh();
this._on(this.element.find("input.ui-slider-input"), {
slidebeforestart: "_slidebeforestart",
slidestop: "_slidestop",
slidedrag: "_slidedrag",
slidebeforechange: "_change",
blur: "_change",
keyup: "_change",
});
this._on({
mousedown: "_change",
});
this._on(this.element.closest("form"), {
reset: "_handleReset",
});
this._on(firstHandle, {
vmousedown: "_dragFirstHandle",
});
},
_handleReset: function () {
var self = this;
//we must wait for the stack to unwind before updateing other wise sliders will not have updated yet
setTimeout(function () {
self._updateHighlight();
}, 0);
},
_dragFirstHandle: function (event) {
//if the first handle is dragged send the event to the first slider
$.data(this._inputFirst.get(0), "mobile-slider").dragging = true;
$.data(this._inputFirst.get(0), "mobile-slider").refresh(event);
return false;
},
_slidedrag: function (event) {
var first = $(event.target).is(this._inputFirst),
otherSlider = first ? this._inputLast : this._inputFirst;
this._sliderTarget = false;
//if the drag was initiated on an extreme and the other handle is focused send the events to
//the closest handle
if (
(this._proxy === "first" && first) ||
(this._proxy === "last" && !first)
) {
$.data(otherSlider.get(0), "mobile-slider").dragging = true;
$.data(otherSlider.get(0), "mobile-slider").refresh(event);
return false;
}
},
_slidestop: function (event) {
var first = $(event.target).is(this._inputFirst);
this._proxy = false;
//this stops dragging of the handle and brings the active track to the front
//this makes clicks on the track go the the last handle used
this.element.find("input").trigger("vmouseup");
this._sliderFirst.css("z-index", first ? 1 : "");
},
_slidebeforestart: function (event) {
this._sliderTarget = false;
//if the track is the target remember this and the original value
if ($(event.originalEvent.target).hasClass("ui-slider-track")) {
this._sliderTarget = true;
this._targetVal = $(event.target).val();
}
},
_setOptions: function (options) {
if (options.theme !== undefined) {
this._setTheme(options.theme);
}
if (options.trackTheme !== undefined) {
this._setTrackTheme(options.trackTheme);
}
if (options.mini !== undefined) {
this._setMini(options.mini);
}
if (options.highlight !== undefined) {
this._setHighlight(options.highlight);
}
this._super(options);
this.refresh();
},
refresh: function () {
var $el = this.element,
o = this.options;
if (
this._inputFirst.is(":disabled") ||
this._inputLast.is(":disabled")
) {
this.options.disabled = true;
}
$el
.find("input")
.slider({
theme: o.theme,
trackTheme: o.trackTheme,
disabled: o.disabled,
corners: o.corners,
mini: o.mini,
highlight: o.highlight,
})
.slider("refresh");
this._updateHighlight();
},
_change: function (event) {
if (event.type === "keyup") {
this._updateHighlight();
return false;
}
var self = this,
min = parseFloat(this._inputFirst.val(), 10),
max = parseFloat(this._inputLast.val(), 10),
first = $(event.target).hasClass("ui-rangeslider-first"),
thisSlider = first ? this._inputFirst : this._inputLast,
otherSlider = first ? this._inputLast : this._inputFirst;
if (
this._inputFirst.val() > this._inputLast.val() &&
event.type === "mousedown" &&
!$(event.target).hasClass("ui-slider-handle")
) {
thisSlider.blur();
} else if (event.type === "mousedown") {
return;
}
if (min > max && !this._sliderTarget) {
//this prevents min from being greater then max
thisSlider.val(first ? max : min).slider("refresh");
this._trigger("normalize");
} else if (min > max) {
//this makes it so clicks on the target on either extreme go to the closest handle
thisSlider.val(this._targetVal).slider("refresh");
//You must wait for the stack to unwind so first slider is updated before updating second
setTimeout(function () {
otherSlider.val(first ? min : max).slider("refresh");
$.data(otherSlider.get(0), "mobile-slider").handle.focus();
self._sliderFirst.css("z-index", first ? "" : 1);
self._trigger("normalize");
}, 0);
this._proxy = first ? "first" : "last";
}
//fixes issue where when both _sliders are at min they cannot be adjusted
if (min === max) {
$.data(thisSlider.get(0), "mobile-slider").handle.css(
"z-index",
1,
);
$.data(otherSlider.get(0), "mobile-slider").handle.css(
"z-index",
0,
);
} else {
$.data(otherSlider.get(0), "mobile-slider").handle.css(
"z-index",
"",
);
$.data(thisSlider.get(0), "mobile-slider").handle.css(
"z-index",
"",
);
}
this._updateHighlight();
if (min >= max) {
return false;
}
},
_updateHighlight: function () {
var min = parseInt(
$.data(this._inputFirst.get(0), "mobile-slider").handle.get(0)
.style.left,
10,
),
max = parseInt(
$.data(this._inputLast.get(0), "mobile-slider").handle.get(0)
.style.left,
10,
),
width = max - min;
this.element.find(".ui-slider-bg").css({
"margin-left": min + "%",
width: width + "%",
});
},
_setTheme: function (value) {
this._inputFirst.slider("option", "theme", value);
this._inputLast.slider("option", "theme", value);
},
_setTrackTheme: function (value) {
this._inputFirst.slider("option", "trackTheme", value);
this._inputLast.slider("option", "trackTheme", value);
},
_setMini: function (value) {
this._inputFirst.slider("option", "mini", value);
this._inputLast.slider("option", "mini", value);
this.element.toggleClass("ui-mini", !!value);
},
_setHighlight: function (value) {
this._inputFirst.slider("option", "highlight", value);
this._inputLast.slider("option", "highlight", value);
},
_destroy: function () {
this._label.prependTo(this.element);
this.element.removeClass("ui-rangeslider ui-mini");
this._inputFirst.after(this._sliderFirst);
this._inputLast.after(this._sliderLast);
this._sliders.remove();
this.element
.find("input")
.removeClass("ui-rangeslider-first ui-rangeslider-last")
.slider("destroy");
},
},
$.mobile.behaviors.formReset,
),
);
})(jQuery);
(function ($, undefined) {
$.widget("mobile.textinput", $.mobile.textinput, {
options: {
clearBtn: false,
clearBtnText: "Clear text",
},
_create: function () {
this._super();
if (!!this.options.clearBtn || this.isSearch) {
this._addClearBtn();
}
},
clearButton: function () {
return $(
"<a href='#' class='ui-input-clear ui-btn ui-icon-delete ui-btn-icon-notext ui-corner-all" +
"' title='" +
this.options.clearBtnText +
"'>" +
this.options.clearBtnText +
"</a>",
);
},
_clearBtnClick: function (event) {
this.element.val("").focus().trigger("change");
this._clearBtn.addClass("ui-input-clear-hidden");
event.preventDefault();
},
_addClearBtn: function () {
if (!this.options.enhanced) {
this._enhanceClear();
}
$.extend(this, {
_clearBtn: this.widget().find("a.ui-input-clear"),
});
this._bindClearEvents();
this._toggleClear();
},
_enhanceClear: function () {
this.clearButton().appendTo(this.widget());
this.widget().addClass("ui-input-has-clear");
},
_bindClearEvents: function () {
this._on(this._clearBtn, {
click: "_clearBtnClick",
});
this._on({
keyup: "_toggleClear",
change: "_toggleClear",
input: "_toggleClear",
focus: "_toggleClear",
blur: "_toggleClear",
cut: "_toggleClear",
paste: "_toggleClear",
});
},
_unbindClear: function () {
this._off(this._clearBtn, "click");
this._off(this.element, "keyup change input focus blur cut paste");
},
_setOptions: function (options) {
this._super(options);
if (
options.clearBtn !== undefined &&
!this.element.is("textarea, :jqmData(type='range')")
) {
if (options.clearBtn) {
this._addClearBtn();
} else {
this._destroyClear();
}
}
if (
options.clearBtnText !== undefined &&
this._clearBtn !== undefined
) {
this._clearBtn
.text(options.clearBtnText)
.attr("title", options.clearBtnText);
}
},
_toggleClear: function () {
this._delay("_toggleClearClass", 0);
},
_toggleClearClass: function () {
this._clearBtn.toggleClass(
"ui-input-clear-hidden",
!this.element.val(),
);
},
_destroyClear: function () {
this.widget().removeClass("ui-input-has-clear");
this._unbindClear();
this._clearBtn.remove();
},
_destroy: function () {
this._super();
this._destroyClear();
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.textinput", $.mobile.textinput, {
options: {
autogrow: true,
keyupTimeoutBuffer: 100,
},
_create: function () {
this._super();
if (this.options.autogrow && this.isTextarea) {
this._autogrow();
}
},
_autogrow: function () {
this.element.addClass("ui-textinput-autogrow");
this._on({
keyup: "_timeout",
change: "_timeout",
input: "_timeout",
paste: "_timeout",
});
// Attach to the various you-have-become-visible notifications that the
// various framework elements emit.
// TODO: Remove all but the updatelayout handler once #6426 is fixed.
this._on(true, this.document, {
// TODO: Move to non-deprecated event
pageshow: "_handleShow",
popupbeforeposition: "_handleShow",
updatelayout: "_handleShow",
panelopen: "_handleShow",
});
},
// Synchronously fix the widget height if this widget's parents are such
// that they show/hide content at runtime. We still need to check whether
// the widget is actually visible in case it is contained inside multiple
// such containers. For example: panel contains collapsible contains
// autogrow textinput. The panel may emit "panelopen" indicating that its
// content has become visible, but the collapsible is still collapsed, so
// the autogrow textarea is still not visible.
_handleShow: function (event) {
if (
$.contains(event.target, this.element[0]) &&
this.element.is(":visible")
) {
if (event.type !== "popupbeforeposition") {
this.element
.addClass("ui-textinput-autogrow-resize")
.animationComplete(
$.proxy(function () {
this.element.removeClass("ui-textinput-autogrow-resize");
}, this),
"transition",
);
}
this._timeout();
}
},
_unbindAutogrow: function () {
this.element.removeClass("ui-textinput-autogrow");
this._off(this.element, "keyup change input paste");
this._off(
this.document,
"pageshow popupbeforeposition updatelayout panelopen",
);
},
keyupTimeout: null,
_prepareHeightUpdate: function (delay) {
if (this.keyupTimeout) {
clearTimeout(this.keyupTimeout);
}
if (delay === undefined) {
this._updateHeight();
} else {
this.keyupTimeout = this._delay("_updateHeight", delay);
}
},
_timeout: function () {
this._prepareHeightUpdate(this.options.keyupTimeoutBuffer);
},
_updateHeight: function () {
var paddingTop,
paddingBottom,
paddingHeight,
scrollHeight,
clientHeight,
borderTop,
borderBottom,
borderHeight,
height,
scrollTop = this.window.scrollTop();
this.keyupTimeout = 0;
// IE8 textareas have the onpage property - others do not
if (!("onpage" in this.element[0])) {
this.element.css({
height: 0,
"min-height": 0,
"max-height": 0,
});
}
scrollHeight = this.element[0].scrollHeight;
clientHeight = this.element[0].clientHeight;
borderTop = parseFloat(this.element.css("border-top-width"));
borderBottom = parseFloat(this.element.css("border-bottom-width"));
borderHeight = borderTop + borderBottom;
height = scrollHeight + borderHeight + 15;
// Issue 6179: Padding is not included in scrollHeight and
// clientHeight by Firefox if no scrollbar is visible. Because
// textareas use the border-box box-sizing model, padding should be
// included in the new (assigned) height. Because the height is set
// to 0, clientHeight == 0 in Firefox. Therefore, we can use this to
// check if padding must be added.
if (clientHeight === 0) {
paddingTop = parseFloat(this.element.css("padding-top"));
paddingBottom = parseFloat(this.element.css("padding-bottom"));
paddingHeight = paddingTop + paddingBottom;
height += paddingHeight;
}
this.element.css({
height: height,
"min-height": "",
"max-height": "",
});
this.window.scrollTop(scrollTop);
},
refresh: function () {
if (this.options.autogrow && this.isTextarea) {
this._updateHeight();
}
},
_setOptions: function (options) {
this._super(options);
if (options.autogrow !== undefined && this.isTextarea) {
if (options.autogrow) {
this._autogrow();
} else {
this._unbindAutogrow();
}
}
},
});
})(jQuery);
(function ($, undefined) {
$.widget(
"mobile.selectmenu",
$.extend(
{
initSelector:
"select:not( :jqmData(role='slider')):not( :jqmData(role='flipswitch') )",
options: {
theme: null,
icon: "carat-d",
iconpos: "right",
inline: false,
corners: true,
shadow: true,
iconshadow: false /* TODO: Deprecated in 1.4, remove in 1.5. */,
overlayTheme: null,
dividerTheme: null,
hidePlaceholderMenuItems: true,
closeText: "Close",
nativeMenu: true,
// This option defaults to true on iOS devices.
preventFocusZoom:
/iPhone|iPad|iPod/.test(navigator.platform) &&
navigator.userAgent.indexOf("AppleWebKit") > -1,
mini: false,
},
_button: function () {
return $("<div/>");
},
_setDisabled: function (value) {
this.element.attr("disabled", value);
this.button.attr("aria-disabled", value);
return this._setOption("disabled", value);
},
_focusButton: function () {
var self = this;
setTimeout(function () {
self.button.focus();
}, 40);
},
_selectOptions: function () {
return this.select.find("option");
},
// setup items that are generally necessary for select menu extension
_preExtension: function () {
var inline = this.options.inline || this.element.jqmData("inline"),
mini = this.options.mini || this.element.jqmData("mini"),
classes = "";
// TODO: Post 1.1--once we have time to test thoroughly--any classes manually applied to the original element should be carried over to the enhanced element, with an `-enhanced` suffix. See https://github.com/jquery/jquery-mobile/issues/3577
/* if ( $el[0].className.length ) {
classes = $el[0].className;
} */
if (!!~this.element[0].className.indexOf("ui-btn-left")) {
classes = " ui-btn-left";
}
if (!!~this.element[0].className.indexOf("ui-btn-right")) {
classes = " ui-btn-right";
}
if (inline) {
classes += " ui-btn-inline";
}
if (mini) {
classes += " ui-mini";
}
this.select = this.element
.removeClass("ui-btn-left ui-btn-right")
.wrap("<div class='ui-select" + classes + "'>");
this.selectId = this.select.attr("id") || "select-" + this.uuid;
this.buttonId = this.selectId + "-button";
this.label = $("label[for='" + this.selectId + "']");
this.isMultiple = this.select[0].multiple;
},
_destroy: function () {
var wrapper = this.element.parents(".ui-select");
if (wrapper.length > 0) {
if (wrapper.is(".ui-btn-left, .ui-btn-right")) {
this.element.addClass(
wrapper.hasClass("ui-btn-left")
? "ui-btn-left"
: "ui-btn-right",
);
}
this.element.insertAfter(wrapper);
wrapper.remove();
}
},
_create: function () {
this._preExtension();
this.button = this._button();
var self = this,
options = this.options,
iconpos = options.icon
? options.iconpos || this.select.jqmData("iconpos")
: false,
button = this.button
.insertBefore(this.select)
.attr("id", this.buttonId)
.addClass(
"ui-btn" +
(options.icon
? " ui-icon-" +
options.icon +
" ui-btn-icon-" +
iconpos +
(options.iconshadow ? " ui-shadow-icon" : "")
: "") /* TODO: Remove in 1.5. */ +
(options.theme ? " ui-btn-" + options.theme : "") +
(options.corners ? " ui-corner-all" : "") +
(options.shadow ? " ui-shadow" : ""),
);
this.setButtonText();
// Opera does not properly support opacity on select elements
// In Mini, it hides the element, but not its text
// On the desktop,it seems to do the opposite
// for these reasons, using the nativeMenu option results in a full native select in Opera
if (options.nativeMenu && window.opera && window.opera.version) {
button.addClass("ui-select-nativeonly");
}
// Add counter for multi selects
if (this.isMultiple) {
this.buttonCount = $("<span>")
.addClass("ui-li-count ui-body-inherit")
.hide()
.appendTo(button.addClass("ui-li-has-count"));
}
// Disable if specified
if (options.disabled || this.element.attr("disabled")) {
this.disable();
}
// Events on native select
this.select.change(function () {
self.refresh();
if (!!options.nativeMenu) {
this.blur();
}
});
this._handleFormReset();
this._on(this.button, {
keydown: "_handleKeydown",
});
this.build();
},
build: function () {
var self = this;
this.select
.appendTo(self.button)
.bind("vmousedown", function () {
// Add active class to button
self.button.addClass($.mobile.activeBtnClass);
})
.bind("focus", function () {
self.button.addClass($.mobile.focusClass);
})
.bind("blur", function () {
self.button.removeClass($.mobile.focusClass);
})
.bind("focus vmouseover", function () {
self.button.trigger("vmouseover");
})
.bind("vmousemove", function () {
// Remove active class on scroll/touchmove
self.button.removeClass($.mobile.activeBtnClass);
})
.bind("change blur vmouseout", function () {
self.button
.trigger("vmouseout")
.removeClass($.mobile.activeBtnClass);
});
// In many situations, iOS will zoom into the select upon tap, this prevents that from happening
self.button.bind("vmousedown", function () {
if (self.options.preventFocusZoom) {
$.mobile.zoom.disable(true);
}
});
self.label.bind("click focus", function () {
if (self.options.preventFocusZoom) {
$.mobile.zoom.disable(true);
}
});
self.select.bind("focus", function () {
if (self.options.preventFocusZoom) {
$.mobile.zoom.disable(true);
}
});
self.button.bind("mouseup", function () {
if (self.options.preventFocusZoom) {
setTimeout(function () {
$.mobile.zoom.enable(true);
}, 0);
}
});
self.select.bind("blur", function () {
if (self.options.preventFocusZoom) {
$.mobile.zoom.enable(true);
}
});
},
selected: function () {
return this._selectOptions().filter(":selected");
},
selectedIndices: function () {
var self = this;
return this.selected()
.map(function () {
return self._selectOptions().index(this);
})
.get();
},
setButtonText: function () {
var self = this,
selected = this.selected(),
text = this.placeholder,
span = $(document.createElement("span"));
this.button
.children("span")
.not(".ui-li-count")
.remove()
.end()
.end()
.prepend(
(function () {
if (selected.length) {
text = selected
.map(function () {
return $(this).text();
})
.get()
.join(", ");
} else {
text = self.placeholder;
}
if (text) {
span.text(text);
} else {
// Set the contents to which we write as   to be XHTML compliant - see gh-6699
span.html(" ");
}
// TODO possibly aggregate multiple select option classes
return span
.addClass(self.select.attr("class"))
.addClass(selected.attr("class"))
.removeClass("ui-screen-hidden");
})(),
);
},
setButtonCount: function () {
var selected = this.selected();
// multiple count inside button
if (this.isMultiple) {
this.buttonCount[selected.length > 1 ? "show" : "hide"]().text(
selected.length,
);
}
},
_handleKeydown: function (/* event */) {
this._delay("_refreshButton");
},
_reset: function () {
this.refresh();
},
_refreshButton: function () {
this.setButtonText();
this.setButtonCount();
},
refresh: function () {
this._refreshButton();
},
// open and close preserved in native selects
// to simplify users code when looping over selects
open: $.noop,
close: $.noop,
disable: function () {
this._setDisabled(true);
this.button.addClass("ui-state-disabled");
},
enable: function () {
this._setDisabled(false);
this.button.removeClass("ui-state-disabled");
},
},
$.mobile.behaviors.formReset,
),
);
})(jQuery);
(function ($, undefined) {
$.mobile.links = function (target) {
//links within content areas, tests included with page
$(target)
.find("a")
.jqmEnhanceable()
.filter(":jqmData(rel='popup')[href][href!='']")
.each(function () {
// Accessibility info for popups
var element = this,
idref = element.getAttribute("href").substring(1);
if (idref) {
element.setAttribute("aria-haspopup", true);
element.setAttribute("aria-owns", idref);
element.setAttribute("aria-expanded", false);
}
})
.end()
.not(".ui-btn, :jqmData(role='none'), :jqmData(role='nojs')")
.addClass("ui-link");
};
})(jQuery);
(function ($, undefined) {
function fitSegmentInsideSegment(windowSize, segmentSize, offset, desired) {
var returnValue = desired;
if (windowSize < segmentSize) {
// Center segment if it's bigger than the window
returnValue = offset + (windowSize - segmentSize) / 2;
} else {
// Otherwise center it at the desired coordinate while keeping it completely inside the window
returnValue = Math.min(
Math.max(offset, desired - segmentSize / 2),
offset + windowSize - segmentSize,
);
}
return returnValue;
}
function getWindowCoordinates(theWindow) {
return {
x: theWindow.scrollLeft(),
y: theWindow.scrollTop(),
cx: theWindow[0].innerWidth || theWindow.width(),
cy: theWindow[0].innerHeight || theWindow.height(),
};
}
$.widget("mobile.popup", {
options: {
wrapperClass: null,
theme: null,
overlayTheme: null,
shadow: true,
corners: true,
transition: "none",
positionTo: "origin",
tolerance: null,
closeLinkSelector: "a:jqmData(rel='back')",
closeLinkEvents: "click.popup",
navigateEvents: "navigate.popup",
closeEvents: "navigate.popup pagebeforechange.popup",
dismissible: true,
enhanced: false,
// NOTE Windows Phone 7 has a scroll position caching issue that
// requires us to disable popup history management by default
// https://github.com/jquery/jquery-mobile/issues/4784
//
// NOTE this option is modified in _create!
history: !$.mobile.browser.oldIE,
},
_create: function () {
var theElement = this.element,
myId = theElement.attr("id"),
currentOptions = this.options;
// We need to adjust the history option to be false if there's no AJAX nav.
// We can't do it in the option declarations because those are run before
// it is determined whether there shall be AJAX nav.
currentOptions.history =
currentOptions.history &&
$.mobile.ajaxEnabled &&
$.mobile.hashListeningEnabled;
// Define instance variables
$.extend(this, {
_scrollTop: 0,
_page: theElement.closest(".ui-page"),
_ui: null,
_fallbackTransition: "",
_currentTransition: false,
_prerequisites: null,
_isOpen: false,
_tolerance: null,
_resizeData: null,
_ignoreResizeTo: 0,
_orientationchangeInProgress: false,
});
if (this._page.length === 0) {
this._page = $("body");
}
if (currentOptions.enhanced) {
this._ui = {
container: theElement.parent(),
screen: theElement.parent().prev(),
placeholder: $(
this.document[0].getElementById(myId + "-placeholder"),
),
};
} else {
this._ui = this._enhance(theElement, myId);
this._applyTransition(currentOptions.transition);
}
this._setTolerance(currentOptions.tolerance)._ui.focusElement =
this._ui.container;
// Event handlers
this._on(this._ui.screen, { vclick: "_eatEventAndClose" });
this._on(this.window, {
orientationchange: $.proxy(this, "_handleWindowOrientationchange"),
resize: $.proxy(this, "_handleWindowResize"),
keyup: $.proxy(this, "_handleWindowKeyUp"),
});
this._on(this.document, { focusin: "_handleDocumentFocusIn" });
},
_enhance: function (theElement, myId) {
var currentOptions = this.options,
wrapperClass = currentOptions.wrapperClass,
ui = {
screen: $(
"<div class='ui-screen-hidden ui-popup-screen " +
this._themeClassFromOption(
"ui-overlay-",
currentOptions.overlayTheme,
) +
"'></div>",
),
placeholder: $(
"<div style='display: none;'><!-- placeholder --></div>",
),
container: $(
"<div class='ui-popup-container ui-popup-hidden ui-popup-truncate" +
(wrapperClass ? " " + wrapperClass : "") +
"'></div>",
),
},
fragment = this.document[0].createDocumentFragment();
fragment.appendChild(ui.screen[0]);
fragment.appendChild(ui.container[0]);
if (myId) {
ui.screen.attr("id", myId + "-screen");
ui.container.attr("id", myId + "-popup");
ui.placeholder
.attr("id", myId + "-placeholder")
.html("<!-- placeholder for " + myId + " -->");
}
// Apply the proto
this._page[0].appendChild(fragment);
// Leave a placeholder where the element used to be
ui.placeholder.insertAfter(theElement);
theElement
.detach()
.addClass(
"ui-popup " +
this._themeClassFromOption("ui-body-", currentOptions.theme) +
" " +
(currentOptions.shadow ? "ui-overlay-shadow " : "") +
(currentOptions.corners ? "ui-corner-all " : ""),
)
.appendTo(ui.container);
return ui;
},
_eatEventAndClose: function (theEvent) {
theEvent.preventDefault();
theEvent.stopImmediatePropagation();
if (this.options.dismissible) {
this.close();
}
return false;
},
// Make sure the screen covers the entire document - CSS is sometimes not
// enough to accomplish this.
_resizeScreen: function () {
var screen = this._ui.screen,
popupHeight = this._ui.container.outerHeight(true),
screenHeight = screen.removeAttr("style").height(),
// Subtracting 1 here is necessary for an obscure Andrdoid 4.0 bug where
// the browser hangs if the screen covers the entire document :/
documentHeight = this.document.height() - 1;
if (screenHeight < documentHeight) {
screen.height(documentHeight);
} else if (popupHeight > screenHeight) {
screen.height(popupHeight);
}
},
_handleWindowKeyUp: function (theEvent) {
if (this._isOpen && theEvent.keyCode === $.mobile.keyCode.ESCAPE) {
return this._eatEventAndClose(theEvent);
}
},
_expectResizeEvent: function () {
var windowCoordinates = getWindowCoordinates(this.window);
if (this._resizeData) {
if (
windowCoordinates.x === this._resizeData.windowCoordinates.x &&
windowCoordinates.y === this._resizeData.windowCoordinates.y &&
windowCoordinates.cx === this._resizeData.windowCoordinates.cx &&
windowCoordinates.cy === this._resizeData.windowCoordinates.cy
) {
// timeout not refreshed
return false;
} else {
// clear existing timeout - it will be refreshed below
clearTimeout(this._resizeData.timeoutId);
}
}
this._resizeData = {
timeoutId: this._delay("_resizeTimeout", 200),
windowCoordinates: windowCoordinates,
};
return true;
},
_resizeTimeout: function () {
if (this._isOpen) {
if (!this._expectResizeEvent()) {
if (this._ui.container.hasClass("ui-popup-hidden")) {
// effectively rapid-open the popup while leaving the screen intact
this._ui.container.removeClass(
"ui-popup-hidden ui-popup-truncate",
);
this.reposition({ positionTo: "window" });
this._ignoreResizeEvents();
}
this._resizeScreen();
this._resizeData = null;
this._orientationchangeInProgress = false;
}
} else {
this._resizeData = null;
this._orientationchangeInProgress = false;
}
},
_stopIgnoringResizeEvents: function () {
this._ignoreResizeTo = 0;
},
_ignoreResizeEvents: function () {
if (this._ignoreResizeTo) {
clearTimeout(this._ignoreResizeTo);
}
this._ignoreResizeTo = this._delay("_stopIgnoringResizeEvents", 1000);
},
_handleWindowResize: function (/* theEvent */) {
if (this._isOpen && this._ignoreResizeTo === 0) {
if (
(this._expectResizeEvent() || this._orientationchangeInProgress) &&
!this._ui.container.hasClass("ui-popup-hidden")
) {
// effectively rapid-close the popup while leaving the screen intact
this._ui.container
.addClass("ui-popup-hidden ui-popup-truncate")
.removeAttr("style");
}
}
},
_handleWindowOrientationchange: function (/* theEvent */) {
if (
!this._orientationchangeInProgress &&
this._isOpen &&
this._ignoreResizeTo === 0
) {
this._expectResizeEvent();
this._orientationchangeInProgress = true;
}
},
// When the popup is open, attempting to focus on an element that is not a
// child of the popup will redirect focus to the popup
_handleDocumentFocusIn: function (theEvent) {
var target,
targetElement = theEvent.target,
ui = this._ui;
if (!this._isOpen) {
return;
}
if (targetElement !== ui.container[0]) {
target = $(targetElement);
if (0 === target.parents().filter(ui.container[0]).length) {
$(this.document[0].activeElement).one(
"focus",
function (/* theEvent */) {
target.blur();
},
);
ui.focusElement.focus();
theEvent.preventDefault();
theEvent.stopImmediatePropagation();
return false;
} else if (ui.focusElement[0] === ui.container[0]) {
ui.focusElement = target;
}
}
this._ignoreResizeEvents();
},
_themeClassFromOption: function (prefix, value) {
return value
? value === "none"
? ""
: prefix + value
: prefix + "inherit";
},
_applyTransition: function (value) {
if (value) {
this._ui.container.removeClass(this._fallbackTransition);
if (value !== "none") {
this._fallbackTransition = $.mobile._maybeDegradeTransition(value);
if (this._fallbackTransition === "none") {
this._fallbackTransition = "";
}
this._ui.container.addClass(this._fallbackTransition);
}
}
return this;
},
_setOptions: function (newOptions) {
var currentOptions = this.options,
theElement = this.element,
screen = this._ui.screen;
if (newOptions.wrapperClass !== undefined) {
this._ui.container
.removeClass(currentOptions.wrapperClass)
.addClass(newOptions.wrapperClass);
}
if (newOptions.theme !== undefined) {
theElement
.removeClass(
this._themeClassFromOption("ui-body-", currentOptions.theme),
)
.addClass(this._themeClassFromOption("ui-body-", newOptions.theme));
}
if (newOptions.overlayTheme !== undefined) {
screen
.removeClass(
this._themeClassFromOption(
"ui-overlay-",
currentOptions.overlayTheme,
),
)
.addClass(
this._themeClassFromOption(
"ui-overlay-",
newOptions.overlayTheme,
),
);
if (this._isOpen) {
screen.addClass("in");
}
}
if (newOptions.shadow !== undefined) {
theElement.toggleClass("ui-overlay-shadow", newOptions.shadow);
}
if (newOptions.corners !== undefined) {
theElement.toggleClass("ui-corner-all", newOptions.corners);
}
if (newOptions.transition !== undefined) {
if (!this._currentTransition) {
this._applyTransition(newOptions.transition);
}
}
if (newOptions.tolerance !== undefined) {
this._setTolerance(newOptions.tolerance);
}
if (newOptions.disabled !== undefined) {
if (newOptions.disabled) {
this.close();
}
}
return this._super(newOptions);
},
_setTolerance: function (value) {
var tol = { t: 30, r: 15, b: 30, l: 15 },
ar;
if (value !== undefined) {
ar = String(value).split(",");
$.each(ar, function (idx, val) {
ar[idx] = parseInt(val, 10);
});
switch (ar.length) {
// All values are to be the same
case 1:
if (!isNaN(ar[0])) {
tol.t = tol.r = tol.b = tol.l = ar[0];
}
break;
// The first value denotes top/bottom tolerance, and the second value denotes left/right tolerance
case 2:
if (!isNaN(ar[0])) {
tol.t = tol.b = ar[0];
}
if (!isNaN(ar[1])) {
tol.l = tol.r = ar[1];
}
break;
// The array contains values in the order top, right, bottom, left
case 4:
if (!isNaN(ar[0])) {
tol.t = ar[0];
}
if (!isNaN(ar[1])) {
tol.r = ar[1];
}
if (!isNaN(ar[2])) {
tol.b = ar[2];
}
if (!isNaN(ar[3])) {
tol.l = ar[3];
}
break;
default:
break;
}
}
this._tolerance = tol;
return this;
},
_clampPopupWidth: function (infoOnly) {
var menuSize,
windowCoordinates = getWindowCoordinates(this.window),
// rectangle within which the popup must fit
rectangle = {
x: this._tolerance.l,
y: windowCoordinates.y + this._tolerance.t,
cx: windowCoordinates.cx - this._tolerance.l - this._tolerance.r,
cy: windowCoordinates.cy - this._tolerance.t - this._tolerance.b,
};
if (!infoOnly) {
// Clamp the width of the menu before grabbing its size
this._ui.container.css("max-width", rectangle.cx);
}
menuSize = {
cx: this._ui.container.outerWidth(true),
cy: this._ui.container.outerHeight(true),
};
return { rc: rectangle, menuSize: menuSize };
},
_calculateFinalLocation: function (desired, clampInfo) {
var returnValue,
rectangle = clampInfo.rc,
menuSize = clampInfo.menuSize;
// Center the menu over the desired coordinates, while not going outside
// the window tolerances. This will center wrt. the window if the popup is
// too large.
returnValue = {
left: fitSegmentInsideSegment(
rectangle.cx,
menuSize.cx,
rectangle.x,
desired.x,
),
top: fitSegmentInsideSegment(
rectangle.cy,
menuSize.cy,
rectangle.y,
desired.y,
),
};
// Make sure the top of the menu is visible
returnValue.top = Math.max(0, returnValue.top);
// If the height of the menu is smaller than the height of the document
// align the bottom with the bottom of the document
returnValue.top -= Math.min(
returnValue.top,
Math.max(0, returnValue.top + menuSize.cy - this.document.height()),
);
return returnValue;
},
// Try and center the overlay over the given coordinates
_placementCoords: function (desired) {
return this._calculateFinalLocation(desired, this._clampPopupWidth());
},
_createPrerequisites: function (
screenPrerequisite,
containerPrerequisite,
whenDone,
) {
var prerequisites,
self = this;
// It is important to maintain both the local variable prerequisites and
// self._prerequisites. The local variable remains in the closure of the
// functions which call the callbacks passed in. The comparison between the
// local variable and self._prerequisites is necessary, because once a
// function has been passed to .animationComplete() it will be called next
// time an animation completes, even if that's not the animation whose end
// the function was supposed to catch (for example, if an abort happens
// during the opening animation, the .animationComplete handler is not
// called for that animation anymore, but the handler remains attached, so
// it is called the next time the popup is opened - making it stale.
// Comparing the local variable prerequisites to the widget-level variable
// self._prerequisites ensures that callbacks triggered by a stale
// .animationComplete will be ignored.
prerequisites = {
screen: $.Deferred(),
container: $.Deferred(),
};
prerequisites.screen.then(function () {
if (prerequisites === self._prerequisites) {
screenPrerequisite();
}
});
prerequisites.container.then(function () {
if (prerequisites === self._prerequisites) {
containerPrerequisite();
}
});
$.when(prerequisites.screen, prerequisites.container).done(function () {
if (prerequisites === self._prerequisites) {
self._prerequisites = null;
whenDone();
}
});
self._prerequisites = prerequisites;
},
_animate: function (args) {
// NOTE before removing the default animation of the screen
// this had an animate callback that would resolve the deferred
// now the deferred is resolved immediately
// TODO remove the dependency on the screen deferred
this._ui.screen
.removeClass(args.classToRemove)
.addClass(args.screenClassToAdd);
args.prerequisites.screen.resolve();
if (args.transition && args.transition !== "none") {
if (args.applyTransition) {
this._applyTransition(args.transition);
}
if (this._fallbackTransition) {
this._ui.container
.addClass(args.containerClassToAdd)
.removeClass(args.classToRemove)
.animationComplete(
$.proxy(args.prerequisites.container, "resolve"),
);
return;
}
}
this._ui.container.removeClass(args.classToRemove);
args.prerequisites.container.resolve();
},
// The desired coordinates passed in will be returned untouched if no reference element can be identified via
// desiredPosition.positionTo. Nevertheless, this function ensures that its return value always contains valid
// x and y coordinates by specifying the center middle of the window if the coordinates are absent.
// options: { x: coordinate, y: coordinate, positionTo: string: "origin", "window", or jQuery selector
_desiredCoords: function (openOptions) {
var offset,
dst = null,
windowCoordinates = getWindowCoordinates(this.window),
x = openOptions.x,
y = openOptions.y,
pTo = openOptions.positionTo;
// Establish which element will serve as the reference
if (pTo && pTo !== "origin") {
if (pTo === "window") {
x = windowCoordinates.cx / 2 + windowCoordinates.x;
y = windowCoordinates.cy / 2 + windowCoordinates.y;
} else {
try {
dst = $(pTo);
} catch (err) {
dst = null;
}
if (dst) {
dst.filter(":visible");
if (dst.length === 0) {
dst = null;
}
}
}
}
// If an element was found, center over it
if (dst) {
offset = dst.offset();
x = offset.left + dst.outerWidth() / 2;
y = offset.top + dst.outerHeight() / 2;
}
// Make sure x and y are valid numbers - center over the window
if ($.type(x) !== "number" || isNaN(x)) {
x = windowCoordinates.cx / 2 + windowCoordinates.x;
}
if ($.type(y) !== "number" || isNaN(y)) {
y = windowCoordinates.cy / 2 + windowCoordinates.y;
}
return { x: x, y: y };
},
_reposition: function (openOptions) {
// We only care about position-related parameters for repositioning
openOptions = {
x: openOptions.x,
y: openOptions.y,
positionTo: openOptions.positionTo,
};
this._trigger("beforeposition", undefined, openOptions);
this._ui.container.offset(
this._placementCoords(this._desiredCoords(openOptions)),
);
},
reposition: function (openOptions) {
if (this._isOpen) {
this._reposition(openOptions);
}
},
_openPrerequisitesComplete: function () {
var id = this.element.attr("id");
this._ui.container.addClass("ui-popup-active");
this._isOpen = true;
this._resizeScreen();
this._ui.container.attr("tabindex", "0").focus();
this._ignoreResizeEvents();
if (id) {
this.document
.find("[aria-haspopup='true'][aria-owns='" + id + "']")
.attr("aria-expanded", true);
}
this._trigger("afteropen");
},
_open: function (options) {
var openOptions = $.extend({}, this.options, options),
// TODO move blacklist to private method
androidBlacklist = (function () {
var ua = navigator.userAgent,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match(/AppleWebKit\/([0-9\.]+)/),
wkversion = !!wkmatch && wkmatch[1],
androidmatch = ua.match(/Android (\d+(?:\.\d+))/),
andversion = !!androidmatch && androidmatch[1],
chromematch = ua.indexOf("Chrome") > -1;
// Platform is Android, WebKit version is greater than 534.13 ( Android 3.2.1 ) and not Chrome.
if (
androidmatch !== null &&
andversion === "4.0" &&
wkversion &&
wkversion > 534.13 &&
!chromematch
) {
return true;
}
return false;
})();
// Count down to triggering "popupafteropen" - we have two prerequisites:
// 1. The popup window animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites(
$.noop,
$.noop,
$.proxy(this, "_openPrerequisitesComplete"),
);
this._currentTransition = openOptions.transition;
this._applyTransition(openOptions.transition);
this._ui.screen.removeClass("ui-screen-hidden");
this._ui.container.removeClass("ui-popup-truncate");
// Give applications a chance to modify the contents of the container before it appears
this._reposition(openOptions);
this._ui.container.removeClass("ui-popup-hidden");
if (this.options.overlayTheme && androidBlacklist) {
/* TODO: The native browser on Android 4.0.X ("Ice Cream Sandwich") suffers from an issue where the popup overlay appears to be z-indexed above the popup itself when certain other styles exist on the same page -- namely, any element set to `position: fixed` and certain types of input. These issues are reminiscent of previously uncovered bugs in older versions of Android's native browser: https://github.com/scottjehl/Device-Bugs/issues/3
This fix closes the following bugs ( I use "closes" with reluctance, and stress that this issue should be revisited as soon as possible ):
https://github.com/jquery/jquery-mobile/issues/4816
https://github.com/jquery/jquery-mobile/issues/4844
https://github.com/jquery/jquery-mobile/issues/4874
*/
// TODO sort out why this._page isn't working
this.element.closest(".ui-page").addClass("ui-popup-open");
}
this._animate({
additionalCondition: true,
transition: openOptions.transition,
classToRemove: "",
screenClassToAdd: "in",
containerClassToAdd: "in",
applyTransition: false,
prerequisites: this._prerequisites,
});
},
_closePrerequisiteScreen: function () {
this._ui.screen.removeClass("out").addClass("ui-screen-hidden");
},
_closePrerequisiteContainer: function () {
this._ui.container
.removeClass("reverse out")
.addClass("ui-popup-hidden ui-popup-truncate")
.removeAttr("style");
},
_closePrerequisitesDone: function () {
var container = this._ui.container,
id = this.element.attr("id");
container.removeAttr("tabindex");
// remove the global mutex for popups
$.mobile.popup.active = undefined;
// Blur elements inside the container, including the container
$(":focus", container[0]).add(container[0]).blur();
if (id) {
this.document
.find("[aria-haspopup='true'][aria-owns='" + id + "']")
.attr("aria-expanded", false);
}
// alert users that the popup is closed
this._trigger("afterclose");
},
_close: function (immediate) {
this._ui.container.removeClass("ui-popup-active");
this._page.removeClass("ui-popup-open");
this._isOpen = false;
// Count down to triggering "popupafterclose" - we have two prerequisites:
// 1. The popup window reverse animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites(
$.proxy(this, "_closePrerequisiteScreen"),
$.proxy(this, "_closePrerequisiteContainer"),
$.proxy(this, "_closePrerequisitesDone"),
);
this._animate({
additionalCondition: this._ui.screen.hasClass("in"),
transition: immediate ? "none" : this._currentTransition,
classToRemove: "in",
screenClassToAdd: "out",
containerClassToAdd: "reverse out",
applyTransition: true,
prerequisites: this._prerequisites,
});
},
_unenhance: function () {
if (this.options.enhanced) {
return;
}
// Put the element back to where the placeholder was and remove the "ui-popup" class
this._setOptions({ theme: $.mobile.popup.prototype.options.theme });
this.element
// Cannot directly insertAfter() - we need to detach() first, because
// insertAfter() will do nothing if the payload div was not attached
// to the DOM at the time the widget was created, and so the payload
// will remain inside the container even after we call insertAfter().
// If that happens and we remove the container a few lines below, we
// will cause an infinite recursion - #5244
.detach()
.insertAfter(this._ui.placeholder)
.removeClass(
"ui-popup ui-overlay-shadow ui-corner-all ui-body-inherit",
);
this._ui.screen.remove();
this._ui.container.remove();
this._ui.placeholder.remove();
},
_destroy: function () {
if ($.mobile.popup.active === this) {
this.element.one("popupafterclose", $.proxy(this, "_unenhance"));
this.close();
} else {
this._unenhance();
}
return this;
},
_closePopup: function (theEvent, data) {
var parsedDst,
toUrl,
currentOptions = this.options,
immediate = false;
if (
(theEvent && theEvent.isDefaultPrevented()) ||
$.mobile.popup.active !== this
) {
return;
}
// restore location on screen
window.scrollTo(0, this._scrollTop);
if (theEvent && theEvent.type === "pagebeforechange" && data) {
// Determine whether we need to rapid-close the popup, or whether we can
// take the time to run the closing transition
if (typeof data.toPage === "string") {
parsedDst = data.toPage;
} else {
parsedDst = data.toPage.jqmData("url");
}
parsedDst = $.mobile.path.parseUrl(parsedDst);
toUrl = parsedDst.pathname + parsedDst.search + parsedDst.hash;
if (this._myUrl !== $.mobile.path.makeUrlAbsolute(toUrl)) {
// Going to a different page - close immediately
immediate = true;
} else {
theEvent.preventDefault();
}
}
// remove nav bindings
this.window.off(currentOptions.closeEvents);
// unbind click handlers added when history is disabled
this.element.undelegate(
currentOptions.closeLinkSelector,
currentOptions.closeLinkEvents,
);
this._close(immediate);
},
// any navigation event after a popup is opened should close the popup
// NOTE the pagebeforechange is bound to catch navigation events that don't
// alter the url (eg, dialogs from popups)
_bindContainerClose: function () {
this.window.on(this.options.closeEvents, $.proxy(this, "_closePopup"));
},
widget: function () {
return this._ui.container;
},
// TODO no clear deliniation of what should be here and
// what should be in _open. Seems to be "visual" vs "history" for now
open: function (options) {
var url,
hashkey,
activePage,
currentIsDialog,
hasHash,
urlHistory,
self = this,
currentOptions = this.options;
// make sure open is idempotent
if ($.mobile.popup.active || currentOptions.disabled) {
return this;
}
// set the global popup mutex
$.mobile.popup.active = this;
this._scrollTop = this.window.scrollTop();
// if history alteration is disabled close on navigate events
// and leave the url as is
if (!currentOptions.history) {
self._open(options);
self._bindContainerClose();
// When histoy is disabled we have to grab the data-rel
// back link clicks so we can close the popup instead of
// relying on history to do it for us
self.element.delegate(
currentOptions.closeLinkSelector,
currentOptions.closeLinkEvents,
function (theEvent) {
self.close();
theEvent.preventDefault();
},
);
return this;
}
// cache some values for min/readability
urlHistory = $.mobile.navigate.history;
hashkey = $.mobile.dialogHashKey;
activePage = $.mobile.activePage;
currentIsDialog = activePage ? activePage.hasClass("ui-dialog") : false;
this._myUrl = url = urlHistory.getActive().url;
hasHash =
url.indexOf(hashkey) > -1 &&
!currentIsDialog &&
urlHistory.activeIndex > 0;
if (hasHash) {
self._open(options);
self._bindContainerClose();
return this;
}
// if the current url has no dialog hash key proceed as normal
// otherwise, if the page is a dialog simply tack on the hash key
if (url.indexOf(hashkey) === -1 && !currentIsDialog) {
url = url + (url.indexOf("#") > -1 ? hashkey : "#" + hashkey);
} else {
url = $.mobile.path.parseLocation().hash + hashkey;
}
// Tack on an extra hashkey if this is the first page and we've just reconstructed the initial hash
if (urlHistory.activeIndex === 0 && url === urlHistory.initialDst) {
url += hashkey;
}
// swallow the the initial navigation event, and bind for the next
this.window.one("beforenavigate", function (theEvent) {
theEvent.preventDefault();
self._open(options);
self._bindContainerClose();
});
this.urlAltered = true;
$.mobile.navigate(url, { role: "dialog" });
return this;
},
close: function () {
// make sure close is idempotent
if ($.mobile.popup.active !== this) {
return this;
}
this._scrollTop = this.window.scrollTop();
if (this.options.history && this.urlAltered) {
$.mobile.back();
this.urlAltered = false;
} else {
// simulate the nav bindings having fired
this._closePopup();
}
return this;
},
});
// TODO this can be moved inside the widget
$.mobile.popup.handleLink = function ($link) {
var offset,
path = $.mobile.path,
// NOTE make sure to get only the hash from the href because ie7 (wp7)
// returns the absolute href in this case ruining the element selection
popup = $(
path.hashToSelector(path.parseUrl($link.attr("href")).hash),
).first();
if (popup.length > 0 && popup.data("mobile-popup")) {
offset = $link.offset();
popup.popup("open", {
x: offset.left + $link.outerWidth() / 2,
y: offset.top + $link.outerHeight() / 2,
transition: $link.jqmData("transition"),
positionTo: $link.jqmData("position-to"),
});
}
//remove after delay
setTimeout(function () {
$link.removeClass($.mobile.activeBtnClass);
}, 300);
};
// TODO move inside _create
$.mobile.document.on("pagebeforechange", function (theEvent, data) {
if (data.options.role === "popup") {
$.mobile.popup.handleLink(data.options.link);
theEvent.preventDefault();
}
});
})(jQuery);
/*
* custom "selectmenu" plugin
*/
(function ($, undefined) {
var unfocusableItemSelector =
".ui-disabled,.ui-state-disabled,.ui-li-divider,.ui-screen-hidden,:jqmData(role='placeholder')",
goToAdjacentItem = function (item, target, direction) {
var adjacent = item[direction + "All"]()
.not(unfocusableItemSelector)
.first();
// if there's a previous option, focus it
if (adjacent.length) {
target.blur().attr("tabindex", "-1");
adjacent.find("a").first().focus();
}
};
$.widget("mobile.selectmenu", $.mobile.selectmenu, {
_create: function () {
var o = this.options;
// Custom selects cannot exist inside popups, so revert the "nativeMenu"
// option to true if a parent is a popup
o.nativeMenu =
o.nativeMenu ||
this.element.parents(":jqmData(role='popup'),:mobile-popup").length >
0;
return this._super();
},
_handleSelectFocus: function () {
this.element.blur();
this.button.focus();
},
_handleKeydown: function (event) {
this._super(event);
this._handleButtonVclickKeydown(event);
},
_handleButtonVclickKeydown: function (event) {
if (this.options.disabled || this.isOpen) {
return;
}
if (
event.type === "vclick" ||
(event.keyCode &&
(event.keyCode === $.mobile.keyCode.ENTER ||
event.keyCode === $.mobile.keyCode.SPACE))
) {
this._decideFormat();
if (this.menuType === "overlay") {
this.button
.attr("href", "#" + this.popupId)
.attr("data-" + ($.mobile.ns || "") + "rel", "popup");
} else {
this.button
.attr("href", "#" + this.dialogId)
.attr("data-" + ($.mobile.ns || "") + "rel", "dialog");
}
this.isOpen = true;
// Do not prevent default, so the navigation may have a chance to actually open the chosen format
}
},
_handleListFocus: function (e) {
var params =
e.type === "focusin"
? { tabindex: "0", event: "vmouseover" }
: { tabindex: "-1", event: "vmouseout" };
$(e.target).attr("tabindex", params.tabindex).trigger(params.event);
},
_handleListKeydown: function (event) {
var target = $(event.target),
li = target.closest("li");
// switch logic based on which key was pressed
switch (event.keyCode) {
// up or left arrow keys
case 38:
goToAdjacentItem(li, target, "prev");
return false;
// down or right arrow keys
case 40:
goToAdjacentItem(li, target, "next");
return false;
// If enter or space is pressed, trigger click
case 13:
case 32:
target.trigger("click");
return false;
}
},
_handleMenuPageHide: function () {
// TODO centralize page removal binding / handling in the page plugin.
// Suggestion from @jblas to do refcounting
//
// TODO extremely confusing dependency on the open method where the pagehide.remove
// bindings are stripped to prevent the parent page from disappearing. The way
// we're keeping pages in the DOM right now sucks
//
// rebind the page remove that was unbound in the open function
// to allow for the parent page removal from actions other than the use
// of a dialog sized custom select
//
// doing this here provides for the back button on the custom select dialog
this.thisPage.page("bindRemove");
},
_handleHeaderCloseClick: function () {
if (this.menuType === "overlay") {
this.close();
return false;
}
},
build: function () {
var selectId,
popupId,
dialogId,
label,
thisPage,
isMultiple,
menuId,
themeAttr,
overlayTheme,
overlayThemeAttr,
dividerThemeAttr,
menuPage,
listbox,
list,
header,
headerTitle,
menuPageContent,
menuPageClose,
headerClose,
self,
o = this.options;
if (o.nativeMenu) {
return this._super();
}
self = this;
selectId = this.selectId;
popupId = selectId + "-listbox";
dialogId = selectId + "-dialog";
label = this.label;
thisPage = this.element.closest(".ui-page");
isMultiple = this.element[0].multiple;
menuId = selectId + "-menu";
themeAttr = o.theme
? " data-" + $.mobile.ns + "theme='" + o.theme + "'"
: "";
overlayTheme = o.overlayTheme || o.theme || null;
overlayThemeAttr = overlayTheme
? " data-" + $.mobile.ns + "overlay-theme='" + overlayTheme + "'"
: "";
dividerThemeAttr =
o.dividerTheme && isMultiple
? " data-" + $.mobile.ns + "divider-theme='" + o.dividerTheme + "'"
: "";
menuPage = $(
"<div data-" +
$.mobile.ns +
"role='dialog' class='ui-selectmenu' id='" +
dialogId +
"'" +
themeAttr +
overlayThemeAttr +
">" +
"<div data-" +
$.mobile.ns +
"role='header'>" +
"<div class='ui-title'>" +
label.getEncodedText() +
"</div>" +
"</div>" +
"<div data-" +
$.mobile.ns +
"role='content'></div>" +
"</div>",
);
listbox = $("<div id='" + popupId + "' class='ui-selectmenu'></div>")
.insertAfter(this.select)
.popup({ theme: o.overlayTheme });
list = $(
"<ul class='ui-selectmenu-list' id='" +
menuId +
"' role='listbox' aria-labelledby='" +
this.buttonId +
"'" +
themeAttr +
dividerThemeAttr +
"></ul>",
).appendTo(listbox);
header = $(
"<div class='ui-header ui-bar-" +
(o.theme ? o.theme : "inherit") +
"'></div>",
).prependTo(listbox);
headerTitle = $("<h1 class='ui-title'></h1>").appendTo(header);
if (this.isMultiple) {
headerClose = $("<a>", {
role: "button",
text: o.closeText,
href: "#",
class:
"ui-btn ui-corner-all ui-btn-left ui-btn-icon-notext ui-icon-delete",
}).appendTo(header);
}
$.extend(this, {
selectId: selectId,
menuId: menuId,
popupId: popupId,
dialogId: dialogId,
thisPage: thisPage,
menuPage: menuPage,
label: label,
isMultiple: isMultiple,
theme: o.theme,
listbox: listbox,
list: list,
header: header,
headerTitle: headerTitle,
headerClose: headerClose,
menuPageContent: menuPageContent,
menuPageClose: menuPageClose,
placeholder: "",
});
// Create list from select, update state
this.refresh();
if (this._origTabIndex === undefined) {
// Map undefined to false, because this._origTabIndex === undefined
// indicates that we have not yet checked whether the select has
// originally had a tabindex attribute, whereas false indicates that
// we have checked the select for such an attribute, and have found
// none present.
this._origTabIndex =
this.select[0].getAttribute("tabindex") === null
? false
: this.select.attr("tabindex");
}
this.select.attr("tabindex", "-1");
this._on(this.select, { focus: "_handleSelectFocus" });
// Button events
this._on(this.button, {
vclick: "_handleButtonVclickKeydown",
});
// Events for list items
this.list.attr("role", "listbox");
this._on(this.list, {
focusin: "_handleListFocus",
focusout: "_handleListFocus",
keydown: "_handleListKeydown",
});
this.list.delegate(
"li:not(.ui-disabled,.ui-state-disabled,.ui-li-divider)",
"click",
function (event) {
// index of option tag to be selected
var oldIndex = self.select[0].selectedIndex,
newIndex = $.mobile.getAttribute(this, "option-index"),
option = self._selectOptions().eq(newIndex)[0];
// toggle selected status on the tag for multi selects
option.selected = self.isMultiple ? !option.selected : true;
// toggle checkbox class for multiple selects
if (self.isMultiple) {
$(this)
.find("a")
.toggleClass("ui-checkbox-on", option.selected)
.toggleClass("ui-checkbox-off", !option.selected);
}
// trigger change if value changed
if (self.isMultiple || oldIndex !== newIndex) {
self.select.trigger("change");
}
// hide custom select for single selects only - otherwise focus clicked item
// We need to grab the clicked item the hard way, because the list may have been rebuilt
if (self.isMultiple) {
self.list
.find("li:not(.ui-li-divider)")
.eq(newIndex)
.find("a")
.first()
.focus();
} else {
self.close();
}
event.preventDefault();
},
);
// button refocus ensures proper height calculation
// by removing the inline style and ensuring page inclusion
this._on(this.menuPage, { pagehide: "_handleMenuPageHide" });
// Events on the popup
this._on(this.listbox, { popupafterclose: "close" });
// Close button on small overlays
if (this.isMultiple) {
this._on(this.headerClose, { click: "_handleHeaderCloseClick" });
}
return this;
},
_isRebuildRequired: function () {
var list = this.list.find("li"),
options = this._selectOptions().not(".ui-screen-hidden");
// TODO exceedingly naive method to determine difference
// ignores value changes etc in favor of a forcedRebuild
// from the user in the refresh method
return options.text() !== list.text();
},
selected: function () {
return this._selectOptions().filter(
":selected:not( :jqmData(placeholder='true') )",
);
},
refresh: function (force) {
var self, indices;
if (this.options.nativeMenu) {
return this._super(force);
}
self = this;
if (force || this._isRebuildRequired()) {
self._buildList();
}
indices = this.selectedIndices();
self.setButtonText();
self.setButtonCount();
self.list
.find("li:not(.ui-li-divider)")
.find("a")
.removeClass($.mobile.activeBtnClass)
.end()
.attr("aria-selected", false)
.each(function (i) {
if ($.inArray(i, indices) > -1) {
var item = $(this);
// Aria selected attr
item.attr("aria-selected", true);
// Multiple selects: add the "on" checkbox state to the icon
if (self.isMultiple) {
item
.find("a")
.removeClass("ui-checkbox-off")
.addClass("ui-checkbox-on");
} else {
if (item.hasClass("ui-screen-hidden")) {
item.next().find("a").addClass($.mobile.activeBtnClass);
} else {
item.find("a").addClass($.mobile.activeBtnClass);
}
}
}
});
},
close: function () {
if (this.options.disabled || !this.isOpen) {
return;
}
var self = this;
if (self.menuType === "page") {
self.menuPage.dialog("close");
self.list.appendTo(self.listbox);
} else {
self.listbox.popup("close");
}
self._focusButton();
// allow the dialog to be closed again
self.isOpen = false;
},
open: function () {
this.button.click();
},
_focusMenuItem: function () {
var selector = this.list.find("a." + $.mobile.activeBtnClass);
if (selector.length === 0) {
selector = this.list.find(
"li:not(" + unfocusableItemSelector + ") a.ui-btn",
);
}
selector.first().focus();
},
_decideFormat: function () {
var self = this,
$window = this.window,
selfListParent = self.list.parent(),
menuHeight = selfListParent.outerHeight(),
scrollTop = $window.scrollTop(),
btnOffset = self.button.offset().top,
screenHeight = $window.height();
if (menuHeight > screenHeight - 80 || !$.support.scrollTop) {
self.menuPage.appendTo($.mobile.pageContainer).page();
self.menuPageContent = self.menuPage.find(".ui-content");
self.menuPageClose = self.menuPage.find(".ui-header a");
// prevent the parent page from being removed from the DOM,
// otherwise the results of selecting a list item in the dialog
// fall into a black hole
self.thisPage.unbind("pagehide.remove");
//for WebOS/Opera Mini (set lastscroll using button offset)
if (scrollTop === 0 && btnOffset > screenHeight) {
self.thisPage.one("pagehide", function () {
$(this).jqmData("lastScroll", btnOffset);
});
}
self.menuPage.one({
pageshow: $.proxy(this, "_focusMenuItem"),
pagehide: $.proxy(this, "close"),
});
self.menuType = "page";
self.menuPageContent.append(self.list);
self.menuPage.find("div .ui-title").text(self.label.text());
} else {
self.menuType = "overlay";
self.listbox.one({ popupafteropen: $.proxy(this, "_focusMenuItem") });
}
},
_buildList: function () {
var self = this,
o = this.options,
placeholder = this.placeholder,
needPlaceholder = true,
dataIcon = "false",
$options,
numOptions,
select,
dataPrefix = "data-" + $.mobile.ns,
dataIndexAttr = dataPrefix + "option-index",
dataIconAttr = dataPrefix + "icon",
dataRoleAttr = dataPrefix + "role",
dataPlaceholderAttr = dataPrefix + "placeholder",
fragment = document.createDocumentFragment(),
isPlaceholderItem = false,
optGroup,
i,
option,
$option,
parent,
text,
anchor,
classes,
optLabel,
divider,
item;
self.list.empty().filter(".ui-listview").listview("destroy");
$options = this._selectOptions();
numOptions = $options.length;
select = this.select[0];
for (i = 0; i < numOptions; i++, isPlaceholderItem = false) {
option = $options[i];
$option = $(option);
// Do not create options based on ui-screen-hidden select options
if ($option.hasClass("ui-screen-hidden")) {
continue;
}
parent = option.parentNode;
text = $option.text();
anchor = document.createElement("a");
classes = [];
anchor.setAttribute("href", "#");
anchor.appendChild(document.createTextNode(text));
// Are we inside an optgroup?
if (
parent !== select &&
parent.nodeName.toLowerCase() === "optgroup"
) {
optLabel = parent.getAttribute("label");
if (optLabel !== optGroup) {
divider = document.createElement("li");
divider.setAttribute(dataRoleAttr, "list-divider");
divider.setAttribute("role", "option");
divider.setAttribute("tabindex", "-1");
divider.appendChild(document.createTextNode(optLabel));
fragment.appendChild(divider);
optGroup = optLabel;
}
}
if (
needPlaceholder &&
(!option.getAttribute("value") ||
text.length === 0 ||
$option.jqmData("placeholder"))
) {
needPlaceholder = false;
isPlaceholderItem = true;
// If we have identified a placeholder, record the fact that it was
// us who have added the placeholder to the option and mark it
// retroactively in the select as well
if (null === option.getAttribute(dataPlaceholderAttr)) {
this._removePlaceholderAttr = true;
}
option.setAttribute(dataPlaceholderAttr, true);
if (o.hidePlaceholderMenuItems) {
classes.push("ui-screen-hidden");
}
if (placeholder !== text) {
placeholder = self.placeholder = text;
}
}
item = document.createElement("li");
if (option.disabled) {
classes.push("ui-state-disabled");
item.setAttribute("aria-disabled", true);
}
item.setAttribute(dataIndexAttr, i);
item.setAttribute(dataIconAttr, dataIcon);
if (isPlaceholderItem) {
item.setAttribute(dataPlaceholderAttr, true);
}
item.className = classes.join(" ");
item.setAttribute("role", "option");
anchor.setAttribute("tabindex", "-1");
if (this.isMultiple) {
$(anchor).addClass("ui-btn ui-checkbox-off ui-btn-icon-right");
}
item.appendChild(anchor);
fragment.appendChild(item);
}
self.list[0].appendChild(fragment);
// Hide header if it's not a multiselect and there's no placeholder
if (!this.isMultiple && !placeholder.length) {
this.header.addClass("ui-screen-hidden");
} else {
this.headerTitle.text(this.placeholder);
}
// Now populated, create listview
self.list.listview();
},
_button: function () {
return this.options.nativeMenu
? this._super()
: $("<a>", {
href: "#",
role: "button",
// TODO value is undefined at creation
id: this.buttonId,
"aria-haspopup": "true",
// TODO value is undefined at creation
"aria-owns": this.menuId,
});
},
_destroy: function () {
if (!this.options.nativeMenu) {
this.close();
// Restore the tabindex attribute to its original value
if (this._origTabIndex !== undefined) {
if (this._origTabIndex !== false) {
this.select.attr("tabindex", this._origTabIndex);
} else {
this.select.removeAttr("tabindex");
}
}
// Remove the placeholder attribute if we were the ones to add it
if (this._removePlaceholderAttr) {
this._selectOptions().removeAttr(
"data-" + $.mobile.ns + "placeholder",
);
}
// Remove the popup
this.listbox.remove();
// Remove the dialog
this.menuPage.remove();
}
// Chain up
this._super();
},
});
})(jQuery);
// buttonMarkup is deprecated as of 1.4.0 and will be removed in 1.5.0.
(function ($, undefined) {
// General policy: Do not access data-* attributes except during enhancement.
// In all other cases we determine the state of the button exclusively from its
// className. That's why optionsToClasses expects a full complement of options,
// and the jQuery plugin completes the set of options from the default values.
// Map classes to buttonMarkup boolean options - used in classNameToOptions()
var reverseBoolOptionMap = {
"ui-shadow": "shadow",
"ui-corner-all": "corners",
"ui-btn-inline": "inline",
"ui-shadow-icon": "iconshadow" /* TODO: Remove in 1.5 */,
"ui-mini": "mini",
},
getAttrFixed = function () {
var ret = $.mobile.getAttribute.apply(this, arguments);
return ret == null ? undefined : ret;
},
capitalLettersRE = /[A-Z]/g;
// optionsToClasses:
// @options: A complete set of options to convert to class names.
// @existingClasses: extra classes to add to the result
//
// Converts @options to buttonMarkup classes and returns the result as an array
// that can be converted to an element's className with .join( " " ). All
// possible options must be set inside @options. Use $.fn.buttonMarkup.defaults
// to get a complete set and use $.extend to override your choice of options
// from that set.
function optionsToClasses(options, existingClasses) {
var classes = existingClasses ? existingClasses : [];
// Add classes to the array - first ui-btn
classes.push("ui-btn");
// If there is a theme
if (options.theme) {
classes.push("ui-btn-" + options.theme);
}
// If there's an icon, add the icon-related classes
if (options.icon) {
classes = classes.concat([
"ui-icon-" + options.icon,
"ui-btn-icon-" + options.iconpos,
]);
if (options.iconshadow) {
classes.push("ui-shadow-icon"); /* TODO: Remove in 1.5 */
}
}
// Add the appropriate class for each boolean option
if (options.inline) {
classes.push("ui-btn-inline");
}
if (options.shadow) {
classes.push("ui-shadow");
}
if (options.corners) {
classes.push("ui-corner-all");
}
if (options.mini) {
classes.push("ui-mini");
}
// Create a string from the array and return it
return classes;
}
// classNameToOptions:
// @classes: A string containing a .className-style space-separated class list
//
// Loops over @classes and calculates an options object based on the
// buttonMarkup-related classes it finds. It records unrecognized classes in an
// array.
//
// Returns: An object containing the following items:
//
// "options": buttonMarkup options found to be present because of the
// presence/absence of corresponding classes
//
// "unknownClasses": a string containing all the non-buttonMarkup-related
// classes found in @classes
//
// "alreadyEnhanced": A boolean indicating whether the ui-btn class was among
// those found to be present
function classNameToOptions(classes) {
var idx,
map,
unknownClass,
alreadyEnhanced = false,
noIcon = true,
o = {
icon: "",
inline: false,
shadow: false,
corners: false,
iconshadow: false,
mini: false,
},
unknownClasses = [];
classes = classes.split(" ");
// Loop over the classes
for (idx = 0; idx < classes.length; idx++) {
// Assume it's an unrecognized class
unknownClass = true;
// Recognize boolean options from the presence of classes
map = reverseBoolOptionMap[classes[idx]];
if (map !== undefined) {
unknownClass = false;
o[map] = true;
// Recognize the presence of an icon and establish the icon position
} else if (classes[idx].indexOf("ui-btn-icon-") === 0) {
unknownClass = false;
noIcon = false;
o.iconpos = classes[idx].substring(12);
// Establish which icon is present
} else if (classes[idx].indexOf("ui-icon-") === 0) {
unknownClass = false;
o.icon = classes[idx].substring(8);
// Establish the theme - this recognizes one-letter theme swatch names
} else if (
classes[idx].indexOf("ui-btn-") === 0 &&
classes[idx].length === 8
) {
unknownClass = false;
o.theme = classes[idx].substring(7);
// Recognize that this element has already been buttonMarkup-enhanced
} else if (classes[idx] === "ui-btn") {
unknownClass = false;
alreadyEnhanced = true;
}
// If this class has not been recognized, add it to the list
if (unknownClass) {
unknownClasses.push(classes[idx]);
}
}
// If a "ui-btn-icon-*" icon position class is absent there cannot be an icon
if (noIcon) {
o.icon = "";
}
return {
options: o,
unknownClasses: unknownClasses,
alreadyEnhanced: alreadyEnhanced,
};
}
function camelCase2Hyphenated(c) {
return "-" + c.toLowerCase();
}
// $.fn.buttonMarkup:
// DOM: gets/sets .className
//
// @options: options to apply to the elements in the jQuery object
// @overwriteClasses: boolean indicating whether to honour existing classes
//
// Calculates the classes to apply to the elements in the jQuery object based on
// the options passed in. If @overwriteClasses is true, it sets the className
// property of each element in the jQuery object to the buttonMarkup classes
// it calculates based on the options passed in.
//
// If you wish to preserve any classes that are already present on the elements
// inside the jQuery object, including buttonMarkup-related classes that were
// added by a previous call to $.fn.buttonMarkup() or during page enhancement
// then you should omit @overwriteClasses or set it to false.
$.fn.buttonMarkup = function (options, overwriteClasses) {
var idx,
data,
el,
retrievedOptions,
optionKey,
defaults = $.fn.buttonMarkup.defaults;
for (idx = 0; idx < this.length; idx++) {
el = this[idx];
data = overwriteClasses
? // Assume this element is not enhanced and ignore its classes
{ alreadyEnhanced: false, unknownClasses: [] }
: // Otherwise analyze existing classes to establish existing options and
// classes
classNameToOptions(el.className);
retrievedOptions = $.extend(
{},
// If the element already has the class ui-btn, then we assume that
// it has passed through buttonMarkup before - otherwise, the options
// returned by classNameToOptions do not correctly reflect the state of
// the element
data.alreadyEnhanced ? data.options : {},
// Finally, apply the options passed in
options,
);
// If this is the first call on this element, retrieve remaining options
// from the data-attributes
if (!data.alreadyEnhanced) {
for (optionKey in defaults) {
if (retrievedOptions[optionKey] === undefined) {
retrievedOptions[optionKey] = getAttrFixed(
el,
optionKey.replace(capitalLettersRE, camelCase2Hyphenated),
);
}
}
}
el.className = optionsToClasses(
// Merge all the options and apply them as classes
$.extend(
{},
// The defaults form the basis
defaults,
// Add the computed options
retrievedOptions,
),
// ... and re-apply any unrecognized classes that were found
data.unknownClasses,
).join(" ");
if (el.tagName.toLowerCase() !== "button") {
el.setAttribute("role", "button");
}
}
return this;
};
// buttonMarkup defaults. This must be a complete set, i.e., a value must be
// given here for all recognized options
$.fn.buttonMarkup.defaults = {
icon: "",
iconpos: "left",
theme: null,
inline: false,
shadow: true,
corners: true,
iconshadow: false /* TODO: Remove in 1.5. Option deprecated in 1.4. */,
mini: false,
};
$.extend($.fn.buttonMarkup, {
initSelector:
"a:jqmData(role='button'), .ui-bar > a, .ui-bar > :jqmData(role='controlgroup') > a, button",
});
})(jQuery);
(function ($, undefined) {
$.widget(
"mobile.controlgroup",
$.extend(
{
options: {
enhanced: false,
theme: null,
shadow: false,
corners: true,
excludeInvisible: true,
type: "vertical",
mini: false,
},
_create: function () {
var elem = this.element,
opts = this.options;
// Run buttonmarkup
if ($.fn.buttonMarkup) {
this.element.find($.fn.buttonMarkup.initSelector).buttonMarkup();
}
// Enhance child widgets
$.each(
this._childWidgets,
$.proxy(function (number, widgetName) {
if ($.mobile[widgetName]) {
this.element
.find($.mobile[widgetName].initSelector)
.not($.mobile.page.prototype.keepNativeSelector())
[widgetName]();
}
}, this),
);
$.extend(this, {
_ui: null,
_initialRefresh: true,
});
if (opts.enhanced) {
this._ui = {
groupLegend: elem.children(".ui-controlgroup-label").children(),
childWrapper: elem.children(".ui-controlgroup-controls"),
};
} else {
this._ui = this._enhance();
}
},
_childWidgets: ["checkboxradio", "selectmenu", "button"],
_themeClassFromOption: function (value) {
return value
? value === "none"
? ""
: "ui-group-theme-" + value
: "";
},
_enhance: function () {
var elem = this.element,
opts = this.options,
ui = {
groupLegend: elem.children("legend"),
childWrapper: elem
.addClass(
"ui-controlgroup " +
"ui-controlgroup-" +
(opts.type === "horizontal" ? "horizontal" : "vertical") +
" " +
this._themeClassFromOption(opts.theme) +
" " +
(opts.corners ? "ui-corner-all " : "") +
(opts.mini ? "ui-mini " : ""),
)
.wrapInner(
"<div " +
"class='ui-controlgroup-controls " +
(opts.shadow === true ? "ui-shadow" : "") +
"'></div>",
)
.children(),
};
if (ui.groupLegend.length > 0) {
$("<div role='heading' class='ui-controlgroup-label'></div>")
.append(ui.groupLegend)
.prependTo(elem);
}
return ui;
},
_init: function () {
this.refresh();
},
_setOptions: function (options) {
var callRefresh,
returnValue,
elem = this.element;
// Must have one of horizontal or vertical
if (options.type !== undefined) {
elem
.removeClass(
"ui-controlgroup-horizontal ui-controlgroup-vertical",
)
.addClass(
"ui-controlgroup-" +
(options.type === "horizontal" ? "horizontal" : "vertical"),
);
callRefresh = true;
}
if (options.theme !== undefined) {
elem
.removeClass(this._themeClassFromOption(this.options.theme))
.addClass(this._themeClassFromOption(options.theme));
}
if (options.corners !== undefined) {
elem.toggleClass("ui-corner-all", options.corners);
}
if (options.mini !== undefined) {
elem.toggleClass("ui-mini", options.mini);
}
if (options.shadow !== undefined) {
this._ui.childWrapper.toggleClass("ui-shadow", options.shadow);
}
if (options.excludeInvisible !== undefined) {
this.options.excludeInvisible = options.excludeInvisible;
callRefresh = true;
}
returnValue = this._super(options);
if (callRefresh) {
this.refresh();
}
return returnValue;
},
container: function () {
return this._ui.childWrapper;
},
refresh: function () {
var $el = this.container(),
els = $el.find(".ui-btn").not(".ui-slider-handle"),
create = this._initialRefresh;
if ($.mobile.checkboxradio) {
$el.find(":mobile-checkboxradio").checkboxradio("refresh");
}
this._addFirstLastClasses(
els,
this.options.excludeInvisible
? this._getVisibles(els, create)
: els,
create,
);
this._initialRefresh = false;
},
// Caveat: If the legend is not the first child of the controlgroup at enhance
// time, it will be after _destroy().
_destroy: function () {
var ui,
buttons,
opts = this.options;
if (opts.enhanced) {
return this;
}
ui = this._ui;
buttons = this.element
.removeClass(
"ui-controlgroup " +
"ui-controlgroup-horizontal ui-controlgroup-vertical ui-corner-all ui-mini " +
this._themeClassFromOption(opts.theme),
)
.find(".ui-btn")
.not(".ui-slider-handle");
this._removeFirstLastClasses(buttons);
ui.groupLegend.unwrap();
ui.childWrapper.children().unwrap();
},
},
$.mobile.behaviors.addFirstLastClasses,
),
);
})(jQuery);
(function ($, undefined) {
$.widget("mobile.toolbar", {
initSelector: ":jqmData(role='footer'), :jqmData(role='header')",
options: {
theme: null,
addBackBtn: false,
backBtnTheme: null,
backBtnText: "Back",
},
_create: function () {
var leftbtn,
rightbtn,
role = this.element.is(":jqmData(role='header')")
? "header"
: "footer",
page = this.element.closest(".ui-page");
if (page.length === 0) {
page = false;
this._on(this.document, {
pageshow: "refresh",
});
}
$.extend(this, {
role: role,
page: page,
leftbtn: leftbtn,
rightbtn: rightbtn,
});
this.element
.attr("role", role === "header" ? "banner" : "contentinfo")
.addClass("ui-" + role);
this.refresh();
this._setOptions(this.options);
},
_setOptions: function (o) {
if (o.addBackBtn !== undefined) {
if (
this.options.addBackBtn &&
this.role === "header" &&
$(".ui-page").length > 1 &&
this.page[0].getAttribute("data-" + $.mobile.ns + "url") !==
$.mobile.path.stripHash(location.hash) &&
!this.leftbtn
) {
this._addBackButton();
} else {
this.element.find(".ui-toolbar-back-btn").remove();
}
}
if (o.backBtnTheme != null) {
this.element
.find(".ui-toolbar-back-btn")
.addClass("ui-btn ui-btn-" + o.backBtnTheme);
}
if (o.backBtnText !== undefined) {
this.element
.find(".ui-toolbar-back-btn .ui-btn-text")
.text(o.backBtnText);
}
if (o.theme !== undefined) {
var currentTheme = this.options.theme
? this.options.theme
: "inherit",
newTheme = o.theme ? o.theme : "inherit";
this.element
.removeClass("ui-bar-" + currentTheme)
.addClass("ui-bar-" + newTheme);
}
this._super(o);
},
refresh: function () {
if (this.role === "header") {
this._addHeaderButtonClasses();
}
if (!this.page) {
this._setRelative();
if (this.role === "footer") {
this.element.appendTo("body");
}
}
this._addHeadingClasses();
this._btnMarkup();
},
//we only want this to run on non fixed toolbars so make it easy to override
_setRelative: function () {
$("[data-" + $.mobile.ns + "role='page']").css({
position: "relative",
});
},
// Deprecated in 1.4. As from 1.5 button classes have to be present in the markup.
_btnMarkup: function () {
this.element
.children("a")
.filter(":not([data-" + $.mobile.ns + "role='none'])")
.attr("data-" + $.mobile.ns + "role", "button");
this.element.trigger("create");
},
// Deprecated in 1.4. As from 1.5 ui-btn-left/right classes have to be present in the markup.
_addHeaderButtonClasses: function () {
var $headeranchors = this.element.children("a, button");
this.leftbtn = $headeranchors.hasClass("ui-btn-left");
this.rightbtn = $headeranchors.hasClass("ui-btn-right");
this.leftbtn =
this.leftbtn ||
$headeranchors.eq(0).not(".ui-btn-right").addClass("ui-btn-left")
.length;
this.rightbtn =
this.rightbtn || $headeranchors.eq(1).addClass("ui-btn-right").length;
},
_addBackButton: function () {
var options = this.options,
theme = options.backBtnTheme || options.theme;
$(
"<a role='button' href='javascript:void(0);' " +
"class='ui-btn ui-corner-all ui-shadow ui-btn-left " +
(theme ? "ui-btn-" + theme + " " : "") +
"ui-toolbar-back-btn ui-icon-carat-l ui-btn-icon-left' " +
"data-" +
$.mobile.ns +
"rel='back'>" +
options.backBtnText +
"</a>",
).prependTo(this.element);
},
_addHeadingClasses: function () {
this.element
.children("h1, h2, h3, h4, h5, h6")
.addClass("ui-title")
// Regardless of h element number in src, it becomes h1 for the enhanced page
.attr({
role: "heading",
"aria-level": "1",
});
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.toolbar", $.mobile.toolbar, {
options: {
position: null,
visibleOnPageShow: true,
disablePageZoom: true,
transition: "slide", //can be none, fade, slide (slide maps to slideup or slidedown)
fullscreen: false,
tapToggle: true,
tapToggleBlacklist:
"a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed, .ui-flipswitch, .ui-popup, .ui-panel, .ui-panel-dismiss-open",
hideDuringFocus: "input, textarea, select",
updatePagePadding: true,
trackPersistentToolbars: true,
// Browser detection! Weeee, here we go...
// Unfortunately, position:fixed is costly, not to mention probably impossible, to feature-detect accurately.
// Some tests exist, but they currently return false results in critical devices and browsers, which could lead to a broken experience.
// Testing fixed positioning is also pretty obtrusive to page load, requiring injected elements and scrolling the window
// The following function serves to rule out some popular browsers with known fixed-positioning issues
// This is a plugin option like any other, so feel free to improve or overwrite it
supportBlacklist: function () {
return !$.support.fixedPosition;
},
},
_create: function () {
this._super();
if (
this.options.position === "fixed" &&
!this.options.supportBlacklist()
) {
this._makeFixed();
}
},
_makeFixed: function () {
this.element.addClass("ui-" + this.role + "-fixed");
this.updatePagePadding();
this._addTransitionClass();
this._bindPageEvents();
this._bindToggleHandlers();
},
_setOptions: function (o) {
if (o.position === "fixed" && this.options.position !== "fixed") {
this._makeFixed();
}
if (
this.options.position === "fixed" &&
!this.options.supportBlacklist()
) {
var $page = !!this.page
? this.page
: $(".ui-page-active").length > 0
? $(".ui-page-active")
: $(".ui-page").eq(0);
if (o.fullscreen !== undefined) {
if (o.fullscreen) {
this.element.addClass("ui-" + this.role + "-fullscreen");
$page.addClass("ui-page-" + this.role + "-fullscreen");
}
// If not fullscreen, add class to page to set top or bottom padding
else {
this.element.removeClass("ui-" + this.role + "-fullscreen");
$page
.removeClass("ui-page-" + this.role + "-fullscreen")
.addClass("ui-page-" + this.role + "-fixed");
}
}
}
this._super(o);
},
_addTransitionClass: function () {
var tclass = this.options.transition;
if (tclass && tclass !== "none") {
// use appropriate slide for header or footer
if (tclass === "slide") {
tclass = this.element.hasClass("ui-header")
? "slidedown"
: "slideup";
}
this.element.addClass(tclass);
}
},
_bindPageEvents: function () {
var page = !!this.page
? this.element.closest(".ui-page")
: this.document;
//page event bindings
// Fixed toolbars require page zoom to be disabled, otherwise usability issues crop up
// This method is meant to disable zoom while a fixed-positioned toolbar page is visible
this._on(page, {
pagebeforeshow: "_handlePageBeforeShow",
webkitAnimationStart: "_handleAnimationStart",
animationstart: "_handleAnimationStart",
updatelayout: "_handleAnimationStart",
pageshow: "_handlePageShow",
pagebeforehide: "_handlePageBeforeHide",
});
},
_handlePageBeforeShow: function () {
var o = this.options;
if (o.disablePageZoom) {
$.mobile.zoom.disable(true);
}
if (!o.visibleOnPageShow) {
this.hide(true);
}
},
_handleAnimationStart: function () {
if (this.options.updatePagePadding) {
this.updatePagePadding(!!this.page ? this.page : ".ui-page-active");
}
},
_handlePageShow: function () {
this.updatePagePadding(!!this.page ? this.page : ".ui-page-active");
if (this.options.updatePagePadding) {
this._on(this.window, { throttledresize: "updatePagePadding" });
}
},
_handlePageBeforeHide: function (e, ui) {
var o = this.options,
thisFooter,
thisHeader,
nextFooter,
nextHeader;
if (o.disablePageZoom) {
$.mobile.zoom.enable(true);
}
if (o.updatePagePadding) {
this._off(this.window, "throttledresize");
}
if (o.trackPersistentToolbars) {
thisFooter = $(".ui-footer-fixed:jqmData(id)", this.page);
thisHeader = $(".ui-header-fixed:jqmData(id)", this.page);
nextFooter =
(thisFooter.length &&
ui.nextPage &&
$(
".ui-footer-fixed:jqmData(id='" +
thisFooter.jqmData("id") +
"')",
ui.nextPage,
)) ||
$();
nextHeader =
(thisHeader.length &&
ui.nextPage &&
$(
".ui-header-fixed:jqmData(id='" +
thisHeader.jqmData("id") +
"')",
ui.nextPage,
)) ||
$();
if (nextFooter.length || nextHeader.length) {
nextFooter.add(nextHeader).appendTo($.mobile.pageContainer);
ui.nextPage.one("pageshow", function () {
nextHeader.prependTo(this);
nextFooter.appendTo(this);
});
}
}
},
_visible: true,
// This will set the content element's top or bottom padding equal to the toolbar's height
updatePagePadding: function (tbPage) {
var $el = this.element,
header = this.role === "header",
pos = parseFloat($el.css(header ? "top" : "bottom"));
// This behavior only applies to "fixed", not "fullscreen"
if (this.options.fullscreen) {
return;
}
// tbPage argument can be a Page object or an event, if coming from throttled resize.
tbPage =
(tbPage && tbPage.type === undefined && tbPage) ||
this.page ||
$el.closest(".ui-page");
tbPage = !!this.page ? this.page : ".ui-page-active";
$(tbPage).css(
"padding-" + (header ? "top" : "bottom"),
$el.outerHeight() + pos,
);
},
_useTransition: function (notransition) {
var $win = this.window,
$el = this.element,
scroll = $win.scrollTop(),
elHeight = $el.height(),
pHeight = !!this.page
? $el.closest(".ui-page").height()
: $(".ui-page-active").height(),
viewportHeight = $.mobile.getScreenHeight();
return (
!notransition &&
((this.options.transition &&
this.options.transition !== "none" &&
((this.role === "header" &&
!this.options.fullscreen &&
scroll > elHeight) ||
(this.role === "footer" &&
!this.options.fullscreen &&
scroll + viewportHeight < pHeight - elHeight))) ||
this.options.fullscreen)
);
},
show: function (notransition) {
var hideClass = "ui-fixed-hidden",
$el = this.element;
if (this._useTransition(notransition)) {
$el
.removeClass("out " + hideClass)
.addClass("in")
.animationComplete(function () {
$el.removeClass("in");
});
} else {
$el.removeClass(hideClass);
}
this._visible = true;
},
hide: function (notransition) {
var hideClass = "ui-fixed-hidden",
$el = this.element,
// if it's a slide transition, our new transitions need the reverse class as well to slide outward
outclass =
"out" + (this.options.transition === "slide" ? " reverse" : "");
if (this._useTransition(notransition)) {
$el
.addClass(outclass)
.removeClass("in")
.animationComplete(function () {
$el.addClass(hideClass).removeClass(outclass);
});
} else {
$el.addClass(hideClass).removeClass(outclass);
}
this._visible = false;
},
toggle: function () {
this[this._visible ? "hide" : "show"]();
},
_bindToggleHandlers: function () {
var self = this,
o = self.options,
delayShow,
delayHide,
isVisible = true,
page = !!this.page ? this.page : $(".ui-page");
// tap toggle
page
.bind("vclick", function (e) {
if (
o.tapToggle &&
!$(e.target).closest(o.tapToggleBlacklist).length
) {
self.toggle();
}
})
.bind("focusin focusout", function (e) {
//this hides the toolbars on a keyboard pop to give more screen room and prevent ios bug which
//positions fixed toolbars in the middle of the screen on pop if the input is near the top or
//bottom of the screen addresses issues #4410 Footer navbar moves up when clicking on a textbox in an Android environment
//and issue #4113 Header and footer change their position after keyboard popup - iOS
//and issue #4410 Footer navbar moves up when clicking on a textbox in an Android environment
if (
screen.width < 1025 &&
$(e.target).is(o.hideDuringFocus) &&
!$(e.target).closest(".ui-header-fixed, .ui-footer-fixed").length
) {
//Fix for issue #4724 Moving through form in Mobile Safari with "Next" and "Previous" system
//controls causes fixed position, tap-toggle false Header to reveal itself
// isVisible instead of self._visible because the focusin and focusout events fire twice at the same time
// Also use a delay for hiding the toolbars because on Android native browser focusin is direclty followed
// by a focusout when a native selects opens and the other way around when it closes.
if (e.type === "focusout" && !isVisible) {
isVisible = true;
//wait for the stack to unwind and see if we have jumped to another input
clearTimeout(delayHide);
delayShow = setTimeout(function () {
self.show();
}, 0);
} else if (e.type === "focusin" && !!isVisible) {
//if we have jumped to another input clear the time out to cancel the show.
clearTimeout(delayShow);
isVisible = false;
delayHide = setTimeout(function () {
self.hide();
}, 0);
}
}
});
},
_setRelative: function () {
if (this.options.position !== "fixed") {
$("[data-" + $.mobile.ns + "role='page']").css({
position: "relative",
});
}
},
_destroy: function () {
var $el = this.element,
header = $el.hasClass("ui-header");
$el
.closest(".ui-page")
.css("padding-" + (header ? "top" : "bottom"), "");
$el.removeClass(
"ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden",
);
$el
.closest(".ui-page")
.removeClass(
"ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen",
);
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.toolbar", $.mobile.toolbar, {
_makeFixed: function () {
this._super();
this._workarounds();
},
//check the browser and version and run needed workarounds
_workarounds: function () {
var ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match(/AppleWebKit\/([0-9]+)/),
wkversion = !!wkmatch && wkmatch[1],
os = null,
self = this;
//set the os we are working in if it dosent match one with workarounds return
if (
platform.indexOf("iPhone") > -1 ||
platform.indexOf("iPad") > -1 ||
platform.indexOf("iPod") > -1
) {
os = "ios";
} else if (ua.indexOf("Android") > -1) {
os = "android";
} else {
return;
}
//check os version if it dosent match one with workarounds return
if (os === "ios") {
//iOS workarounds
self._bindScrollWorkaround();
} else if (os === "android" && wkversion && wkversion < 534) {
//Android 2.3 run all Android 2.3 workaround
self._bindScrollWorkaround();
self._bindListThumbWorkaround();
} else {
return;
}
},
//Utility class for checking header and footer positions relative to viewport
_viewportOffset: function () {
var $el = this.element,
header = $el.hasClass("ui-header"),
offset = Math.abs($el.offset().top - this.window.scrollTop());
if (!header) {
offset =
Math.round(offset - this.window.height() + $el.outerHeight()) - 60;
}
return offset;
},
//bind events for _triggerRedraw() function
_bindScrollWorkaround: function () {
var self = this;
//bind to scrollstop and check if the toolbars are correctly positioned
this._on(this.window, {
scrollstop: function () {
var viewportOffset = self._viewportOffset();
//check if the header is visible and if its in the right place
if (viewportOffset > 2 && self._visible) {
self._triggerRedraw();
}
},
});
},
//this addresses issue #4250 Persistent footer instability in v1.1 with long select lists in Android 2.3.3
//and issue #3748 Android 2.x: Page transitions broken when fixed toolbars used
//the absolutely positioned thumbnail in a list view causes problems with fixed position buttons above in a nav bar
//setting the li's to -webkit-transform:translate3d(0,0,0); solves this problem to avoide potential issues in other
//platforms we scope this with the class ui-android-2x-fix
_bindListThumbWorkaround: function () {
this.element.closest(".ui-page").addClass("ui-android-2x-fixed");
},
//this addresses issues #4337 Fixed header problem after scrolling content on iOS and Android
//and device bugs project issue #1 Form elements can lose click hit area in position: fixed containers.
//this also addresses not on fixed toolbars page in docs
//adding 1px of padding to the bottom then removing it causes a "redraw"
//which positions the toolbars correctly (they will always be visually correct)
_triggerRedraw: function () {
var paddingBottom = parseFloat(
$(".ui-page-active").css("padding-bottom"),
);
//trigger page redraw to fix incorrectly positioned fixed elements
$(".ui-page-active").css("padding-bottom", paddingBottom + 1 + "px");
//if the padding is reset with out a timeout the reposition will not occure.
//this is independant of JQM the browser seems to need the time to react.
setTimeout(function () {
$(".ui-page-active").css("padding-bottom", paddingBottom + "px");
}, 0);
},
destroy: function () {
this._super();
//Remove the class we added to the page previously in android 2.x
this.element
.closest(".ui-page-active")
.removeClass("ui-android-2x-fix");
},
});
})(jQuery);
(function ($, undefined) {
var ieHack = $.mobile.browser.oldIE && $.mobile.browser.oldIE <= 8,
uiTemplate = $(
"<div class='ui-popup-arrow-guide'></div>" +
"<div class='ui-popup-arrow-container" +
(ieHack ? " ie" : "") +
"'>" +
"<div class='ui-popup-arrow'></div>" +
"</div>",
);
function getArrow() {
var clone = uiTemplate.clone(),
gd = clone.eq(0),
ct = clone.eq(1),
ar = ct.children();
return { arEls: ct.add(gd), gd: gd, ct: ct, ar: ar };
}
$.widget("mobile.popup", $.mobile.popup, {
options: {
arrow: "",
},
_create: function () {
var ar,
ret = this._super();
if (this.options.arrow) {
this._ui.arrow = ar = this._addArrow();
}
return ret;
},
_addArrow: function () {
var theme,
opts = this.options,
ar = getArrow();
theme = this._themeClassFromOption("ui-body-", opts.theme);
ar.ar.addClass(theme + (opts.shadow ? " ui-overlay-shadow" : ""));
ar.arEls.hide().appendTo(this.element);
return ar;
},
_unenhance: function () {
var ar = this._ui.arrow;
if (ar) {
ar.arEls.remove();
}
return this._super();
},
// Pretend to show an arrow described by @p and @dir and calculate the
// distance from the desired point. If a best-distance is passed in, return
// the minimum of the one passed in and the one calculated.
_tryAnArrow: function (p, dir, desired, s, best) {
var result,
r,
diff,
desiredForArrow = {},
tip = {};
// If the arrow has no wiggle room along the edge of the popup, it cannot
// be displayed along the requested edge without it sticking out.
if (s.arFull[p.dimKey] > s.guideDims[p.dimKey]) {
return best;
}
desiredForArrow[p.fst] =
desired[p.fst] +
(s.arHalf[p.oDimKey] + s.menuHalf[p.oDimKey]) * p.offsetFactor -
s.contentBox[p.fst] +
(s.clampInfo.menuSize[p.oDimKey] - s.contentBox[p.oDimKey]) *
p.arrowOffsetFactor;
desiredForArrow[p.snd] = desired[p.snd];
result =
s.result ||
this._calculateFinalLocation(desiredForArrow, s.clampInfo);
r = { x: result.left, y: result.top };
tip[p.fst] = r[p.fst] + s.contentBox[p.fst] + p.tipOffset;
tip[p.snd] = Math.max(
result[p.prop] + s.guideOffset[p.prop] + s.arHalf[p.dimKey],
Math.min(
result[p.prop] +
s.guideOffset[p.prop] +
s.guideDims[p.dimKey] -
s.arHalf[p.dimKey],
desired[p.snd],
),
);
diff = Math.abs(desired.x - tip.x) + Math.abs(desired.y - tip.y);
if (!best || diff < best.diff) {
// Convert tip offset to coordinates inside the popup
tip[p.snd] -=
s.arHalf[p.dimKey] + result[p.prop] + s.contentBox[p.snd];
best = {
dir: dir,
diff: diff,
result: result,
posProp: p.prop,
posVal: tip[p.snd],
};
}
return best;
},
_getPlacementState: function (clamp) {
var offset,
gdOffset,
ar = this._ui.arrow,
state = {
clampInfo: this._clampPopupWidth(!clamp),
arFull: { cx: ar.ct.width(), cy: ar.ct.height() },
guideDims: { cx: ar.gd.width(), cy: ar.gd.height() },
guideOffset: ar.gd.offset(),
};
offset = this.element.offset();
ar.gd.css({ left: 0, top: 0, right: 0, bottom: 0 });
gdOffset = ar.gd.offset();
state.contentBox = {
x: gdOffset.left - offset.left,
y: gdOffset.top - offset.top,
cx: ar.gd.width(),
cy: ar.gd.height(),
};
ar.gd.removeAttr("style");
// The arrow box moves between guideOffset and guideOffset + guideDims - arFull
state.guideOffset = {
left: state.guideOffset.left - offset.left,
top: state.guideOffset.top - offset.top,
};
state.arHalf = { cx: state.arFull.cx / 2, cy: state.arFull.cy / 2 };
state.menuHalf = {
cx: state.clampInfo.menuSize.cx / 2,
cy: state.clampInfo.menuSize.cy / 2,
};
return state;
},
_placementCoords: function (desired) {
var state,
best,
params,
elOffset,
bgRef,
optionValue = this.options.arrow,
ar = this._ui.arrow;
if (!ar) {
return this._super(desired);
}
ar.arEls.show();
bgRef = {};
state = this._getPlacementState(true);
params = {
l: {
fst: "x",
snd: "y",
prop: "top",
dimKey: "cy",
oDimKey: "cx",
offsetFactor: 1,
tipOffset: -state.arHalf.cx,
arrowOffsetFactor: 0,
},
r: {
fst: "x",
snd: "y",
prop: "top",
dimKey: "cy",
oDimKey: "cx",
offsetFactor: -1,
tipOffset: state.arHalf.cx + state.contentBox.cx,
arrowOffsetFactor: 1,
},
b: {
fst: "y",
snd: "x",
prop: "left",
dimKey: "cx",
oDimKey: "cy",
offsetFactor: -1,
tipOffset: state.arHalf.cy + state.contentBox.cy,
arrowOffsetFactor: 1,
},
t: {
fst: "y",
snd: "x",
prop: "left",
dimKey: "cx",
oDimKey: "cy",
offsetFactor: 1,
tipOffset: -state.arHalf.cy,
arrowOffsetFactor: 0,
},
};
// Try each side specified in the options to see on which one the arrow
// should be placed such that the distance between the tip of the arrow and
// the desired coordinates is the shortest.
$.each(
(optionValue === true ? "l,t,r,b" : optionValue).split(","),
$.proxy(function (key, value) {
best = this._tryAnArrow(params[value], value, desired, state, best);
}, this),
);
// Could not place the arrow along any of the edges - behave as if showing
// the arrow was turned off.
if (!best) {
ar.arEls.hide();
return this._super(desired);
}
// Move the arrow into place
ar.ct
.removeClass(
"ui-popup-arrow-l ui-popup-arrow-t ui-popup-arrow-r ui-popup-arrow-b",
)
.addClass("ui-popup-arrow-" + best.dir)
.removeAttr("style")
.css(best.posProp, best.posVal)
.show();
// Do not move/size the background div on IE, because we use the arrow div for background as well.
if (!ieHack) {
elOffset = this.element.offset();
bgRef[params[best.dir].fst] = ar.ct.offset();
bgRef[params[best.dir].snd] = {
left: elOffset.left + state.contentBox.x,
top: elOffset.top + state.contentBox.y,
};
}
return best.result;
},
_setOptions: function (opts) {
var newTheme,
oldTheme = this.options.theme,
ar = this._ui.arrow,
ret = this._super(opts);
if (opts.arrow !== undefined) {
if (!ar && opts.arrow) {
this._ui.arrow = this._addArrow();
// Important to return here so we don't set the same options all over
// again below.
return;
} else if (ar && !opts.arrow) {
ar.arEls.remove();
this._ui.arrow = null;
}
}
// Reassign with potentially new arrow
ar = this._ui.arrow;
if (ar) {
if (opts.theme !== undefined) {
oldTheme = this._themeClassFromOption("ui-body-", oldTheme);
newTheme = this._themeClassFromOption("ui-body-", opts.theme);
ar.ar.removeClass(oldTheme).addClass(newTheme);
}
if (opts.shadow !== undefined) {
ar.ar.toggleClass("ui-overlay-shadow", opts.shadow);
}
}
return ret;
},
_destroy: function () {
var ar = this._ui.arrow;
if (ar) {
ar.arEls.remove();
}
return this._super();
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.panel", {
options: {
classes: {
panel: "ui-panel",
panelOpen: "ui-panel-open",
panelClosed: "ui-panel-closed",
panelFixed: "ui-panel-fixed",
panelInner: "ui-panel-inner",
modal: "ui-panel-dismiss",
modalOpen: "ui-panel-dismiss-open",
pageContainer: "ui-panel-page-container",
pageWrapper: "ui-panel-wrapper",
pageFixedToolbar: "ui-panel-fixed-toolbar",
pageContentPrefix:
"ui-panel-page-content" /* Used for wrapper and fixed toolbars position, display and open classes. */,
animate: "ui-panel-animate",
},
animate: true,
theme: null,
position: "left",
dismissible: true,
display: "reveal", //accepts reveal, push, overlay
swipeClose: true,
positionFixed: false,
},
_closeLink: null,
_parentPage: null,
_page: null,
_modal: null,
_panelInner: null,
_wrapper: null,
_fixedToolbars: null,
_create: function () {
var el = this.element,
parentPage = el.closest(".ui-page, :jqmData(role='page')");
// expose some private props to other methods
$.extend(this, {
_closeLink: el.find(":jqmData(rel='close')"),
_parentPage: parentPage.length > 0 ? parentPage : false,
_openedPage: null,
_page: this._getPage,
_panelInner: this._getPanelInner(),
_fixedToolbars: this._getFixedToolbars,
});
if (this.options.display !== "overlay") {
this._getWrapper();
}
this._addPanelClasses();
// if animating, add the class to do so
if ($.support.cssTransform3d && !!this.options.animate) {
this.element.addClass(this.options.classes.animate);
}
this._bindUpdateLayout();
this._bindCloseEvents();
this._bindLinkListeners();
this._bindPageEvents();
if (!!this.options.dismissible) {
this._createModal();
}
this._bindSwipeEvents();
},
_getPanelInner: function () {
var panelInner = this.element.find(
"." + this.options.classes.panelInner,
);
if (panelInner.length === 0) {
panelInner = this.element
.children()
.wrapAll("<div class='" + this.options.classes.panelInner + "' />")
.parent();
}
return panelInner;
},
_createModal: function () {
var self = this,
target = self._parentPage
? self._parentPage.parent()
: self.element.parent();
self._modal = $(
"<div class='" + self.options.classes.modal + "'></div>",
)
.on("mousedown", function () {
self.close();
})
.appendTo(target);
},
_getPage: function () {
var page =
this._openedPage ||
this._parentPage ||
$("." + $.mobile.activePageClass);
return page;
},
_getWrapper: function () {
var wrapper = this._page().find("." + this.options.classes.pageWrapper);
if (wrapper.length === 0) {
wrapper = this._page()
.children(
".ui-header:not(.ui-header-fixed), .ui-content:not(.ui-popup), .ui-footer:not(.ui-footer-fixed)",
)
.wrapAll(
"<div class='" + this.options.classes.pageWrapper + "'></div>",
)
.parent();
}
this._wrapper = wrapper;
},
_getFixedToolbars: function () {
var extFixedToolbars = $("body").children(
".ui-header-fixed, .ui-footer-fixed",
),
intFixedToolbars = this._page().find(
".ui-header-fixed, .ui-footer-fixed",
),
fixedToolbars = extFixedToolbars
.add(intFixedToolbars)
.addClass(this.options.classes.pageFixedToolbar);
return fixedToolbars;
},
_getPosDisplayClasses: function (prefix) {
return (
prefix +
"-position-" +
this.options.position +
" " +
prefix +
"-display-" +
this.options.display
);
},
_getPanelClasses: function () {
var panelClasses =
this.options.classes.panel +
" " +
this._getPosDisplayClasses(this.options.classes.panel) +
" " +
this.options.classes.panelClosed +
" " +
"ui-body-" +
(this.options.theme ? this.options.theme : "inherit");
if (!!this.options.positionFixed) {
panelClasses += " " + this.options.classes.panelFixed;
}
return panelClasses;
},
_addPanelClasses: function () {
this.element.addClass(this._getPanelClasses());
},
_handleCloseClickAndEatEvent: function (event) {
if (!event.isDefaultPrevented()) {
event.preventDefault();
this.close();
return false;
}
},
_handleCloseClick: function (event) {
if (!event.isDefaultPrevented()) {
this.close();
}
},
_bindCloseEvents: function () {
this._on(this._closeLink, {
click: "_handleCloseClick",
});
this._on({
"click a:jqmData(ajax='false')": "_handleCloseClick",
});
},
_positionPanel: function (scrollToTop) {
var self = this,
panelInnerHeight = self._panelInner.outerHeight(),
expand = panelInnerHeight > $.mobile.getScreenHeight();
if (expand || !self.options.positionFixed) {
if (expand) {
self._unfixPanel();
$.mobile.resetActivePageHeight(panelInnerHeight);
}
if (scrollToTop) {
this.window[0].scrollTo(0, $.mobile.defaultHomeScroll);
}
} else {
self._fixPanel();
}
},
_bindFixListener: function () {
this._on($(window), { throttledresize: "_positionPanel" });
},
_unbindFixListener: function () {
this._off($(window), "throttledresize");
},
_unfixPanel: function () {
if (!!this.options.positionFixed && $.support.fixedPosition) {
this.element.removeClass(this.options.classes.panelFixed);
}
},
_fixPanel: function () {
if (!!this.options.positionFixed && $.support.fixedPosition) {
this.element.addClass(this.options.classes.panelFixed);
}
},
_bindUpdateLayout: function () {
var self = this;
self.element.on("updatelayout", function (/* e */) {
if (self._open) {
self._positionPanel();
}
});
},
_bindLinkListeners: function () {
this._on("body", {
"click a": "_handleClick",
});
},
_handleClick: function (e) {
var link,
panelId = this.element.attr("id");
if (
e.currentTarget.href.split("#")[1] === panelId &&
panelId !== undefined
) {
e.preventDefault();
link = $(e.target);
if (link.hasClass("ui-btn")) {
link.addClass($.mobile.activeBtnClass);
this.element.one("panelopen panelclose", function () {
link.removeClass($.mobile.activeBtnClass);
});
}
this.toggle();
return false;
}
},
_bindSwipeEvents: function () {
var self = this,
area = self._modal ? self.element.add(self._modal) : self.element;
// on swipe, close the panel
if (!!self.options.swipeClose) {
if (self.options.position === "left") {
area.on("swipeleft.panel", function (/* e */) {
self.close();
});
} else {
area.on("swiperight.panel", function (/* e */) {
self.close();
});
}
}
},
_bindPageEvents: function () {
var self = this;
this.document
// Close the panel if another panel on the page opens
.on("panelbeforeopen", function (e) {
if (self._open && e.target !== self.element[0]) {
self.close();
}
})
// On escape, close? might need to have a target check too...
.on("keyup.panel", function (e) {
if (e.keyCode === 27 && self._open) {
self.close();
}
});
if (!this._parentPage && this.options.display !== "overlay") {
this._on(this.document, {
pageshow: "_getWrapper",
});
}
// Clean up open panels after page hide
if (self._parentPage) {
this.document.on("pagehide", ":jqmData(role='page')", function () {
if (self._open) {
self.close(true);
}
});
} else {
this.document.on("pagebeforehide", function () {
if (self._open) {
self.close(true);
}
});
}
},
// state storage of open or closed
_open: false,
_pageContentOpenClasses: null,
_modalOpenClasses: null,
open: function (immediate) {
if (!this._open) {
var self = this,
o = self.options,
_openPanel = function () {
self.document.off("panelclose");
self._page().jqmData("panel", "open");
if (
$.support.cssTransform3d &&
!!o.animate &&
o.display !== "overlay"
) {
self._wrapper.addClass(o.classes.animate);
self._fixedToolbars().addClass(o.classes.animate);
}
if (!immediate && $.support.cssTransform3d && !!o.animate) {
self.element.animationComplete(complete, "transition");
} else {
setTimeout(complete, 0);
}
if (o.theme && o.display !== "overlay") {
self
._page()
.parent()
.addClass(
o.classes.pageContainer +
"-themed " +
o.classes.pageContainer +
"-" +
o.theme,
);
}
self.element
.removeClass(o.classes.panelClosed)
.addClass(o.classes.panelOpen);
self._positionPanel(true);
self._pageContentOpenClasses = self._getPosDisplayClasses(
o.classes.pageContentPrefix,
);
if (o.display !== "overlay") {
self._page().parent().addClass(o.classes.pageContainer);
self._wrapper.addClass(self._pageContentOpenClasses);
self._fixedToolbars().addClass(self._pageContentOpenClasses);
}
self._modalOpenClasses =
self._getPosDisplayClasses(o.classes.modal) +
" " +
o.classes.modalOpen;
if (self._modal) {
self._modal
.addClass(self._modalOpenClasses)
.height(
Math.max(self._modal.height(), self.document.height()),
);
}
},
complete = function () {
if (o.display !== "overlay") {
self._wrapper.addClass(o.classes.pageContentPrefix + "-open");
self
._fixedToolbars()
.addClass(o.classes.pageContentPrefix + "-open");
}
self._bindFixListener();
self._trigger("open");
self._openedPage = self._page();
};
self._trigger("beforeopen");
if (self._page().jqmData("panel") === "open") {
self.document.on("panelclose", function () {
_openPanel();
});
} else {
_openPanel();
}
self._open = true;
}
},
close: function (immediate) {
if (this._open) {
var self = this,
o = this.options,
_closePanel = function () {
self.element.removeClass(o.classes.panelOpen);
if (o.display !== "overlay") {
self._wrapper.removeClass(self._pageContentOpenClasses);
self._fixedToolbars().removeClass(self._pageContentOpenClasses);
}
if (!immediate && $.support.cssTransform3d && !!o.animate) {
self.element.animationComplete(complete, "transition");
} else {
setTimeout(complete, 0);
}
if (self._modal) {
self._modal.removeClass(self._modalOpenClasses);
}
},
complete = function () {
if (o.theme && o.display !== "overlay") {
self
._page()
.parent()
.removeClass(
o.classes.pageContainer +
"-themed " +
o.classes.pageContainer +
"-" +
o.theme,
);
}
self.element.addClass(o.classes.panelClosed);
if (o.display !== "overlay") {
self._page().parent().removeClass(o.classes.pageContainer);
self._wrapper.removeClass(
o.classes.pageContentPrefix + "-open",
);
self
._fixedToolbars()
.removeClass(o.classes.pageContentPrefix + "-open");
}
if (
$.support.cssTransform3d &&
!!o.animate &&
o.display !== "overlay"
) {
self._wrapper.removeClass(o.classes.animate);
self._fixedToolbars().removeClass(o.classes.animate);
}
self._fixPanel();
self._unbindFixListener();
$.mobile.resetActivePageHeight();
self._page().jqmRemoveData("panel");
self._trigger("close");
self._openedPage = null;
};
self._trigger("beforeclose");
_closePanel();
self._open = false;
}
},
toggle: function () {
this[this._open ? "close" : "open"]();
},
_destroy: function () {
var otherPanels,
o = this.options,
multiplePanels =
$("body > :mobile-panel").length +
$.mobile.activePage.find(":mobile-panel").length >
1;
if (o.display !== "overlay") {
// remove the wrapper if not in use by another panel
otherPanels = $("body > :mobile-panel").add(
$.mobile.activePage.find(":mobile-panel"),
);
if (
otherPanels.not(".ui-panel-display-overlay").not(this.element)
.length === 0
) {
this._wrapper.children().unwrap();
}
if (this._open) {
this._fixedToolbars().removeClass(
o.classes.pageContentPrefix + "-open",
);
if ($.support.cssTransform3d && !!o.animate) {
this._fixedToolbars().removeClass(o.classes.animate);
}
this._page().parent().removeClass(o.classes.pageContainer);
if (o.theme) {
this._page()
.parent()
.removeClass(
o.classes.pageContainer +
"-themed " +
o.classes.pageContainer +
"-" +
o.theme,
);
}
}
}
if (!multiplePanels) {
this.document.off("panelopen panelclose");
}
if (this._open) {
this._page().jqmRemoveData("panel");
}
this._panelInner.children().unwrap();
this.element
.removeClass(
[
this._getPanelClasses(),
o.classes.panelOpen,
o.classes.animate,
].join(" "),
)
.off("swipeleft.panel swiperight.panel")
.off("panelbeforeopen")
.off("panelhide")
.off("keyup.panel")
.off("updatelayout");
if (this._modal) {
this._modal.remove();
}
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.table", {
options: {
classes: {
table: "ui-table",
},
enhanced: false,
},
_create: function () {
if (!this.options.enhanced) {
this.element.addClass(this.options.classes.table);
}
// extend here, assign on refresh > _setHeaders
$.extend(this, {
// Expose headers and allHeaders properties on the widget
// headers references the THs within the first TR in the table
headers: undefined,
// allHeaders references headers, plus all THs in the thead, which may
// include several rows, or not
allHeaders: undefined,
});
this._refresh(true);
},
_setHeaders: function () {
var trs = this.element.find("thead tr");
this.headers = this.element.find("tr:eq(0)").children();
this.allHeaders = this.headers.add(trs.children());
},
refresh: function () {
this._refresh();
},
rebuild: $.noop,
_refresh: function (/* create */) {
var table = this.element,
trs = table.find("thead tr");
// updating headers on refresh (fixes #5880)
this._setHeaders();
// Iterate over the trs
trs.each(function () {
var columnCount = 0;
// Iterate over the children of the tr
$(this)
.children()
.each(function () {
var span = parseInt(this.getAttribute("colspan"), 10),
selector = ":nth-child(" + (columnCount + 1) + ")",
j;
this.setAttribute(
"data-" + $.mobile.ns + "colstart",
columnCount + 1,
);
if (span) {
for (j = 0; j < span - 1; j++) {
columnCount++;
selector += ", :nth-child(" + (columnCount + 1) + ")";
}
}
// Store "cells" data on header as a reference to all cells in the
// same column as this TH
$(this).jqmData(
"cells",
table.find("tr").not(trs.eq(0)).not(this).children(selector),
);
columnCount++;
});
});
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.table", $.mobile.table, {
options: {
mode: "columntoggle",
columnBtnTheme: null,
columnPopupTheme: null,
columnBtnText: "Columns...",
classes: $.extend($.mobile.table.prototype.options.classes, {
popup: "ui-table-columntoggle-popup",
columnBtn: "ui-table-columntoggle-btn",
priorityPrefix: "ui-table-priority-",
columnToggleTable: "ui-table-columntoggle",
}),
},
_create: function () {
this._super();
if (this.options.mode !== "columntoggle") {
return;
}
$.extend(this, {
_menu: null,
});
if (this.options.enhanced) {
this._menu = $(this.document[0].getElementById(this._id() + "-popup"))
.children()
.first();
this._addToggles(this._menu, true);
} else {
this._menu = this._enhanceColToggle();
this.element.addClass(this.options.classes.columnToggleTable);
}
this._setupEvents();
this._setToggleState();
},
_id: function () {
return this.element.attr("id") || this.widgetName + this.uuid;
},
_setupEvents: function () {
//NOTE: inputs are bound in bindToggles,
// so it can be called on refresh, too
// update column toggles on resize
this._on(this.window, {
throttledresize: "_setToggleState",
});
this._on(this._menu, {
"change input": "_menuInputChange",
});
},
_addToggles: function (menu, keep) {
var inputs,
checkboxIndex = 0,
opts = this.options,
container = menu.controlgroup("container");
// allow update of menu on refresh (fixes #5880)
if (keep) {
inputs = menu.find("input");
} else {
container.empty();
}
// create the hide/show toggles
this.headers.not("td").each(function () {
var header = $(this),
priority = $.mobile.getAttribute(this, "priority"),
cells = header.add(header.jqmData("cells"));
if (priority) {
cells.addClass(opts.classes.priorityPrefix + priority);
(keep
? inputs.eq(checkboxIndex++)
: $(
"<label><input type='checkbox' checked />" +
(header.children("abbr").first().attr("title") ||
header.text()) +
"</label>",
)
.appendTo(container)
.children(0)
.checkboxradio({
theme: opts.columnPopupTheme,
})
).jqmData("cells", cells);
}
});
// set bindings here
if (!keep) {
menu.controlgroup("refresh");
}
},
_menuInputChange: function (evt) {
var input = $(evt.target),
checked = input[0].checked;
input
.jqmData("cells")
.toggleClass("ui-table-cell-hidden", !checked)
.toggleClass("ui-table-cell-visible", checked);
if (input[0].getAttribute("locked")) {
input.removeAttr("locked");
this._unlockCells(input.jqmData("cells"));
} else {
input.attr("locked", true);
}
},
_unlockCells: function (cells) {
// allow hide/show via CSS only = remove all toggle-locks
cells.removeClass("ui-table-cell-hidden ui-table-cell-visible");
},
_enhanceColToggle: function () {
var id,
menuButton,
popup,
menu,
table = this.element,
opts = this.options,
ns = $.mobile.ns,
fragment = this.document[0].createDocumentFragment();
id = this._id() + "-popup";
menuButton = $(
"<a href='#" +
id +
"' " +
"class='" +
opts.classes.columnBtn +
" ui-btn " +
"ui-btn-" +
(opts.columnBtnTheme || "a") +
" ui-corner-all ui-shadow ui-mini' " +
"data-" +
ns +
"rel='popup'>" +
opts.columnBtnText +
"</a>",
);
popup = $(
"<div class='" + opts.classes.popup + "' id='" + id + "'></div>",
);
menu = $("<fieldset></fieldset>").controlgroup();
// set extension here, send "false" to trigger build/rebuild
this._addToggles(menu, false);
menu.appendTo(popup);
fragment.appendChild(popup[0]);
fragment.appendChild(menuButton[0]);
table.before(fragment);
popup.popup();
return menu;
},
rebuild: function () {
this._super();
if (this.options.mode === "columntoggle") {
// NOTE: rebuild passes "false", while refresh passes "undefined"
// both refresh the table, but inside addToggles, !false will be true,
// so a rebuild call can be indentified
this._refresh(false);
}
},
_refresh: function (create) {
this._super(create);
if (!create && this.options.mode === "columntoggle") {
// columns not being replaced must be cleared from input toggle-locks
this._unlockCells(
this.element.find(
".ui-table-cell-hidden, " + ".ui-table-cell-visible",
),
);
// update columntoggles and cells
this._addToggles(this._menu, create);
// check/uncheck
this._setToggleState();
}
},
_setToggleState: function () {
this._menu.find("input").each(function () {
var checkbox = $(this);
this.checked =
checkbox.jqmData("cells").eq(0).css("display") === "table-cell";
checkbox.checkboxradio("refresh");
});
},
_destroy: function () {
this._super();
},
});
})(jQuery);
(function ($, undefined) {
$.widget("mobile.table", $.mobile.table, {
options: {
mode: "reflow",
classes: $.extend($.mobile.table.prototype.options.classes, {
reflowTable: "ui-table-reflow",
cellLabels: "ui-table-cell-label",
}),
},
_create: function () {
this._super();
// If it's not reflow mode, return here.
if (this.options.mode !== "reflow") {
return;
}
if (!this.options.enhanced) {
this.element.addClass(this.options.classes.reflowTable);
this._updateReflow();
}
},
rebuild: function () {
this._super();
if (this.options.mode === "reflow") {
this._refresh(false);
}
},
_refresh: function (create) {
this._super(create);
if (!create && this.options.mode === "reflow") {
this._updateReflow();
}
},
_updateReflow: function () {
var table = this,
opts = this.options;
// get headers in reverse order so that top-level headers are appended last
$(table.allHeaders.get().reverse()).each(function () {
var cells = $(this).jqmData("cells"),
colstart = $.mobile.getAttribute(this, "colstart"),
hierarchyClass =
cells.not(this).filter("thead th").length &&
" ui-table-cell-label-top",
text = $(this).text(),
iteration,
filter;
if (text !== "") {
if (hierarchyClass) {
iteration = parseInt(this.getAttribute("colspan"), 10);
filter = "";
if (iteration) {
filter = "td:nth-child(" + iteration + "n + " + colstart + ")";
}
table._addLabels(
cells.filter(filter),
opts.classes.cellLabels + hierarchyClass,
text,
);
} else {
table._addLabels(cells, opts.classes.cellLabels, text);
}
}
});
},
_addLabels: function (cells, label, text) {
// .not fixes #6006
cells
.not(":has(b." + label + ")")
.prepend("<b class='" + label + "'>" + text + "</b>");
},
});
})(jQuery);
(function ($, undefined) {
// TODO rename filterCallback/deprecate and default to the item itself as the first argument
var defaultFilterCallback = function (index, searchValue) {
return (
("" + ($.mobile.getAttribute(this, "filtertext") || $(this).text()))
.toLowerCase()
.indexOf(searchValue) === -1
);
};
$.widget("mobile.filterable", {
initSelector: ":jqmData(filter='true')",
options: {
filterReveal: false,
filterCallback: defaultFilterCallback,
enhanced: false,
input: null,
children:
"> li, > option, > optgroup option, > tbody tr, > .ui-controlgroup-controls > .ui-btn, > .ui-controlgroup-controls > .ui-checkbox, > .ui-controlgroup-controls > .ui-radio",
},
_create: function () {
var opts = this.options;
$.extend(this, {
_search: null,
_timer: 0,
});
this._setInput(opts.input);
if (!opts.enhanced) {
this._filterItems(
((this._search && this._search.val()) || "").toLowerCase(),
);
}
},
_onKeyUp: function () {
var val,
lastval,
search = this._search;
if (search) {
(val = search.val().toLowerCase()),
(lastval = $.mobile.getAttribute(search[0], "lastval") + "");
if (lastval && lastval === val) {
// Execute the handler only once per value change
return;
}
if (this._timer) {
window.clearTimeout(this._timer);
this._timer = 0;
}
this._timer = this._delay(function () {
this._trigger("beforefilter", null, { input: search });
// Change val as lastval for next execution
search[0].setAttribute("data-" + $.mobile.ns + "lastval", val);
this._filterItems(val);
this._timer = 0;
}, 250);
}
},
_getFilterableItems: function () {
var elem = this.element,
children = this.options.children,
items = !children
? { length: 0 }
: $.isFunction(children)
? children()
: children.nodeName
? $(children)
: children.jquery
? children
: this.element.find(children);
if (items.length === 0) {
items = elem.children();
}
return items;
},
_filterItems: function (val) {
var idx,
callback,
length,
dst,
show = [],
hide = [],
opts = this.options,
filterItems = this._getFilterableItems();
if (val != null) {
callback = opts.filterCallback || defaultFilterCallback;
length = filterItems.length;
// Partition the items into those to be hidden and those to be shown
for (idx = 0; idx < length; idx++) {
dst = callback.call(filterItems[idx], idx, val) ? hide : show;
dst.push(filterItems[idx]);
}
}
// If nothing is hidden, then the decision whether to hide or show the items
// is based on the "filterReveal" option.
if (hide.length === 0) {
filterItems[opts.filterReveal ? "addClass" : "removeClass"](
"ui-screen-hidden",
);
} else {
$(hide).addClass("ui-screen-hidden");
$(show).removeClass("ui-screen-hidden");
}
this._refreshChildWidget();
this._trigger("filter", null, {
items: filterItems,
});
},
// The Default implementation of _refreshChildWidget attempts to call
// refresh on collapsibleset, controlgroup, selectmenu, or listview
_refreshChildWidget: function () {
var widget,
idx,
recognizedWidgets = [
"collapsibleset",
"selectmenu",
"controlgroup",
"listview",
];
for (idx = recognizedWidgets.length - 1; idx > -1; idx--) {
widget = recognizedWidgets[idx];
if ($.mobile[widget]) {
widget = this.element.data("mobile-" + widget);
if (widget && $.isFunction(widget.refresh)) {
widget.refresh();
}
}
}
},
// TODO: When the input is not internal, do not even store it in this._search
_setInput: function (selector) {
var search = this._search;
// Stop a pending filter operation
if (this._timer) {
window.clearTimeout(this._timer);
this._timer = 0;
}
if (search) {
this._off(search, "keyup change input");
search = null;
}
if (selector) {
search = selector.jquery
? selector
: selector.nodeName
? $(selector)
: this.document.find(selector);
this._on(search, {
keyup: "_onKeyUp",
change: "_onKeyUp",
input: "_onKeyUp",
});
}
this._search = search;
},
_setOptions: function (options) {
var refilter = !(
options.filterReveal === undefined &&
options.filterCallback === undefined &&
options.children === undefined
);
this._super(options);
if (options.input !== undefined) {
this._setInput(options.input);
refilter = true;
}
if (refilter) {
this.refresh();
}
},
_destroy: function () {
var opts = this.options,
items = this._getFilterableItems();
if (opts.enhanced) {
items.toggleClass("ui-screen-hidden", opts.filterReveal);
} else {
items.removeClass("ui-screen-hidden");
}
},
refresh: function () {
if (this._timer) {
window.clearTimeout(this._timer);
this._timer = 0;
}
this._filterItems(
((this._search && this._search.val()) || "").toLowerCase(),
);
},
});
})(jQuery);
(function ($, undefined) {
// Create a function that will replace the _setOptions function of a widget,
// and will pass the options on to the input of the filterable.
var replaceSetOptions = function (self, orig) {
return function (options) {
orig.call(this, options);
self._syncTextInputOptions(options);
};
},
rDividerListItem = /(^|\s)ui-li-divider(\s|$)/,
origDefaultFilterCallback =
$.mobile.filterable.prototype.options.filterCallback;
// Override the default filter callback with one that does not hide list dividers
$.mobile.filterable.prototype.options.filterCallback = function (
index,
searchValue,
) {
return (
!this.className.match(rDividerListItem) &&
origDefaultFilterCallback.call(this, index, searchValue)
);
};
$.widget("mobile.filterable", $.mobile.filterable, {
options: {
filterPlaceholder: "Filter items...",
filterTheme: null,
},
_create: function () {
var idx,
widgetName,
elem = this.element,
recognizedWidgets = [
"collapsibleset",
"selectmenu",
"controlgroup",
"listview",
],
createHandlers = {};
this._super();
$.extend(this, {
_widget: null,
});
for (idx = recognizedWidgets.length - 1; idx > -1; idx--) {
widgetName = recognizedWidgets[idx];
if ($.mobile[widgetName]) {
if (this._setWidget(elem.data("mobile-" + widgetName))) {
break;
} else {
createHandlers[widgetName + "create"] = "_handleCreate";
}
}
}
if (!this._widget) {
this._on(elem, createHandlers);
}
},
_handleCreate: function (evt) {
this._setWidget(
this.element.data(
"mobile-" + evt.type.substring(0, evt.type.length - 6),
),
);
},
_trigger: function (type, event, data) {
if (
this._widget &&
this._widget.widgetFullName === "mobile-listview" &&
type === "beforefilter"
) {
// Also trigger listviewbeforefilter if this widget is also a listview
this._widget._trigger("beforefilter", event, data);
}
this._super(type, event, data);
},
_setWidget: function (widget) {
if (!this._widget && widget) {
this._widget = widget;
this._widget._setOptions = replaceSetOptions(
this,
this._widget._setOptions,
);
}
if (!!this._widget) {
this._syncTextInputOptions(this._widget.options);
if (this._widget.widgetName === "listview") {
this._widget.options.hideDividers = true;
this._widget.element.listview("refresh");
}
}
return !!this._widget;
},
_isSearchInternal: function () {
return (
this._search &&
this._search.jqmData("ui-filterable-" + this.uuid + "-internal")
);
},
_setInput: function (selector) {
var opts = this.options,
updatePlaceholder = true,
textinputOpts = {};
if (!selector) {
if (this._isSearchInternal()) {
// Ignore the call to set a new input if the selector goes to falsy and
// the current textinput is already of the internally generated variety.
return;
} else {
// Generating a new textinput widget. No need to set the placeholder
// further down the function.
updatePlaceholder = false;
selector = $(
"<input " +
"data-" +
$.mobile.ns +
"type='search' " +
"placeholder='" +
opts.filterPlaceholder +
"'></input>",
).jqmData("ui-filterable-" + this.uuid + "-internal", true);
$("<form class='ui-filterable'></form>")
.append(selector)
.submit(function (evt) {
evt.preventDefault();
selector.blur();
})
.insertBefore(this.element);
if ($.mobile.textinput) {
if (this.options.filterTheme != null) {
textinputOpts["theme"] = opts.filterTheme;
}
selector.textinput(textinputOpts);
}
}
}
this._super(selector);
if (this._isSearchInternal() && updatePlaceholder) {
this._search.attr("placeholder", this.options.filterPlaceholder);
}
},
_setOptions: function (options) {
var ret = this._super(options);
// Need to set the filterPlaceholder after having established the search input
if (options.filterPlaceholder !== undefined) {
if (this._isSearchInternal()) {
this._search.attr("placeholder", options.filterPlaceholder);
}
}
if (
options.filterTheme !== undefined &&
this._search &&
$.mobile.textinput
) {
this._search.textinput("option", "theme", options.filterTheme);
}
return ret;
},
_destroy: function () {
if (this._isSearchInternal()) {
this._search.remove();
}
this._super();
},
_syncTextInputOptions: function (options) {
var idx,
textinputOptions = {};
// We only sync options if the filterable's textinput is of the internally
// generated variety, rather than one specified by the user.
if (this._isSearchInternal() && $.mobile.textinput) {
// Apply only the options understood by textinput
for (idx in $.mobile.textinput.prototype.options) {
if (options[idx] !== undefined) {
if (idx === "theme" && this.options.filterTheme != null) {
textinputOptions[idx] = this.options.filterTheme;
} else {
textinputOptions[idx] = options[idx];
}
}
}
this._search.textinput("option", textinputOptions);
}
},
});
})(jQuery);
/*!
* jQuery UI Tabs fadf2b312a05040436451c64bbfaf4814bc62c56
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/tabs/
*
* Depends:
* jquery.ui.core.js
* jquery.ui.widget.js
*/
(function ($, undefined) {
var tabId = 0,
rhash = /#.*$/;
function getNextTabId() {
return ++tabId;
}
function isLocal(anchor) {
return (
anchor.hash.length > 1 &&
decodeURIComponent(anchor.href.replace(rhash, "")) ===
decodeURIComponent(location.href.replace(rhash, ""))
);
}
$.widget("ui.tabs", {
version: "fadf2b312a05040436451c64bbfaf4814bc62c56",
delay: 300,
options: {
active: null,
collapsible: false,
event: "click",
heightStyle: "content",
hide: null,
show: null,
// callbacks
activate: null,
beforeActivate: null,
beforeLoad: null,
load: null,
},
_create: function () {
var that = this,
options = this.options;
this.running = false;
this.element
.addClass("ui-tabs ui-widget ui-widget-content ui-corner-all")
.toggleClass("ui-tabs-collapsible", options.collapsible)
// Prevent users from focusing disabled tabs via click
.delegate(
".ui-tabs-nav > li",
"mousedown" + this.eventNamespace,
function (event) {
if ($(this).is(".ui-state-disabled")) {
event.preventDefault();
}
},
)
// support: IE <9
// Preventing the default action in mousedown doesn't prevent IE
// from focusing the element, so if the anchor gets focused, blur.
// We don't have to worry about focusing the previously focused
// element since clicking on a non-focusable element should focus
// the body anyway.
.delegate(
".ui-tabs-anchor",
"focus" + this.eventNamespace,
function () {
if ($(this).closest("li").is(".ui-state-disabled")) {
this.blur();
}
},
);
this._processTabs();
options.active = this._initialActive();
// Take disabling tabs via class attribute from HTML
// into account and update option properly.
if ($.isArray(options.disabled)) {
options.disabled = $.unique(
options.disabled.concat(
$.map(this.tabs.filter(".ui-state-disabled"), function (li) {
return that.tabs.index(li);
}),
),
).sort();
}
// check for length avoids error when initializing empty list
if (this.options.active !== false && this.anchors.length) {
this.active = this._findActive(options.active);
} else {
this.active = $();
}
this._refresh();
if (this.active.length) {
this.load(options.active);
}
},
_initialActive: function () {
var active = this.options.active,
collapsible = this.options.collapsible,
locationHash = location.hash.substring(1);
if (active === null) {
// check the fragment identifier in the URL
if (locationHash) {
this.tabs.each(function (i, tab) {
if ($(tab).attr("aria-controls") === locationHash) {
active = i;
return false;
}
});
}
// check for a tab marked active via a class
if (active === null) {
active = this.tabs.index(this.tabs.filter(".ui-tabs-active"));
}
// no active tab, set to false
if (active === null || active === -1) {
active = this.tabs.length ? 0 : false;
}
}
// handle numbers: negative, out of range
if (active !== false) {
active = this.tabs.index(this.tabs.eq(active));
if (active === -1) {
active = collapsible ? false : 0;
}
}
// don't allow collapsible: false and active: false
if (!collapsible && active === false && this.anchors.length) {
active = 0;
}
return active;
},
_getCreateEventData: function () {
return {
tab: this.active,
panel: !this.active.length ? $() : this._getPanelForTab(this.active),
};
},
_tabKeydown: function (event) {
var focusedTab = $(this.document[0].activeElement).closest("li"),
selectedIndex = this.tabs.index(focusedTab),
goingForward = true;
if (this._handlePageNav(event)) {
return;
}
switch (event.keyCode) {
case $.ui.keyCode.RIGHT:
case $.ui.keyCode.DOWN:
selectedIndex++;
break;
case $.ui.keyCode.UP:
case $.ui.keyCode.LEFT:
goingForward = false;
selectedIndex--;
break;
case $.ui.keyCode.END:
selectedIndex = this.anchors.length - 1;
break;
case $.ui.keyCode.HOME:
selectedIndex = 0;
break;
case $.ui.keyCode.SPACE:
// Activate only, no collapsing
event.preventDefault();
clearTimeout(this.activating);
this._activate(selectedIndex);
return;
case $.ui.keyCode.ENTER:
// Toggle (cancel delayed activation, allow collapsing)
event.preventDefault();
clearTimeout(this.activating);
// Determine if we should collapse or activate
this._activate(
selectedIndex === this.options.active ? false : selectedIndex,
);
return;
default:
return;
}
// Focus the appropriate tab, based on which key was pressed
event.preventDefault();
clearTimeout(this.activating);
selectedIndex = this._focusNextTab(selectedIndex, goingForward);
// Navigating with control key will prevent automatic activation
if (!event.ctrlKey) {
// Update aria-selected immediately so that AT think the tab is already selected.
// Otherwise AT may confuse the user by stating that they need to activate the tab,
// but the tab will already be activated by the time the announcement finishes.
focusedTab.attr("aria-selected", "false");
this.tabs.eq(selectedIndex).attr("aria-selected", "true");
this.activating = this._delay(function () {
this.option("active", selectedIndex);
}, this.delay);
}
},
_panelKeydown: function (event) {
if (this._handlePageNav(event)) {
return;
}
// Ctrl+up moves focus to the current tab
if (event.ctrlKey && event.keyCode === $.ui.keyCode.UP) {
event.preventDefault();
this.active.focus();
}
},
// Alt+page up/down moves focus to the previous/next tab (and activates)
_handlePageNav: function (event) {
if (event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP) {
this._activate(this._focusNextTab(this.options.active - 1, false));
return true;
}
if (event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN) {
this._activate(this._focusNextTab(this.options.active + 1, true));
return true;
}
},
_findNextTab: function (index, goingForward) {
var lastTabIndex = this.tabs.length - 1;
function constrain() {
if (index > lastTabIndex) {
index = 0;
}
if (index < 0) {
index = lastTabIndex;
}
return index;
}
while ($.inArray(constrain(), this.options.disabled) !== -1) {
index = goingForward ? index + 1 : index - 1;
}
return index;
},
_focusNextTab: function (index, goingForward) {
index = this._findNextTab(index, goingForward);
this.tabs.eq(index).focus();
return index;
},
_setOption: function (key, value) {
if (key === "active") {
// _activate() will handle invalid values and update this.options
this._activate(value);
return;
}
if (key === "disabled") {
// don't use the widget factory's disabled handling
this._setupDisabled(value);
return;
}
this._super(key, value);
if (key === "collapsible") {
this.element.toggleClass("ui-tabs-collapsible", value);
// Setting collapsible: false while collapsed; open first panel
if (!value && this.options.active === false) {
this._activate(0);
}
}
if (key === "event") {
this._setupEvents(value);
}
if (key === "heightStyle") {
this._setupHeightStyle(value);
}
},
_tabId: function (tab) {
return tab.attr("aria-controls") || "ui-tabs-" + getNextTabId();
},
_sanitizeSelector: function (hash) {
return hash
? hash.replace(/[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&")
: "";
},
refresh: function () {
var options = this.options,
lis = this.tablist.children(":has(a[href])");
// get disabled tabs from class attribute from HTML
// this will get converted to a boolean if needed in _refresh()
options.disabled = $.map(
lis.filter(".ui-state-disabled"),
function (tab) {
return lis.index(tab);
},
);
this._processTabs();
// was collapsed or no tabs
if (options.active === false || !this.anchors.length) {
options.active = false;
this.active = $();
// was active, but active tab is gone
} else if (
this.active.length &&
!$.contains(this.tablist[0], this.active[0])
) {
// all remaining tabs are disabled
if (this.tabs.length === options.disabled.length) {
options.active = false;
this.active = $();
// activate previous tab
} else {
this._activate(
this._findNextTab(Math.max(0, options.active - 1), false),
);
}
// was active, active tab still exists
} else {
// make sure active index is correct
options.active = this.tabs.index(this.active);
}
this._refresh();
},
_refresh: function () {
this._setupDisabled(this.options.disabled);
this._setupEvents(this.options.event);
this._setupHeightStyle(this.options.heightStyle);
this.tabs.not(this.active).attr({
"aria-selected": "false",
tabIndex: -1,
});
this.panels.not(this._getPanelForTab(this.active)).hide().attr({
"aria-expanded": "false",
"aria-hidden": "true",
});
// Make sure one tab is in the tab order
if (!this.active.length) {
this.tabs.eq(0).attr("tabIndex", 0);
} else {
this.active.addClass("ui-tabs-active ui-state-active").attr({
"aria-selected": "true",
tabIndex: 0,
});
this._getPanelForTab(this.active).show().attr({
"aria-expanded": "true",
"aria-hidden": "false",
});
}
},
_processTabs: function () {
var that = this;
this.tablist = this._getList()
.addClass(
"ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all",
)
.attr("role", "tablist");
this.tabs = this.tablist
.find("> li:has(a[href])")
.addClass("ui-state-default ui-corner-top")
.attr({
role: "tab",
tabIndex: -1,
});
this.anchors = this.tabs
.map(function () {
return $("a", this)[0];
})
.addClass("ui-tabs-anchor")
.attr({
role: "presentation",
tabIndex: -1,
});
this.panels = $();
this.anchors.each(function (i, anchor) {
var selector,
panel,
panelId,
anchorId = $(anchor).uniqueId().attr("id"),
tab = $(anchor).closest("li"),
originalAriaControls = tab.attr("aria-controls");
// inline tab
if (isLocal(anchor)) {
selector = anchor.hash;
panel = that.element.find(that._sanitizeSelector(selector));
// remote tab
} else {
panelId = that._tabId(tab);
selector = "#" + panelId;
panel = that.element.find(selector);
if (!panel.length) {
panel = that._createPanel(panelId);
panel.insertAfter(that.panels[i - 1] || that.tablist);
}
panel.attr("aria-live", "polite");
}
if (panel.length) {
that.panels = that.panels.add(panel);
}
if (originalAriaControls) {
tab.data("ui-tabs-aria-controls", originalAriaControls);
}
tab.attr({
"aria-controls": selector.substring(1),
"aria-labelledby": anchorId,
});
panel.attr("aria-labelledby", anchorId);
});
this.panels
.addClass("ui-tabs-panel ui-widget-content ui-corner-bottom")
.attr("role", "tabpanel");
},
// allow overriding how to find the list for rare usage scenarios (#7715)
_getList: function () {
return this.element.find("ol,ul").eq(0);
},
_createPanel: function (id) {
return $("<div>")
.attr("id", id)
.addClass("ui-tabs-panel ui-widget-content ui-corner-bottom")
.data("ui-tabs-destroy", true);
},
_setupDisabled: function (disabled) {
if ($.isArray(disabled)) {
if (!disabled.length) {
disabled = false;
} else if (disabled.length === this.anchors.length) {
disabled = true;
}
}
// disable tabs
for (var i = 0, li; (li = this.tabs[i]); i++) {
if (disabled === true || $.inArray(i, disabled) !== -1) {
$(li).addClass("ui-state-disabled").attr("aria-disabled", "true");
} else {
$(li).removeClass("ui-state-disabled").removeAttr("aria-disabled");
}
}
this.options.disabled = disabled;
},
_setupEvents: function (event) {
var events = {
click: function (event) {
event.preventDefault();
},
};
if (event) {
$.each(event.split(" "), function (index, eventName) {
events[eventName] = "_eventHandler";
});
}
this._off(this.anchors.add(this.tabs).add(this.panels));
this._on(this.anchors, events);
this._on(this.tabs, { keydown: "_tabKeydown" });
this._on(this.panels, { keydown: "_panelKeydown" });
this._focusable(this.tabs);
this._hoverable(this.tabs);
},
_setupHeightStyle: function (heightStyle) {
var maxHeight,
parent = this.element.parent();
if (heightStyle === "fill") {
maxHeight = parent.height();
maxHeight -= this.element.outerHeight() - this.element.height();
this.element.siblings(":visible").each(function () {
var elem = $(this),
position = elem.css("position");
if (position === "absolute" || position === "fixed") {
return;
}
maxHeight -= elem.outerHeight(true);
});
this.element
.children()
.not(this.panels)
.each(function () {
maxHeight -= $(this).outerHeight(true);
});
this.panels
.each(function () {
$(this).height(
Math.max(
0,
maxHeight - $(this).innerHeight() + $(this).height(),
),
);
})
.css("overflow", "auto");
} else if (heightStyle === "auto") {
maxHeight = 0;
this.panels
.each(function () {
maxHeight = Math.max(maxHeight, $(this).height("").height());
})
.height(maxHeight);
}
},
_eventHandler: function (event) {
var options = this.options,
active = this.active,
anchor = $(event.currentTarget),
tab = anchor.closest("li"),
clickedIsActive = tab[0] === active[0],
collapsing = clickedIsActive && options.collapsible,
toShow = collapsing ? $() : this._getPanelForTab(tab),
toHide = !active.length ? $() : this._getPanelForTab(active),
eventData = {
oldTab: active,
oldPanel: toHide,
newTab: collapsing ? $() : tab,
newPanel: toShow,
};
event.preventDefault();
if (
tab.hasClass("ui-state-disabled") ||
// tab is already loading
tab.hasClass("ui-tabs-loading") ||
// can't switch durning an animation
this.running ||
// click on active header, but not collapsible
(clickedIsActive && !options.collapsible) ||
// allow canceling activation
this._trigger("beforeActivate", event, eventData) === false
) {
return;
}
options.active = collapsing ? false : this.tabs.index(tab);
this.active = clickedIsActive ? $() : tab;
if (this.xhr) {
this.xhr.abort();
}
if (!toHide.length && !toShow.length) {
$.error("jQuery UI Tabs: Mismatching fragment identifier.");
}
if (toShow.length) {
this.load(this.tabs.index(tab), event);
}
this._toggle(event, eventData);
},
// handles show/hide for selecting tabs
_toggle: function (event, eventData) {
var that = this,
toShow = eventData.newPanel,
toHide = eventData.oldPanel;
this.running = true;
function complete() {
that.running = false;
that._trigger("activate", event, eventData);
}
function show() {
eventData.newTab
.closest("li")
.addClass("ui-tabs-active ui-state-active");
if (toShow.length && that.options.show) {
that._show(toShow, that.options.show, complete);
} else {
toShow.show();
complete();
}
}
// start out by hiding, then showing, then completing
if (toHide.length && this.options.hide) {
this._hide(toHide, this.options.hide, function () {
eventData.oldTab
.closest("li")
.removeClass("ui-tabs-active ui-state-active");
show();
});
} else {
eventData.oldTab
.closest("li")
.removeClass("ui-tabs-active ui-state-active");
toHide.hide();
show();
}
toHide.attr({
"aria-expanded": "false",
"aria-hidden": "true",
});
eventData.oldTab.attr("aria-selected", "false");
// If we're switching tabs, remove the old tab from the tab order.
// If we're opening from collapsed state, remove the previous tab from the tab order.
// If we're collapsing, then keep the collapsing tab in the tab order.
if (toShow.length && toHide.length) {
eventData.oldTab.attr("tabIndex", -1);
} else if (toShow.length) {
this.tabs
.filter(function () {
return $(this).attr("tabIndex") === 0;
})
.attr("tabIndex", -1);
}
toShow.attr({
"aria-expanded": "true",
"aria-hidden": "false",
});
eventData.newTab.attr({
"aria-selected": "true",
tabIndex: 0,
});
},
_activate: function (index) {
var anchor,
active = this._findActive(index);
// trying to activate the already active panel
if (active[0] === this.active[0]) {
return;
}
// trying to collapse, simulate a click on the current active header
if (!active.length) {
active = this.active;
}
anchor = active.find(".ui-tabs-anchor")[0];
this._eventHandler({
target: anchor,
currentTarget: anchor,
preventDefault: $.noop,
});
},
_findActive: function (index) {
return index === false ? $() : this.tabs.eq(index);
},
_getIndex: function (index) {
// meta-function to give users option to provide a href string instead of a numerical index.
if (typeof index === "string") {
index = this.anchors.index(
this.anchors.filter("[href$='" + index + "']"),
);
}
return index;
},
_destroy: function () {
if (this.xhr) {
this.xhr.abort();
}
this.element.removeClass(
"ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible",
);
this.tablist
.removeClass(
"ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all",
)
.removeAttr("role");
this.anchors
.removeClass("ui-tabs-anchor")
.removeAttr("role")
.removeAttr("tabIndex")
.removeUniqueId();
this.tabs.add(this.panels).each(function () {
if ($.data(this, "ui-tabs-destroy")) {
$(this).remove();
} else {
$(this)
.removeClass(
"ui-state-default ui-state-active ui-state-disabled " +
"ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel",
)
.removeAttr("tabIndex")
.removeAttr("aria-live")
.removeAttr("aria-busy")
.removeAttr("aria-selected")
.removeAttr("aria-labelledby")
.removeAttr("aria-hidden")
.removeAttr("aria-expanded")
.removeAttr("role");
}
});
this.tabs.each(function () {
var li = $(this),
prev = li.data("ui-tabs-aria-controls");
if (prev) {
li.attr("aria-controls", prev).removeData("ui-tabs-aria-controls");
} else {
li.removeAttr("aria-controls");
}
});
this.panels.show();
if (this.options.heightStyle !== "content") {
this.panels.css("height", "");
}
},
enable: function (index) {
var disabled = this.options.disabled;
if (disabled === false) {
return;
}
if (index === undefined) {
disabled = false;
} else {
index = this._getIndex(index);
if ($.isArray(disabled)) {
disabled = $.map(disabled, function (num) {
return num !== index ? num : null;
});
} else {
disabled = $.map(this.tabs, function (li, num) {
return num !== index ? num : null;
});
}
}
this._setupDisabled(disabled);
},
disable: function (index) {
var disabled = this.options.disabled;
if (disabled === true) {
return;
}
if (index === undefined) {
disabled = true;
} else {
index = this._getIndex(index);
if ($.inArray(index, disabled) !== -1) {
return;
}
if ($.isArray(disabled)) {
disabled = $.merge([index], disabled).sort();
} else {
disabled = [index];
}
}
this._setupDisabled(disabled);
},
load: function (index, event) {
index = this._getIndex(index);
var that = this,
tab = this.tabs.eq(index),
anchor = tab.find(".ui-tabs-anchor"),
panel = this._getPanelForTab(tab),
eventData = {
tab: tab,
panel: panel,
};
// not remote
if (isLocal(anchor[0])) {
return;
}
this.xhr = $.ajax(this._ajaxSettings(anchor, event, eventData));
// support: jQuery <1.8
// jQuery <1.8 returns false if the request is canceled in beforeSend,
// but as of 1.8, $.ajax() always returns a jqXHR object.
if (this.xhr && this.xhr.statusText !== "canceled") {
tab.addClass("ui-tabs-loading");
panel.attr("aria-busy", "true");
this.xhr
.success(function (response) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function () {
panel.html(response);
that._trigger("load", event, eventData);
}, 1);
})
.complete(function (jqXHR, status) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function () {
if (status === "abort") {
that.panels.stop(false, true);
}
tab.removeClass("ui-tabs-loading");
panel.removeAttr("aria-busy");
if (jqXHR === that.xhr) {
delete that.xhr;
}
}, 1);
});
}
},
_ajaxSettings: function (anchor, event, eventData) {
var that = this;
return {
url: anchor.attr("href"),
beforeSend: function (jqXHR, settings) {
return that._trigger(
"beforeLoad",
event,
$.extend({ jqXHR: jqXHR, ajaxSettings: settings }, eventData),
);
},
};
},
_getPanelForTab: function (tab) {
var id = $(tab).attr("aria-controls");
return this.element.find(this._sanitizeSelector("#" + id));
},
});
})(jQuery);
(function ($, undefined) {})(jQuery);
(function ($, window) {
$.mobile.iosorientationfixEnabled = true;
// This fix addresses an iOS bug, so return early if the UA claims it's something else.
var ua = navigator.userAgent,
zoom,
evt,
x,
y,
z,
aig;
if (
!(
/iPhone|iPad|iPod/.test(navigator.platform) &&
/OS [1-5]_[0-9_]* like Mac OS X/i.test(ua) &&
ua.indexOf("AppleWebKit") > -1
)
) {
$.mobile.iosorientationfixEnabled = false;
return;
}
zoom = $.mobile.zoom;
function checkTilt(e) {
evt = e.originalEvent;
aig = evt.accelerationIncludingGravity;
x = Math.abs(aig.x);
y = Math.abs(aig.y);
z = Math.abs(aig.z);
// If portrait orientation and in one of the danger zones
if (
!window.orientation &&
(x > 7 || (((z > 6 && y < 8) || (z < 8 && y > 6)) && x > 5))
) {
if (zoom.enabled) {
zoom.disable();
}
} else if (!zoom.enabled) {
zoom.enable();
}
}
$.mobile.document.on("mobileinit", function () {
if ($.mobile.iosorientationfixEnabled) {
$.mobile.window
.bind("orientationchange.iosorientationfix", zoom.enable)
.bind("devicemotion.iosorientationfix", checkTilt);
}
});
})(jQuery, this);
(function ($, window, undefined) {
var $html = $("html"),
$window = $.mobile.window;
//remove initial build class (only present on first pageshow)
function hideRenderingClass() {
$html.removeClass("ui-mobile-rendering");
}
// trigger mobileinit event - useful hook for configuring $.mobile settings before they're used
$(window.document).trigger("mobileinit");
// support conditions
// if device support condition(s) aren't met, leave things as they are -> a basic, usable experience,
// otherwise, proceed with the enhancements
if (!$.mobile.gradeA()) {
return;
}
// override ajaxEnabled on platforms that have known conflicts with hash history updates
// or generally work better browsing in regular http for full page refreshes (BB5, Opera Mini)
if ($.mobile.ajaxBlacklist) {
$.mobile.ajaxEnabled = false;
}
// Add mobile, initial load "rendering" classes to docEl
$html.addClass("ui-mobile ui-mobile-rendering");
// This is a fallback. If anything goes wrong (JS errors, etc), or events don't fire,
// this ensures the rendering class is removed after 5 seconds, so content is visible and accessible
setTimeout(hideRenderingClass, 5000);
$.extend($.mobile, {
// find and enhance the pages in the dom and transition to the first page.
initializePage: function () {
// find present pages
var path = $.mobile.path,
$pages = $(":jqmData(role='page'), :jqmData(role='dialog')"),
hash = path.stripHash(
path.stripQueryParams(path.parseLocation().hash),
),
hashPage = document.getElementById(hash);
// if no pages are found, create one with body's inner html
if (!$pages.length) {
$pages = $("body")
.wrapInner("<div data-" + $.mobile.ns + "role='page'></div>")
.children(0);
}
// add dialogs, set data-url attrs
$pages.each(function () {
var $this = $(this);
// unless the data url is already set set it to the pathname
if (!$this[0].getAttribute("data-" + $.mobile.ns + "url")) {
$this.attr(
"data-" + $.mobile.ns + "url",
$this.attr("id") || location.pathname + location.search,
);
}
});
// define first page in dom case one backs out to the directory root (not always the first page visited, but defined as fallback)
$.mobile.firstPage = $pages.first();
// define page container
$.mobile.pageContainer = $.mobile.firstPage
.parent()
.addClass("ui-mobile-viewport")
.pagecontainer();
// initialize navigation events now, after mobileinit has occurred and the page container
// has been created but before the rest of the library is alerted to that fact
$.mobile.navreadyDeferred.resolve();
// alert listeners that the pagecontainer has been determined for binding
// to events triggered on it
$window.trigger("pagecontainercreate");
// cue page loading message
$.mobile.loading("show");
//remove initial build class (only present on first pageshow)
hideRenderingClass();
// if hashchange listening is disabled, there's no hash deeplink,
// the hash is not valid (contains more than one # or does not start with #)
// or there is no page with that hash, change to the first page in the DOM
// Remember, however, that the hash can also be a path!
if (
!(
$.mobile.hashListeningEnabled &&
$.mobile.path.isHashValid(location.hash) &&
($(hashPage).is(":jqmData(role='page')") ||
$.mobile.path.isPath(hash) ||
hash === $.mobile.dialogHashKey)
)
) {
// Store the initial destination
if ($.mobile.path.isHashValid(location.hash)) {
$.mobile.navigate.history.initialDst = hash.replace("#", "");
}
// make sure to set initial popstate state if it exists
// so that navigation back to the initial page works properly
if ($.event.special.navigate.isPushStateEnabled()) {
$.mobile.navigate.navigator.squash(path.parseLocation().href);
}
$.mobile.changePage($.mobile.firstPage, {
transition: "none",
reverse: true,
changeHash: false,
fromHashChange: true,
});
} else {
// trigger hashchange or navigate to squash and record the correct
// history entry for an initial hash path
if (!$.event.special.navigate.isPushStateEnabled()) {
$window.trigger("hashchange", [true]);
} else {
// TODO figure out how to simplify this interaction with the initial history entry
// at the bottom js/navigate/navigate.js
$.mobile.navigate.history.stack = [];
$.mobile.navigate(
$.mobile.path.isPath(location.hash)
? location.hash
: location.href,
);
}
}
},
});
$(function () {
//Run inlineSVG support test
$.support.inlineSVG();
// check which scrollTop value should be used by scrolling to 1 immediately at domready
// then check what the scroll top is. Android will report 0... others 1
// note that this initial scroll won't hide the address bar. It's just for the check.
// hide iOS browser chrome on load if hideUrlBar is true this is to try and do it as soon as possible
if ($.mobile.hideUrlBar) {
window.scrollTo(0, 1);
}
// if defaultHomeScroll hasn't been set yet, see if scrollTop is 1
// it should be 1 in most browsers, but android treats 1 as 0 (for hiding addr bar)
// so if it's 1, use 0 from now on
$.mobile.defaultHomeScroll =
!$.support.scrollTop || $.mobile.window.scrollTop() === 1 ? 0 : 1;
//dom-ready inits
if ($.mobile.autoInitializePage) {
$.mobile.initializePage();
}
// window load event
// hide iOS browser chrome on load if hideUrlBar is true this is as fall back incase we were too early before
if ($.mobile.hideUrlBar) {
$window.load($.mobile.silentScroll);
}
if (!$.support.cssPointerEvents) {
// IE and Opera don't support CSS pointer-events: none that we use to disable link-based buttons
// by adding the 'ui-disabled' class to them. Using a JavaScript workaround for those browser.
// https://github.com/jquery/jquery-mobile/issues/3558
// DEPRECATED as of 1.4.0 - remove ui-disabled after 1.4.0 release
// only ui-state-disabled should be present thereafter
$.mobile.document.delegate(
".ui-state-disabled,.ui-disabled",
"vclick",
function (e) {
e.preventDefault();
e.stopImmediatePropagation();
},
);
}
});
})(jQuery, this);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/mootools-1.4.5.js | JavaScript | /*
---
MooTools: the javascript framework
web build:
- http://mootools.net/core/76bf47062d6c1983d66ce47ad66aa0e0
packager build:
- packager build Core/Core Core/Array Core/String Core/Number Core/Function Core/Object Core/Event Core/Browser Core/Class Core/Class.Extras Core/Slick.Parser Core/Slick.Finder Core/Element Core/Element.Style Core/Element.Event Core/Element.Delegation Core/Element.Dimensions Core/Fx Core/Fx.CSS Core/Fx.Tween Core/Fx.Morph Core/Fx.Transitions Core/Request Core/Request.HTML Core/Request.JSON Core/Cookie Core/JSON Core/DOMReady Core/Swiff
...
*/
/*
---
name: Core
description: The heart of MooTools.
license: MIT-style license.
copyright: Copyright (c) 2006-2012 [Valerio Proietti](http://mad4milk.net/).
authors: The MooTools production team (http://mootools.net/developers/)
inspiration:
- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
- Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)
provides: [Core, MooTools, Type, typeOf, instanceOf, Native]
...
*/
(function () {
this.MooTools = {
version: "1.4.5",
build: "ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0",
};
// typeOf, instanceOf
var typeOf = (this.typeOf = function (item) {
if (item == null) return "null";
if (item.$family != null) return item.$family();
if (item.nodeName) {
if (item.nodeType == 1) return "element";
if (item.nodeType == 3)
return /\S/.test(item.nodeValue) ? "textnode" : "whitespace";
} else if (typeof item.length == "number") {
if (item.callee) return "arguments";
if ("item" in item) return "collection";
}
return typeof item;
});
var instanceOf = (this.instanceOf = function (item, object) {
if (item == null) return false;
var constructor = item.$constructor || item.constructor;
while (constructor) {
if (constructor === object) return true;
constructor = constructor.parent;
}
/*<ltIE8>*/
if (!item.hasOwnProperty) return false;
/*</ltIE8>*/
return item instanceof object;
});
// Function overloading
var Function = this.Function;
var enumerables = true;
for (var i in { toString: 1 }) enumerables = null;
if (enumerables)
enumerables = [
"hasOwnProperty",
"valueOf",
"isPrototypeOf",
"propertyIsEnumerable",
"toLocaleString",
"toString",
"constructor",
];
Function.prototype.overloadSetter = function (usePlural) {
var self = this;
return function (a, b) {
if (a == null) return this;
if (usePlural || typeof a != "string") {
for (var k in a) self.call(this, k, a[k]);
if (enumerables)
for (var i = enumerables.length; i--; ) {
k = enumerables[i];
if (a.hasOwnProperty(k)) self.call(this, k, a[k]);
}
} else {
self.call(this, a, b);
}
return this;
};
};
Function.prototype.overloadGetter = function (usePlural) {
var self = this;
return function (a) {
var args, result;
if (typeof a != "string") args = a;
else if (arguments.length > 1) args = arguments;
else if (usePlural) args = [a];
if (args) {
result = {};
for (var i = 0; i < args.length; i++)
result[args[i]] = self.call(this, args[i]);
} else {
result = self.call(this, a);
}
return result;
};
};
Function.prototype.extend = function (key, value) {
this[key] = value;
}.overloadSetter();
Function.prototype.implement = function (key, value) {
this.prototype[key] = value;
}.overloadSetter();
// From
var slice = Array.prototype.slice;
Function.from = function (item) {
return typeOf(item) == "function"
? item
: function () {
return item;
};
};
Array.from = function (item) {
if (item == null) return [];
return Type.isEnumerable(item) && typeof item != "string"
? typeOf(item) == "array"
? item
: slice.call(item)
: [item];
};
Number.from = function (item) {
var number = parseFloat(item);
return isFinite(number) ? number : null;
};
String.from = function (item) {
return item + "";
};
// hide, protect
Function.implement({
hide: function () {
this.$hidden = true;
return this;
},
protect: function () {
this.$protected = true;
return this;
},
});
// Type
var Type = (this.Type = function (name, object) {
if (name) {
var lower = name.toLowerCase();
var typeCheck = function (item) {
return typeOf(item) == lower;
};
Type["is" + name] = typeCheck;
if (object != null) {
object.prototype.$family = function () {
return lower;
}.hide();
//<1.2compat>
object.type = typeCheck;
//</1.2compat>
}
}
if (object == null) return null;
object.extend(this);
object.$constructor = Type;
object.prototype.$constructor = object;
return object;
});
var toString = Object.prototype.toString;
Type.isEnumerable = function (item) {
return (
item != null &&
typeof item.length == "number" &&
toString.call(item) != "[object Function]"
);
};
var hooks = {};
var hooksOf = function (object) {
var type = typeOf(object.prototype);
return hooks[type] || (hooks[type] = []);
};
var implement = function (name, method) {
if (method && method.$hidden) return;
var hooks = hooksOf(this);
for (var i = 0; i < hooks.length; i++) {
var hook = hooks[i];
if (typeOf(hook) == "type") implement.call(hook, name, method);
else hook.call(this, name, method);
}
var previous = this.prototype[name];
if (previous == null || !previous.$protected) this.prototype[name] = method;
if (this[name] == null && typeOf(method) == "function")
extend.call(this, name, function (item) {
return method.apply(item, slice.call(arguments, 1));
});
};
var extend = function (name, method) {
if (method && method.$hidden) return;
var previous = this[name];
if (previous == null || !previous.$protected) this[name] = method;
};
Type.implement({
implement: implement.overloadSetter(),
extend: extend.overloadSetter(),
alias: function (name, existing) {
implement.call(this, name, this.prototype[existing]);
}.overloadSetter(),
mirror: function (hook) {
hooksOf(this).push(hook);
return this;
},
});
new Type("Type", Type);
// Default Types
var force = function (name, object, methods) {
var isType = object != Object,
prototype = object.prototype;
if (isType) object = new Type(name, object);
for (var i = 0, l = methods.length; i < l; i++) {
var key = methods[i],
generic = object[key],
proto = prototype[key];
if (generic) generic.protect();
if (isType && proto) object.implement(key, proto.protect());
}
if (isType) {
var methodsEnumerable = prototype.propertyIsEnumerable(methods[0]);
object.forEachMethod = function (fn) {
if (!methodsEnumerable)
for (var i = 0, l = methods.length; i < l; i++) {
fn.call(prototype, prototype[methods[i]], methods[i]);
}
for (var key in prototype) fn.call(prototype, prototype[key], key);
};
}
return force;
};
force("String", String, [
"charAt",
"charCodeAt",
"concat",
"indexOf",
"lastIndexOf",
"match",
"quote",
"replace",
"search",
"slice",
"split",
"substr",
"substring",
"trim",
"toLowerCase",
"toUpperCase",
])("Array", Array, [
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift",
"concat",
"join",
"slice",
"indexOf",
"lastIndexOf",
"filter",
"forEach",
"every",
"map",
"some",
"reduce",
"reduceRight",
])("Number", Number, [
"toExponential",
"toFixed",
"toLocaleString",
"toPrecision",
])("Function", Function, ["apply", "call", "bind"])("RegExp", RegExp, [
"exec",
"test",
])("Object", Object, [
"create",
"defineProperty",
"defineProperties",
"keys",
"getPrototypeOf",
"getOwnPropertyDescriptor",
"getOwnPropertyNames",
"preventExtensions",
"isExtensible",
"seal",
"isSealed",
"freeze",
"isFrozen",
])("Date", Date, ["now"]);
Object.extend = extend.overloadSetter();
Date.extend("now", function () {
return +new Date();
});
new Type("Boolean", Boolean);
// fixes NaN returning as Number
Number.prototype.$family = function () {
return isFinite(this) ? "number" : "null";
}.hide();
// Number.random
Number.extend("random", function (min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
});
// forEach, each
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend("forEach", function (object, fn, bind) {
for (var key in object) {
if (hasOwnProperty.call(object, key))
fn.call(bind, object[key], key, object);
}
});
Object.each = Object.forEach;
Array.implement({
forEach: function (fn, bind) {
for (var i = 0, l = this.length; i < l; i++) {
if (i in this) fn.call(bind, this[i], i, this);
}
},
each: function (fn, bind) {
Array.forEach(this, fn, bind);
return this;
},
});
// Array & Object cloning, Object merging and appending
var cloneOf = function (item) {
switch (typeOf(item)) {
case "array":
return item.clone();
case "object":
return Object.clone(item);
default:
return item;
}
};
Array.implement("clone", function () {
var i = this.length,
clone = new Array(i);
while (i--) clone[i] = cloneOf(this[i]);
return clone;
});
var mergeOne = function (source, key, current) {
switch (typeOf(current)) {
case "object":
if (typeOf(source[key]) == "object") Object.merge(source[key], current);
else source[key] = Object.clone(current);
break;
case "array":
source[key] = current.clone();
break;
default:
source[key] = current;
}
return source;
};
Object.extend({
merge: function (source, k, v) {
if (typeOf(k) == "string") return mergeOne(source, k, v);
for (var i = 1, l = arguments.length; i < l; i++) {
var object = arguments[i];
for (var key in object) mergeOne(source, key, object[key]);
}
return source;
},
clone: function (object) {
var clone = {};
for (var key in object) clone[key] = cloneOf(object[key]);
return clone;
},
append: function (original) {
for (var i = 1, l = arguments.length; i < l; i++) {
var extended = arguments[i] || {};
for (var key in extended) original[key] = extended[key];
}
return original;
},
});
// Object-less types
["Object", "WhiteSpace", "TextNode", "Collection", "Arguments"].each(
function (name) {
new Type(name);
},
);
// Unique ID
var UID = Date.now();
String.extend("uniqueID", function () {
return (UID++).toString(36);
});
//<1.2compat>
var Hash = (this.Hash = new Type("Hash", function (object) {
if (typeOf(object) == "hash") object = Object.clone(object.getClean());
for (var key in object) this[key] = object[key];
return this;
}));
Hash.implement({
forEach: function (fn, bind) {
Object.forEach(this, fn, bind);
},
getClean: function () {
var clean = {};
for (var key in this) {
if (this.hasOwnProperty(key)) clean[key] = this[key];
}
return clean;
},
getLength: function () {
var length = 0;
for (var key in this) {
if (this.hasOwnProperty(key)) length++;
}
return length;
},
});
Hash.alias("each", "forEach");
Object.type = Type.isObject;
var Native = (this.Native = function (properties) {
return new Type(properties.name, properties.initialize);
});
Native.type = Type.type;
Native.implement = function (objects, methods) {
for (var i = 0; i < objects.length; i++) objects[i].implement(methods);
return Native;
};
var arrayType = Array.type;
Array.type = function (item) {
return instanceOf(item, Array) || arrayType(item);
};
this.$A = function (item) {
return Array.from(item).slice();
};
this.$arguments = function (i) {
return function () {
return arguments[i];
};
};
this.$chk = function (obj) {
return !!(obj || obj === 0);
};
this.$clear = function (timer) {
clearTimeout(timer);
clearInterval(timer);
return null;
};
this.$defined = function (obj) {
return obj != null;
};
this.$each = function (iterable, fn, bind) {
var type = typeOf(iterable);
(type == "arguments" ||
type == "collection" ||
type == "array" ||
type == "elements"
? Array
: Object
).each(iterable, fn, bind);
};
this.$empty = function () {};
this.$extend = function (original, extended) {
return Object.append(original, extended);
};
this.$H = function (object) {
return new Hash(object);
};
this.$merge = function () {
var args = Array.slice(arguments);
args.unshift({});
return Object.merge.apply(null, args);
};
this.$lambda = Function.from;
this.$mixin = Object.merge;
this.$random = Number.random;
this.$splat = Array.from;
this.$time = Date.now;
this.$type = function (object) {
var type = typeOf(object);
if (type == "elements") return "array";
return type == "null" ? false : type;
};
this.$unlink = function (object) {
switch (typeOf(object)) {
case "object":
return Object.clone(object);
case "array":
return Array.clone(object);
case "hash":
return new Hash(object);
default:
return object;
}
};
//</1.2compat>
})();
/*
---
name: Array
description: Contains Array Prototypes like each, contains, and erase.
license: MIT-style license.
requires: Type
provides: Array
...
*/
Array.implement({
/*<!ES5>*/
every: function (fn, bind) {
for (var i = 0, l = this.length >>> 0; i < l; i++) {
if (i in this && !fn.call(bind, this[i], i, this)) return false;
}
return true;
},
filter: function (fn, bind) {
var results = [];
for (var value, i = 0, l = this.length >>> 0; i < l; i++)
if (i in this) {
value = this[i];
if (fn.call(bind, value, i, this)) results.push(value);
}
return results;
},
indexOf: function (item, from) {
var length = this.length >>> 0;
for (
var i = from < 0 ? Math.max(0, length + from) : from || 0;
i < length;
i++
) {
if (this[i] === item) return i;
}
return -1;
},
map: function (fn, bind) {
var length = this.length >>> 0,
results = Array(length);
for (var i = 0; i < length; i++) {
if (i in this) results[i] = fn.call(bind, this[i], i, this);
}
return results;
},
some: function (fn, bind) {
for (var i = 0, l = this.length >>> 0; i < l; i++) {
if (i in this && fn.call(bind, this[i], i, this)) return true;
}
return false;
},
/*</!ES5>*/
clean: function () {
return this.filter(function (item) {
return item != null;
});
},
invoke: function (methodName) {
var args = Array.slice(arguments, 1);
return this.map(function (item) {
return item[methodName].apply(item, args);
});
},
associate: function (keys) {
var obj = {},
length = Math.min(this.length, keys.length);
for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
return obj;
},
link: function (object) {
var result = {};
for (var i = 0, l = this.length; i < l; i++) {
for (var key in object) {
if (object[key](this[i])) {
result[key] = this[i];
delete object[key];
break;
}
}
}
return result;
},
contains: function (item, from) {
return this.indexOf(item, from) != -1;
},
append: function (array) {
this.push.apply(this, array);
return this;
},
getLast: function () {
return this.length ? this[this.length - 1] : null;
},
getRandom: function () {
return this.length ? this[Number.random(0, this.length - 1)] : null;
},
include: function (item) {
if (!this.contains(item)) this.push(item);
return this;
},
combine: function (array) {
for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
return this;
},
erase: function (item) {
for (var i = this.length; i--; ) {
if (this[i] === item) this.splice(i, 1);
}
return this;
},
empty: function () {
this.length = 0;
return this;
},
flatten: function () {
var array = [];
for (var i = 0, l = this.length; i < l; i++) {
var type = typeOf(this[i]);
if (type == "null") continue;
array = array.concat(
type == "array" ||
type == "collection" ||
type == "arguments" ||
instanceOf(this[i], Array)
? Array.flatten(this[i])
: this[i],
);
}
return array;
},
pick: function () {
for (var i = 0, l = this.length; i < l; i++) {
if (this[i] != null) return this[i];
}
return null;
},
hexToRgb: function (array) {
if (this.length != 3) return null;
var rgb = this.map(function (value) {
if (value.length == 1) value += value;
return value.toInt(16);
});
return array ? rgb : "rgb(" + rgb + ")";
},
rgbToHex: function (array) {
if (this.length < 3) return null;
if (this.length == 4 && this[3] == 0 && !array) return "transparent";
var hex = [];
for (var i = 0; i < 3; i++) {
var bit = (this[i] - 0).toString(16);
hex.push(bit.length == 1 ? "0" + bit : bit);
}
return array ? hex : "#" + hex.join("");
},
});
//<1.2compat>
Array.alias("extend", "append");
var $pick = function () {
return Array.from(arguments).pick();
};
//</1.2compat>
/*
---
name: String
description: Contains String Prototypes like camelCase, capitalize, test, and toInt.
license: MIT-style license.
requires: Type
provides: String
...
*/
String.implement({
test: function (regex, params) {
return (
typeOf(regex) == "regexp" ? regex : new RegExp("" + regex, params)
).test(this);
},
contains: function (string, separator) {
return separator
? (separator + this + separator).indexOf(separator + string + separator) >
-1
: String(this).indexOf(string) > -1;
},
trim: function () {
return String(this).replace(/^\s+|\s+$/g, "");
},
clean: function () {
return String(this).replace(/\s+/g, " ").trim();
},
camelCase: function () {
return String(this).replace(/-\D/g, function (match) {
return match.charAt(1).toUpperCase();
});
},
hyphenate: function () {
return String(this).replace(/[A-Z]/g, function (match) {
return "-" + match.charAt(0).toLowerCase();
});
},
capitalize: function () {
return String(this).replace(/\b[a-z]/g, function (match) {
return match.toUpperCase();
});
},
escapeRegExp: function () {
return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
},
toInt: function (base) {
return parseInt(this, base || 10);
},
toFloat: function () {
return parseFloat(this);
},
hexToRgb: function (array) {
var hex = String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
return hex ? hex.slice(1).hexToRgb(array) : null;
},
rgbToHex: function (array) {
var rgb = String(this).match(/\d{1,3}/g);
return rgb ? rgb.rgbToHex(array) : null;
},
substitute: function (object, regexp) {
return String(this).replace(
regexp || /\\?\{([^{}]+)\}/g,
function (match, name) {
if (match.charAt(0) == "\\") return match.slice(1);
return object[name] != null ? object[name] : "";
},
);
},
});
/*
---
name: Number
description: Contains Number Prototypes like limit, round, times, and ceil.
license: MIT-style license.
requires: Type
provides: Number
...
*/
Number.implement({
limit: function (min, max) {
return Math.min(max, Math.max(min, this));
},
round: function (precision) {
precision = Math.pow(10, precision || 0).toFixed(
precision < 0 ? -precision : 0,
);
return Math.round(this * precision) / precision;
},
times: function (fn, bind) {
for (var i = 0; i < this; i++) fn.call(bind, i, this);
},
toFloat: function () {
return parseFloat(this);
},
toInt: function (base) {
return parseInt(this, base || 10);
},
});
Number.alias("each", "times");
(function (math) {
var methods = {};
math.each(function (name) {
if (!Number[name])
methods[name] = function () {
return Math[name].apply(null, [this].concat(Array.from(arguments)));
};
});
Number.implement(methods);
})([
"abs",
"acos",
"asin",
"atan",
"atan2",
"ceil",
"cos",
"exp",
"floor",
"log",
"max",
"min",
"pow",
"sin",
"sqrt",
"tan",
]);
/*
---
name: Function
description: Contains Function Prototypes like create, bind, pass, and delay.
license: MIT-style license.
requires: Type
provides: Function
...
*/
Function.extend({
attempt: function () {
for (var i = 0, l = arguments.length; i < l; i++) {
try {
return arguments[i]();
} catch (e) {}
}
return null;
},
});
Function.implement({
attempt: function (args, bind) {
try {
return this.apply(bind, Array.from(args));
} catch (e) {}
return null;
},
/*<!ES5-bind>*/
bind: function (that) {
var self = this,
args = arguments.length > 1 ? Array.slice(arguments, 1) : null,
F = function () {};
var bound = function () {
var context = that,
length = arguments.length;
if (this instanceof bound) {
F.prototype = self.prototype;
context = new F();
}
var result =
!args && !length
? self.call(context)
: self.apply(
context,
args && length
? args.concat(Array.slice(arguments))
: args || arguments,
);
return context == that ? result : context;
};
return bound;
},
/*</!ES5-bind>*/
pass: function (args, bind) {
var self = this;
if (args != null) args = Array.from(args);
return function () {
return self.apply(bind, args || arguments);
};
},
delay: function (delay, bind, args) {
return setTimeout(this.pass(args == null ? [] : args, bind), delay);
},
periodical: function (periodical, bind, args) {
return setInterval(this.pass(args == null ? [] : args, bind), periodical);
},
});
//<1.2compat>
delete Function.prototype.bind;
Function.implement({
create: function (options) {
var self = this;
options = options || {};
return function (event) {
var args = options.arguments;
args =
args != null
? Array.from(args)
: Array.slice(arguments, options.event ? 1 : 0);
if (options.event) args = [event || window.event].extend(args);
var returns = function () {
return self.apply(options.bind || null, args);
};
if (options.delay) return setTimeout(returns, options.delay);
if (options.periodical) return setInterval(returns, options.periodical);
if (options.attempt) return Function.attempt(returns);
return returns();
};
},
bind: function (bind, args) {
var self = this;
if (args != null) args = Array.from(args);
return function () {
return self.apply(bind, args || arguments);
};
},
bindWithEvent: function (bind, args) {
var self = this;
if (args != null) args = Array.from(args);
return function (event) {
return self.apply(bind, args == null ? arguments : [event].concat(args));
};
},
run: function (args, bind) {
return this.apply(bind, Array.from(args));
},
});
if (Object.create == Function.prototype.create) Object.create = null;
var $try = Function.attempt;
//</1.2compat>
/*
---
name: Object
description: Object generic methods
license: MIT-style license.
requires: Type
provides: [Object, Hash]
...
*/
(function () {
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend({
subset: function (object, keys) {
var results = {};
for (var i = 0, l = keys.length; i < l; i++) {
var k = keys[i];
if (k in object) results[k] = object[k];
}
return results;
},
map: function (object, fn, bind) {
var results = {};
for (var key in object) {
if (hasOwnProperty.call(object, key))
results[key] = fn.call(bind, object[key], key, object);
}
return results;
},
filter: function (object, fn, bind) {
var results = {};
for (var key in object) {
var value = object[key];
if (
hasOwnProperty.call(object, key) &&
fn.call(bind, value, key, object)
)
results[key] = value;
}
return results;
},
every: function (object, fn, bind) {
for (var key in object) {
if (
hasOwnProperty.call(object, key) &&
!fn.call(bind, object[key], key)
)
return false;
}
return true;
},
some: function (object, fn, bind) {
for (var key in object) {
if (hasOwnProperty.call(object, key) && fn.call(bind, object[key], key))
return true;
}
return false;
},
keys: function (object) {
var keys = [];
for (var key in object) {
if (hasOwnProperty.call(object, key)) keys.push(key);
}
return keys;
},
values: function (object) {
var values = [];
for (var key in object) {
if (hasOwnProperty.call(object, key)) values.push(object[key]);
}
return values;
},
getLength: function (object) {
return Object.keys(object).length;
},
keyOf: function (object, value) {
for (var key in object) {
if (hasOwnProperty.call(object, key) && object[key] === value)
return key;
}
return null;
},
contains: function (object, value) {
return Object.keyOf(object, value) != null;
},
toQueryString: function (object, base) {
var queryString = [];
Object.each(object, function (value, key) {
if (base) key = base + "[" + key + "]";
var result;
switch (typeOf(value)) {
case "object":
result = Object.toQueryString(value, key);
break;
case "array":
var qs = {};
value.each(function (val, i) {
qs[i] = val;
});
result = Object.toQueryString(qs, key);
break;
default:
result = key + "=" + encodeURIComponent(value);
}
if (value != null) queryString.push(result);
});
return queryString.join("&");
},
});
})();
//<1.2compat>
Hash.implement({
has: Object.prototype.hasOwnProperty,
keyOf: function (value) {
return Object.keyOf(this, value);
},
hasValue: function (value) {
return Object.contains(this, value);
},
extend: function (properties) {
Hash.each(
properties || {},
function (value, key) {
Hash.set(this, key, value);
},
this,
);
return this;
},
combine: function (properties) {
Hash.each(
properties || {},
function (value, key) {
Hash.include(this, key, value);
},
this,
);
return this;
},
erase: function (key) {
if (this.hasOwnProperty(key)) delete this[key];
return this;
},
get: function (key) {
return this.hasOwnProperty(key) ? this[key] : null;
},
set: function (key, value) {
if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
return this;
},
empty: function () {
Hash.each(
this,
function (value, key) {
delete this[key];
},
this,
);
return this;
},
include: function (key, value) {
if (this[key] == null) this[key] = value;
return this;
},
map: function (fn, bind) {
return new Hash(Object.map(this, fn, bind));
},
filter: function (fn, bind) {
return new Hash(Object.filter(this, fn, bind));
},
every: function (fn, bind) {
return Object.every(this, fn, bind);
},
some: function (fn, bind) {
return Object.some(this, fn, bind);
},
getKeys: function () {
return Object.keys(this);
},
getValues: function () {
return Object.values(this);
},
toQueryString: function (base) {
return Object.toQueryString(this, base);
},
});
Hash.extend = Object.append;
Hash.alias({ indexOf: "keyOf", contains: "hasValue" });
//</1.2compat>
/*
---
name: Browser
description: The Browser Object. Contains Browser initialization, Window and Document, and the Browser Hash.
license: MIT-style license.
requires: [Array, Function, Number, String]
provides: [Browser, Window, Document]
...
*/
(function () {
var document = this.document;
var window = (document.window = this);
var ua = navigator.userAgent.toLowerCase(),
platform = navigator.platform.toLowerCase(),
UA = ua.match(
/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/,
) || [null, "unknown", 0],
mode = UA[1] == "ie" && document.documentMode;
var Browser = (this.Browser = {
extend: Function.prototype.extend,
name: UA[1] == "version" ? UA[3] : UA[1],
version: mode || parseFloat(UA[1] == "opera" && UA[4] ? UA[4] : UA[2]),
Platform: {
name: ua.match(/ip(?:ad|od|hone)/)
? "ios"
: (ua.match(/(?:webos|android)/) ||
platform.match(/mac|win|linux/) || ["other"])[0],
},
Features: {
xpath: !!document.evaluate,
air: !!window.runtime,
query: !!document.querySelector,
json: !!window.JSON,
},
Plugins: {},
});
Browser[Browser.name] = true;
Browser[Browser.name + parseInt(Browser.version, 10)] = true;
Browser.Platform[Browser.Platform.name] = true;
// Request
Browser.Request = (function () {
var XMLHTTP = function () {
return new XMLHttpRequest();
};
var MSXML2 = function () {
return new ActiveXObject("MSXML2.XMLHTTP");
};
var MSXML = function () {
return new ActiveXObject("Microsoft.XMLHTTP");
};
return Function.attempt(
function () {
XMLHTTP();
return XMLHTTP;
},
function () {
MSXML2();
return MSXML2;
},
function () {
MSXML();
return MSXML;
},
);
})();
Browser.Features.xhr = !!Browser.Request;
// Flash detection
var version = (
Function.attempt(
function () {
return navigator.plugins["Shockwave Flash"].description;
},
function () {
return new ActiveXObject("ShockwaveFlash.ShockwaveFlash").GetVariable(
"$version",
);
},
) || "0 r0"
).match(/\d+/g);
Browser.Plugins.Flash = {
version: Number(version[0] || "0." + version[1]) || 0,
build: Number(version[2]) || 0,
};
// String scripts
Browser.exec = function (text) {
if (!text) return text;
if (window.execScript) {
window.execScript(text);
} else {
var script = document.createElement("script");
script.setAttribute("type", "text/javascript");
script.text = text;
document.head.appendChild(script);
document.head.removeChild(script);
}
return text;
};
String.implement("stripScripts", function (exec) {
var scripts = "";
var text = this.replace(
/<script[^>]*>([\s\S]*?)<\/script>/gi,
function (all, code) {
scripts += code + "\n";
return "";
},
);
if (exec === true) Browser.exec(scripts);
else if (typeOf(exec) == "function") exec(scripts, text);
return text;
});
// Window, Document
Browser.extend({
Document: this.Document,
Window: this.Window,
Element: this.Element,
Event: this.Event,
});
this.Window = this.$constructor = new Type("Window", function () {});
this.$family = Function.from("window").hide();
Window.mirror(function (name, method) {
window[name] = method;
});
this.Document = document.$constructor = new Type("Document", function () {});
document.$family = Function.from("document").hide();
Document.mirror(function (name, method) {
document[name] = method;
});
document.html = document.documentElement;
if (!document.head) document.head = document.getElementsByTagName("head")[0];
if (document.execCommand)
try {
document.execCommand("BackgroundImageCache", false, true);
} catch (e) {}
/*<ltIE9>*/
if (this.attachEvent && !this.addEventListener) {
var unloadEvent = function () {
this.detachEvent("onunload", unloadEvent);
document.head = document.html = document.window = null;
};
this.attachEvent("onunload", unloadEvent);
}
// IE fails on collections and <select>.options (refers to <select>)
var arrayFrom = Array.from;
try {
arrayFrom(document.html.childNodes);
} catch (e) {
Array.from = function (item) {
if (
typeof item != "string" &&
Type.isEnumerable(item) &&
typeOf(item) != "array"
) {
var i = item.length,
array = new Array(i);
while (i--) array[i] = item[i];
return array;
}
return arrayFrom(item);
};
var prototype = Array.prototype,
slice = prototype.slice;
[
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift",
"concat",
"join",
"slice",
].each(function (name) {
var method = prototype[name];
Array[name] = function (item) {
return method.apply(Array.from(item), slice.call(arguments, 1));
};
});
}
/*</ltIE9>*/
//<1.2compat>
if (Browser.Platform.ios) Browser.Platform.ipod = true;
Browser.Engine = {};
var setEngine = function (name, version) {
Browser.Engine.name = name;
Browser.Engine[name + version] = true;
Browser.Engine.version = version;
};
if (Browser.ie) {
Browser.Engine.trident = true;
switch (Browser.version) {
case 6:
setEngine("trident", 4);
break;
case 7:
setEngine("trident", 5);
break;
case 8:
setEngine("trident", 6);
}
}
if (Browser.firefox) {
Browser.Engine.gecko = true;
if (Browser.version >= 3) setEngine("gecko", 19);
else setEngine("gecko", 18);
}
if (Browser.safari || Browser.chrome) {
Browser.Engine.webkit = true;
switch (Browser.version) {
case 2:
setEngine("webkit", 419);
break;
case 3:
setEngine("webkit", 420);
break;
case 4:
setEngine("webkit", 525);
}
}
if (Browser.opera) {
Browser.Engine.presto = true;
if (Browser.version >= 9.6) setEngine("presto", 960);
else if (Browser.version >= 9.5) setEngine("presto", 950);
else setEngine("presto", 925);
}
if (Browser.name == "unknown") {
switch ((ua.match(/(?:webkit|khtml|gecko)/) || [])[0]) {
case "webkit":
case "khtml":
Browser.Engine.webkit = true;
break;
case "gecko":
Browser.Engine.gecko = true;
}
}
this.$exec = Browser.exec;
//</1.2compat>
})();
/*
---
name: Event
description: Contains the Event Type, to make the event object cross-browser.
license: MIT-style license.
requires: [Window, Document, Array, Function, String, Object]
provides: Event
...
*/
(function () {
var _keys = {};
var DOMEvent = (this.DOMEvent = new Type("DOMEvent", function (event, win) {
if (!win) win = window;
event = event || win.event;
if (event.$extended) return event;
this.event = event;
this.$extended = true;
this.shift = event.shiftKey;
this.control = event.ctrlKey;
this.alt = event.altKey;
this.meta = event.metaKey;
var type = (this.type = event.type);
var target = event.target || event.srcElement;
while (target && target.nodeType == 3) target = target.parentNode;
this.target = document.id(target);
if (type.indexOf("key") == 0) {
var code = (this.code = event.which || event.keyCode);
this.key =
_keys[code] /*<1.3compat>*/ ||
Object.keyOf(Event.Keys, code) /*</1.3compat>*/;
if (type == "keydown") {
if (code > 111 && code < 124) this.key = "f" + (code - 111);
else if (code > 95 && code < 106) this.key = code - 96;
}
if (this.key == null) this.key = String.fromCharCode(code).toLowerCase();
} else if (
type == "click" ||
type == "dblclick" ||
type == "contextmenu" ||
type == "DOMMouseScroll" ||
type.indexOf("mouse") == 0
) {
var doc = win.document;
doc =
!doc.compatMode || doc.compatMode == "CSS1Compat" ? doc.html : doc.body;
this.page = {
x: event.pageX != null ? event.pageX : event.clientX + doc.scrollLeft,
y: event.pageY != null ? event.pageY : event.clientY + doc.scrollTop,
};
this.client = {
x: event.pageX != null ? event.pageX - win.pageXOffset : event.clientX,
y: event.pageY != null ? event.pageY - win.pageYOffset : event.clientY,
};
if (type == "DOMMouseScroll" || type == "mousewheel")
this.wheel = event.wheelDelta
? event.wheelDelta / 120
: -(event.detail || 0) / 3;
this.rightClick = event.which == 3 || event.button == 2;
if (type == "mouseover" || type == "mouseout") {
var related =
event.relatedTarget ||
event[(type == "mouseover" ? "from" : "to") + "Element"];
while (related && related.nodeType == 3) related = related.parentNode;
this.relatedTarget = document.id(related);
}
} else if (type.indexOf("touch") == 0 || type.indexOf("gesture") == 0) {
this.rotation = event.rotation;
this.scale = event.scale;
this.targetTouches = event.targetTouches;
this.changedTouches = event.changedTouches;
var touches = (this.touches = event.touches);
if (touches && touches[0]) {
var touch = touches[0];
this.page = { x: touch.pageX, y: touch.pageY };
this.client = { x: touch.clientX, y: touch.clientY };
}
}
if (!this.client) this.client = {};
if (!this.page) this.page = {};
}));
DOMEvent.implement({
stop: function () {
return this.preventDefault().stopPropagation();
},
stopPropagation: function () {
if (this.event.stopPropagation) this.event.stopPropagation();
else this.event.cancelBubble = true;
return this;
},
preventDefault: function () {
if (this.event.preventDefault) this.event.preventDefault();
else this.event.returnValue = false;
return this;
},
});
DOMEvent.defineKey = function (code, key) {
_keys[code] = key;
return this;
};
DOMEvent.defineKeys = DOMEvent.defineKey.overloadSetter(true);
DOMEvent.defineKeys({
38: "up",
40: "down",
37: "left",
39: "right",
27: "esc",
32: "space",
8: "backspace",
9: "tab",
46: "delete",
13: "enter",
});
})();
/*<1.3compat>*/
var Event = DOMEvent;
Event.Keys = {};
/*</1.3compat>*/
/*<1.2compat>*/
Event.Keys = new Hash(Event.Keys);
/*</1.2compat>*/
/*
---
name: Class
description: Contains the Class Function for easily creating, extending, and implementing reusable Classes.
license: MIT-style license.
requires: [Array, String, Function, Number]
provides: Class
...
*/
(function () {
var Class = (this.Class = new Type("Class", function (params) {
if (instanceOf(params, Function)) params = { initialize: params };
var newClass = function () {
reset(this);
if (newClass.$prototyping) return this;
this.$caller = null;
var value = this.initialize
? this.initialize.apply(this, arguments)
: this;
this.$caller = this.caller = null;
return value;
}
.extend(this)
.implement(params);
newClass.$constructor = Class;
newClass.prototype.$constructor = newClass;
newClass.prototype.parent = parent;
return newClass;
}));
var parent = function () {
if (!this.$caller) throw new Error('The method "parent" cannot be called.');
var name = this.$caller.$name,
parent = this.$caller.$owner.parent,
previous = parent ? parent.prototype[name] : null;
if (!previous) throw new Error('The method "' + name + '" has no parent.');
return previous.apply(this, arguments);
};
var reset = function (object) {
for (var key in object) {
var value = object[key];
switch (typeOf(value)) {
case "object":
var F = function () {};
F.prototype = value;
object[key] = reset(new F());
break;
case "array":
object[key] = value.clone();
break;
}
}
return object;
};
var wrap = function (self, key, method) {
if (method.$origin) method = method.$origin;
var wrapper = function () {
if (method.$protected && this.$caller == null)
throw new Error('The method "' + key + '" cannot be called.');
var caller = this.caller,
current = this.$caller;
this.caller = current;
this.$caller = wrapper;
var result = method.apply(this, arguments);
this.$caller = current;
this.caller = caller;
return result;
}.extend({ $owner: self, $origin: method, $name: key });
return wrapper;
};
var implement = function (key, value, retain) {
if (Class.Mutators.hasOwnProperty(key)) {
value = Class.Mutators[key].call(this, value);
if (value == null) return this;
}
if (typeOf(value) == "function") {
if (value.$hidden) return this;
this.prototype[key] = retain ? value : wrap(this, key, value);
} else {
Object.merge(this.prototype, key, value);
}
return this;
};
var getInstance = function (klass) {
klass.$prototyping = true;
var proto = new klass();
delete klass.$prototyping;
return proto;
};
Class.implement("implement", implement.overloadSetter());
Class.Mutators = {
Extends: function (parent) {
this.parent = parent;
this.prototype = getInstance(parent);
},
Implements: function (items) {
Array.from(items).each(function (item) {
var instance = new item();
for (var key in instance)
implement.call(this, key, instance[key], true);
}, this);
},
};
})();
/*
---
name: Class.Extras
description: Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
license: MIT-style license.
requires: Class
provides: [Class.Extras, Chain, Events, Options]
...
*/
(function () {
this.Chain = new Class({
$chain: [],
chain: function () {
this.$chain.append(Array.flatten(arguments));
return this;
},
callChain: function () {
return this.$chain.length
? this.$chain.shift().apply(this, arguments)
: false;
},
clearChain: function () {
this.$chain.empty();
return this;
},
});
var removeOn = function (string) {
return string.replace(/^on([A-Z])/, function (full, first) {
return first.toLowerCase();
});
};
this.Events = new Class({
$events: {},
addEvent: function (type, fn, internal) {
type = removeOn(type);
/*<1.2compat>*/
if (fn == $empty) return this;
/*</1.2compat>*/
this.$events[type] = (this.$events[type] || []).include(fn);
if (internal) fn.internal = true;
return this;
},
addEvents: function (events) {
for (var type in events) this.addEvent(type, events[type]);
return this;
},
fireEvent: function (type, args, delay) {
type = removeOn(type);
var events = this.$events[type];
if (!events) return this;
args = Array.from(args);
events.each(function (fn) {
if (delay) fn.delay(delay, this, args);
else fn.apply(this, args);
}, this);
return this;
},
removeEvent: function (type, fn) {
type = removeOn(type);
var events = this.$events[type];
if (events && !fn.internal) {
var index = events.indexOf(fn);
if (index != -1) delete events[index];
}
return this;
},
removeEvents: function (events) {
var type;
if (typeOf(events) == "object") {
for (type in events) this.removeEvent(type, events[type]);
return this;
}
if (events) events = removeOn(events);
for (type in this.$events) {
if (events && events != type) continue;
var fns = this.$events[type];
for (var i = fns.length; i--; )
if (i in fns) {
this.removeEvent(type, fns[i]);
}
}
return this;
},
});
this.Options = new Class({
setOptions: function () {
var options = (this.options = Object.merge.apply(
null,
[{}, this.options].append(arguments),
));
if (this.addEvent)
for (var option in options) {
if (typeOf(options[option]) != "function" || !/^on[A-Z]/.test(option))
continue;
this.addEvent(option, options[option]);
delete options[option];
}
return this;
},
});
})();
/*
---
name: Slick.Parser
description: Standalone CSS3 Selector parser
provides: Slick.Parser
...
*/
(function () {
var parsed,
separatorIndex,
combinatorIndex,
reversed,
cache = {},
reverseCache = {},
reUnescape = /\\/g;
var parse = function (expression, isReversed) {
if (expression == null) return null;
if (expression.Slick === true) return expression;
expression = ("" + expression).replace(/^\s+|\s+$/g, "");
reversed = !!isReversed;
var currentCache = reversed ? reverseCache : cache;
if (currentCache[expression]) return currentCache[expression];
parsed = {
Slick: true,
expressions: [],
raw: expression,
reverse: function () {
return parse(this.raw, true);
},
};
separatorIndex = -1;
while (expression != (expression = expression.replace(regexp, parser)));
parsed.length = parsed.expressions.length;
return (currentCache[parsed.raw] = reversed ? reverse(parsed) : parsed);
};
var reverseCombinator = function (combinator) {
if (combinator === "!") return " ";
else if (combinator === " ") return "!";
else if (/^!/.test(combinator)) return combinator.replace(/^!/, "");
else return "!" + combinator;
};
var reverse = function (expression) {
var expressions = expression.expressions;
for (var i = 0; i < expressions.length; i++) {
var exp = expressions[i];
var last = {
parts: [],
tag: "*",
combinator: reverseCombinator(exp[0].combinator),
};
for (var j = 0; j < exp.length; j++) {
var cexp = exp[j];
if (!cexp.reverseCombinator) cexp.reverseCombinator = " ";
cexp.combinator = cexp.reverseCombinator;
delete cexp.reverseCombinator;
}
exp.reverse().push(last);
}
return expression;
};
var escapeRegExp = function (string) {
// Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License
return string.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, function (match) {
return "\\" + match;
});
};
var regexp = new RegExp(
/*
#!/usr/bin/env ruby
puts "\t\t" + DATA.read.gsub(/\(\?x\)|\s+#.*$|\s+|\\$|\\n/,'')
__END__
"(?x)^(?:\
\\s* ( , ) \\s* # Separator \n\
| \\s* ( <combinator>+ ) \\s* # Combinator \n\
| ( \\s+ ) # CombinatorChildren \n\
| ( <unicode>+ | \\* ) # Tag \n\
| \\# ( <unicode>+ ) # ID \n\
| \\. ( <unicode>+ ) # ClassName \n\
| # Attribute \n\
\\[ \
\\s* (<unicode1>+) (?: \
\\s* ([*^$!~|]?=) (?: \
\\s* (?:\
([\"']?)(.*?)\\9 \
)\
) \
)? \\s* \
\\](?!\\]) \n\
| :+ ( <unicode>+ )(?:\
\\( (?:\
(?:([\"'])([^\\12]*)\\12)|((?:\\([^)]+\\)|[^()]*)+)\
) \\)\
)?\
)"
*/
"^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)"
.replace(/<combinator>/, "[" + escapeRegExp(">+~`!@$%^&={}\\;</") + "]")
.replace(/<unicode>/g, "(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])")
.replace(/<unicode1>/g, "(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])"),
);
function parser(
rawMatch,
separator,
combinator,
combinatorChildren,
tagName,
id,
className,
attributeKey,
attributeOperator,
attributeQuote,
attributeValue,
pseudoMarker,
pseudoClass,
pseudoQuote,
pseudoClassQuotedValue,
pseudoClassValue,
) {
if (separator || separatorIndex === -1) {
parsed.expressions[++separatorIndex] = [];
combinatorIndex = -1;
if (separator) return "";
}
if (combinator || combinatorChildren || combinatorIndex === -1) {
combinator = combinator || " ";
var currentSeparator = parsed.expressions[separatorIndex];
if (reversed && currentSeparator[combinatorIndex])
currentSeparator[combinatorIndex].reverseCombinator =
reverseCombinator(combinator);
currentSeparator[++combinatorIndex] = {
combinator: combinator,
tag: "*",
};
}
var currentParsed = parsed.expressions[separatorIndex][combinatorIndex];
if (tagName) {
currentParsed.tag = tagName.replace(reUnescape, "");
} else if (id) {
currentParsed.id = id.replace(reUnescape, "");
} else if (className) {
className = className.replace(reUnescape, "");
if (!currentParsed.classList) currentParsed.classList = [];
if (!currentParsed.classes) currentParsed.classes = [];
currentParsed.classList.push(className);
currentParsed.classes.push({
value: className,
regexp: new RegExp("(^|\\s)" + escapeRegExp(className) + "(\\s|$)"),
});
} else if (pseudoClass) {
pseudoClassValue = pseudoClassValue || pseudoClassQuotedValue;
pseudoClassValue = pseudoClassValue
? pseudoClassValue.replace(reUnescape, "")
: null;
if (!currentParsed.pseudos) currentParsed.pseudos = [];
currentParsed.pseudos.push({
key: pseudoClass.replace(reUnescape, ""),
value: pseudoClassValue,
type: pseudoMarker.length == 1 ? "class" : "element",
});
} else if (attributeKey) {
attributeKey = attributeKey.replace(reUnescape, "");
attributeValue = (attributeValue || "").replace(reUnescape, "");
var test, regexp;
switch (attributeOperator) {
case "^=":
regexp = new RegExp("^" + escapeRegExp(attributeValue));
break;
case "$=":
regexp = new RegExp(escapeRegExp(attributeValue) + "$");
break;
case "~=":
regexp = new RegExp(
"(^|\\s)" + escapeRegExp(attributeValue) + "(\\s|$)",
);
break;
case "|=":
regexp = new RegExp("^" + escapeRegExp(attributeValue) + "(-|$)");
break;
case "=":
test = function (value) {
return attributeValue == value;
};
break;
case "*=":
test = function (value) {
return value && value.indexOf(attributeValue) > -1;
};
break;
case "!=":
test = function (value) {
return attributeValue != value;
};
break;
default:
test = function (value) {
return !!value;
};
}
if (attributeValue == "" && /^[*$^]=$/.test(attributeOperator))
test = function () {
return false;
};
if (!test)
test = function (value) {
return value && regexp.test(value);
};
if (!currentParsed.attributes) currentParsed.attributes = [];
currentParsed.attributes.push({
key: attributeKey,
operator: attributeOperator,
value: attributeValue,
test: test,
});
}
return "";
}
// Slick NS
var Slick = this.Slick || {};
Slick.parse = function (expression) {
return parse(expression);
};
Slick.escapeRegExp = escapeRegExp;
if (!this.Slick) this.Slick = Slick;
}.apply(
/*<CommonJS>*/ typeof exports != "undefined" ? exports : /*</CommonJS>*/ this,
));
/*
---
name: Slick.Finder
description: The new, superfast css selector engine.
provides: Slick.Finder
requires: Slick.Parser
...
*/
(function () {
var local = {},
featuresCache = {},
toString = Object.prototype.toString;
// Feature / Bug detection
local.isNativeCode = function (fn) {
return /\{\s*\[native code\]\s*\}/.test("" + fn);
};
local.isXML = function (document) {
return (
!!document.xmlVersion ||
!!document.xml ||
toString.call(document) == "[object XMLDocument]" ||
(document.nodeType == 9 && document.documentElement.nodeName != "HTML")
);
};
local.setDocument = function (document) {
// convert elements / window arguments to document. if document cannot be extrapolated, the function returns.
var nodeType = document.nodeType;
if (nodeType == 9);
else if (nodeType)
// document
document = document.ownerDocument; // node
else if (document.navigator) document = document.document; // window
else return;
// check if it's the old document
if (this.document === document) return;
this.document = document;
// check if we have done feature detection on this document before
var root = document.documentElement,
rootUid = this.getUIDXML(root),
features = featuresCache[rootUid],
feature;
if (features) {
for (feature in features) {
this[feature] = features[feature];
}
return;
}
features = featuresCache[rootUid] = {};
features.root = root;
features.isXMLDocument = this.isXML(document);
features.brokenStarGEBTN =
features.starSelectsClosedQSA =
features.idGetsName =
features.brokenMixedCaseQSA =
features.brokenGEBCN =
features.brokenCheckedQSA =
features.brokenEmptyAttributeQSA =
features.isHTMLDocument =
features.nativeMatchesSelector =
false;
var starSelectsClosed,
starSelectsComments,
brokenSecondClassNameGEBCN,
cachedGetElementsByClassName,
brokenFormAttributeGetter;
var selected,
id = "slick_uniqueid";
var testNode = document.createElement("div");
var testRoot =
document.body || document.getElementsByTagName("body")[0] || root;
testRoot.appendChild(testNode);
// on non-HTML documents innerHTML and getElementsById doesnt work properly
try {
testNode.innerHTML = '<a id="' + id + '"></a>';
features.isHTMLDocument = !!document.getElementById(id);
} catch (e) {}
if (features.isHTMLDocument) {
testNode.style.display = "none";
// IE returns comment nodes for getElementsByTagName('*') for some documents
testNode.appendChild(document.createComment(""));
starSelectsComments = testNode.getElementsByTagName("*").length > 1;
// IE returns closed nodes (EG:"</foo>") for getElementsByTagName('*') for some documents
try {
testNode.innerHTML = "foo</foo>";
selected = testNode.getElementsByTagName("*");
starSelectsClosed =
selected &&
!!selected.length &&
selected[0].nodeName.charAt(0) == "/";
} catch (e) {}
features.brokenStarGEBTN = starSelectsComments || starSelectsClosed;
// IE returns elements with the name instead of just id for getElementsById for some documents
try {
testNode.innerHTML = '<a name="' + id + '"></a><b id="' + id + '"></b>';
features.idGetsName =
document.getElementById(id) === testNode.firstChild;
} catch (e) {}
if (testNode.getElementsByClassName) {
// Safari 3.2 getElementsByClassName caches results
try {
testNode.innerHTML = '<a class="f"></a><a class="b"></a>';
testNode.getElementsByClassName("b").length;
testNode.firstChild.className = "b";
cachedGetElementsByClassName =
testNode.getElementsByClassName("b").length != 2;
} catch (e) {}
// Opera 9.6 getElementsByClassName doesnt detects the class if its not the first one
try {
testNode.innerHTML = '<a class="a"></a><a class="f b a"></a>';
brokenSecondClassNameGEBCN =
testNode.getElementsByClassName("a").length != 2;
} catch (e) {}
features.brokenGEBCN =
cachedGetElementsByClassName || brokenSecondClassNameGEBCN;
}
if (testNode.querySelectorAll) {
// IE 8 returns closed nodes (EG:"</foo>") for querySelectorAll('*') for some documents
try {
testNode.innerHTML = "foo</foo>";
selected = testNode.querySelectorAll("*");
features.starSelectsClosedQSA =
selected &&
!!selected.length &&
selected[0].nodeName.charAt(0) == "/";
} catch (e) {}
// Safari 3.2 querySelectorAll doesnt work with mixedcase on quirksmode
try {
testNode.innerHTML = '<a class="MiX"></a>';
features.brokenMixedCaseQSA =
!testNode.querySelectorAll(".MiX").length;
} catch (e) {}
// Webkit and Opera dont return selected options on querySelectorAll
try {
testNode.innerHTML =
'<select><option selected="selected">a</option></select>';
features.brokenCheckedQSA =
testNode.querySelectorAll(":checked").length == 0;
} catch (e) {}
// IE returns incorrect results for attr[*^$]="" selectors on querySelectorAll
try {
testNode.innerHTML = '<a class=""></a>';
features.brokenEmptyAttributeQSA =
testNode.querySelectorAll('[class*=""]').length != 0;
} catch (e) {}
}
// IE6-7, if a form has an input of id x, form.getAttribute(x) returns a reference to the input
try {
testNode.innerHTML = '<form action="s"><input id="action"/></form>';
brokenFormAttributeGetter =
testNode.firstChild.getAttribute("action") != "s";
} catch (e) {}
// native matchesSelector function
features.nativeMatchesSelector =
root.matchesSelector ||
/*root.msMatchesSelector ||*/ root.mozMatchesSelector ||
root.webkitMatchesSelector;
if (features.nativeMatchesSelector)
try {
// if matchesSelector trows errors on incorrect sintaxes we can use it
features.nativeMatchesSelector.call(root, ":slick");
features.nativeMatchesSelector = null;
} catch (e) {}
}
try {
root.slick_expando = 1;
delete root.slick_expando;
features.getUID = this.getUIDHTML;
} catch (e) {
features.getUID = this.getUIDXML;
}
testRoot.removeChild(testNode);
testNode = selected = testRoot = null;
// getAttribute
features.getAttribute =
features.isHTMLDocument && brokenFormAttributeGetter
? function (node, name) {
var method = this.attributeGetters[name];
if (method) return method.call(node);
var attributeNode = node.getAttributeNode(name);
return attributeNode ? attributeNode.nodeValue : null;
}
: function (node, name) {
var method = this.attributeGetters[name];
return method ? method.call(node) : node.getAttribute(name);
};
// hasAttribute
features.hasAttribute =
root && this.isNativeCode(root.hasAttribute)
? function (node, attribute) {
return node.hasAttribute(attribute);
}
: function (node, attribute) {
node = node.getAttributeNode(attribute);
return !!(node && (node.specified || node.nodeValue));
};
// contains
// FIXME: Add specs: local.contains should be different for xml and html documents?
var nativeRootContains = root && this.isNativeCode(root.contains),
nativeDocumentContains = document && this.isNativeCode(document.contains);
features.contains =
nativeRootContains && nativeDocumentContains
? function (context, node) {
return context.contains(node);
}
: nativeRootContains && !nativeDocumentContains
? function (context, node) {
// IE8 does not have .contains on document.
return (
context === node ||
(context === document
? document.documentElement
: context
).contains(node)
);
}
: root && root.compareDocumentPosition
? function (context, node) {
return (
context === node || !!(context.compareDocumentPosition(node) & 16)
);
}
: function (context, node) {
if (node)
do {
if (node === context) return true;
} while ((node = node.parentNode));
return false;
};
// document order sorting
// credits to Sizzle (http://sizzlejs.com/)
features.documentSorter = root.compareDocumentPosition
? function (a, b) {
if (!a.compareDocumentPosition || !b.compareDocumentPosition)
return 0;
return a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
}
: "sourceIndex" in root
? function (a, b) {
if (!a.sourceIndex || !b.sourceIndex) return 0;
return a.sourceIndex - b.sourceIndex;
}
: document.createRange
? function (a, b) {
if (!a.ownerDocument || !b.ownerDocument) return 0;
var aRange = a.ownerDocument.createRange(),
bRange = b.ownerDocument.createRange();
aRange.setStart(a, 0);
aRange.setEnd(a, 0);
bRange.setStart(b, 0);
bRange.setEnd(b, 0);
return aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
}
: null;
root = null;
for (feature in features) {
this[feature] = features[feature];
}
};
// Main Method
var reSimpleSelector = /^([#.]?)((?:[\w-]+|\*))$/,
reEmptyAttribute = /\[.+[*$^]=(?:""|'')?\]/,
qsaFailExpCache = {};
local.search = function (context, expression, append, first) {
var found = (this.found = first ? null : append || []);
if (!context) return found;
else if (context.navigator) context = context.document;
// Convert the node from a window to a document
else if (!context.nodeType) return found;
// setup
var parsed,
i,
uniques = (this.uniques = {}),
hasOthers = !!(append && append.length),
contextIsDocument = context.nodeType == 9;
if (this.document !== (contextIsDocument ? context : context.ownerDocument))
this.setDocument(context);
// avoid duplicating items already in the append array
if (hasOthers)
for (i = found.length; i--; ) uniques[this.getUID(found[i])] = true;
// expression checks
if (typeof expression == "string") {
// expression is a string
/*<simple-selectors-override>*/
var simpleSelector = expression.match(reSimpleSelector);
simpleSelectors: if (simpleSelector) {
var symbol = simpleSelector[1],
name = simpleSelector[2],
node,
nodes;
if (!symbol) {
if (name == "*" && this.brokenStarGEBTN) break simpleSelectors;
nodes = context.getElementsByTagName(name);
if (first) return nodes[0] || null;
for (i = 0; (node = nodes[i++]); ) {
if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
}
} else if (symbol == "#") {
if (!this.isHTMLDocument || !contextIsDocument) break simpleSelectors;
node = context.getElementById(name);
if (!node) return found;
if (this.idGetsName && node.getAttributeNode("id").nodeValue != name)
break simpleSelectors;
if (first) return node || null;
if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
} else if (symbol == ".") {
if (
!this.isHTMLDocument ||
((!context.getElementsByClassName || this.brokenGEBCN) &&
context.querySelectorAll)
)
break simpleSelectors;
if (context.getElementsByClassName && !this.brokenGEBCN) {
nodes = context.getElementsByClassName(name);
if (first) return nodes[0] || null;
for (i = 0; (node = nodes[i++]); ) {
if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
}
} else {
var matchClass = new RegExp(
"(^|\\s)" + Slick.escapeRegExp(name) + "(\\s|$)",
);
nodes = context.getElementsByTagName("*");
for (i = 0; (node = nodes[i++]); ) {
className = node.className;
if (!(className && matchClass.test(className))) continue;
if (first) return node;
if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
}
}
}
if (hasOthers) this.sort(found);
return first ? null : found;
}
/*</simple-selectors-override>*/
/*<query-selector-override>*/
querySelector: if (context.querySelectorAll) {
if (
!this.isHTMLDocument ||
qsaFailExpCache[expression] ||
//TODO: only skip when expression is actually mixed case
this.brokenMixedCaseQSA ||
(this.brokenCheckedQSA && expression.indexOf(":checked") > -1) ||
(this.brokenEmptyAttributeQSA && reEmptyAttribute.test(expression)) ||
(!contextIsDocument && //Abort when !contextIsDocument and...
// there are multiple expressions in the selector
// since we currently only fix non-document rooted QSA for single expression selectors
expression.indexOf(",") > -1) ||
Slick.disableQSA
)
break querySelector;
var _expression = expression,
_context = context;
if (!contextIsDocument) {
// non-document rooted QSA
// credits to Andrew Dupont
var currentId = _context.getAttribute("id"),
slickid = "slickid__";
_context.setAttribute("id", slickid);
_expression = "#" + slickid + " " + _expression;
context = _context.parentNode;
}
try {
if (first) return context.querySelector(_expression) || null;
else nodes = context.querySelectorAll(_expression);
} catch (e) {
qsaFailExpCache[expression] = 1;
break querySelector;
} finally {
if (!contextIsDocument) {
if (currentId) _context.setAttribute("id", currentId);
else _context.removeAttribute("id");
context = _context;
}
}
if (this.starSelectsClosedQSA)
for (i = 0; (node = nodes[i++]); ) {
if (
node.nodeName > "@" &&
!(hasOthers && uniques[this.getUID(node)])
)
found.push(node);
}
else
for (i = 0; (node = nodes[i++]); ) {
if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
}
if (hasOthers) this.sort(found);
return found;
}
/*</query-selector-override>*/
parsed = this.Slick.parse(expression);
if (!parsed.length) return found;
} else if (expression == null) {
// there is no expression
return found;
} else if (expression.Slick) {
// expression is a parsed Slick object
parsed = expression;
} else if (this.contains(context.documentElement || context, expression)) {
// expression is a node
found ? found.push(expression) : (found = expression);
return found;
} else {
// other junk
return found;
}
/*<pseudo-selectors>*/ /*<nth-pseudo-selectors>*/
// cache elements for the nth selectors
this.posNTH = {};
this.posNTHLast = {};
this.posNTHType = {};
this.posNTHTypeLast = {};
/*</nth-pseudo-selectors>*/ /*</pseudo-selectors>*/
// if append is null and there is only a single selector with one expression use pushArray, else use pushUID
this.push =
!hasOthers &&
(first || (parsed.length == 1 && parsed.expressions[0].length == 1))
? this.pushArray
: this.pushUID;
if (found == null) found = [];
// default engine
var j, m, n;
var combinator, tag, id, classList, classes, attributes, pseudos;
var currentItems,
currentExpression,
currentBit,
lastBit,
expressions = parsed.expressions;
search: for (i = 0; (currentExpression = expressions[i]); i++)
for (j = 0; (currentBit = currentExpression[j]); j++) {
combinator = "combinator:" + currentBit.combinator;
if (!this[combinator]) continue search;
tag = this.isXMLDocument
? currentBit.tag
: currentBit.tag.toUpperCase();
id = currentBit.id;
classList = currentBit.classList;
classes = currentBit.classes;
attributes = currentBit.attributes;
pseudos = currentBit.pseudos;
lastBit = j === currentExpression.length - 1;
this.bitUniques = {};
if (lastBit) {
this.uniques = uniques;
this.found = found;
} else {
this.uniques = {};
this.found = [];
}
if (j === 0) {
this[combinator](
context,
tag,
id,
classes,
attributes,
pseudos,
classList,
);
if (first && lastBit && found.length) break search;
} else {
if (first && lastBit)
for (m = 0, n = currentItems.length; m < n; m++) {
this[combinator](
currentItems[m],
tag,
id,
classes,
attributes,
pseudos,
classList,
);
if (found.length) break search;
}
else
for (m = 0, n = currentItems.length; m < n; m++)
this[combinator](
currentItems[m],
tag,
id,
classes,
attributes,
pseudos,
classList,
);
}
currentItems = this.found;
}
// should sort if there are nodes in append and if you pass multiple expressions.
if (hasOthers || parsed.expressions.length > 1) this.sort(found);
return first ? found[0] || null : found;
};
// Utils
local.uidx = 1;
local.uidk = "slick-uniqueid";
local.getUIDXML = function (node) {
var uid = node.getAttribute(this.uidk);
if (!uid) {
uid = this.uidx++;
node.setAttribute(this.uidk, uid);
}
return uid;
};
local.getUIDHTML = function (node) {
return node.uniqueNumber || (node.uniqueNumber = this.uidx++);
};
// sort based on the setDocument documentSorter method.
local.sort = function (results) {
if (!this.documentSorter) return results;
results.sort(this.documentSorter);
return results;
};
/*<pseudo-selectors>*/ /*<nth-pseudo-selectors>*/
local.cacheNTH = {};
local.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/;
local.parseNTHArgument = function (argument) {
var parsed = argument.match(this.matchNTH);
if (!parsed) return false;
var special = parsed[2] || false;
var a = parsed[1] || 1;
if (a == "-") a = -1;
var b = +parsed[3] || 0;
parsed =
special == "n"
? { a: a, b: b }
: special == "odd"
? { a: 2, b: 1 }
: special == "even"
? { a: 2, b: 0 }
: { a: 0, b: a };
return (this.cacheNTH[argument] = parsed);
};
local.createNTHPseudo = function (child, sibling, positions, ofType) {
return function (node, argument) {
var uid = this.getUID(node);
if (!this[positions][uid]) {
var parent = node.parentNode;
if (!parent) return false;
var el = parent[child],
count = 1;
if (ofType) {
var nodeName = node.nodeName;
do {
if (el.nodeName != nodeName) continue;
this[positions][this.getUID(el)] = count++;
} while ((el = el[sibling]));
} else {
do {
if (el.nodeType != 1) continue;
this[positions][this.getUID(el)] = count++;
} while ((el = el[sibling]));
}
}
argument = argument || "n";
var parsed = this.cacheNTH[argument] || this.parseNTHArgument(argument);
if (!parsed) return false;
var a = parsed.a,
b = parsed.b,
pos = this[positions][uid];
if (a == 0) return b == pos;
if (a > 0) {
if (pos < b) return false;
} else {
if (b < pos) return false;
}
return (pos - b) % a == 0;
};
};
/*</nth-pseudo-selectors>*/ /*</pseudo-selectors>*/
local.pushArray = function (node, tag, id, classes, attributes, pseudos) {
if (this.matchSelector(node, tag, id, classes, attributes, pseudos))
this.found.push(node);
};
local.pushUID = function (node, tag, id, classes, attributes, pseudos) {
var uid = this.getUID(node);
if (
!this.uniques[uid] &&
this.matchSelector(node, tag, id, classes, attributes, pseudos)
) {
this.uniques[uid] = true;
this.found.push(node);
}
};
local.matchNode = function (node, selector) {
if (this.isHTMLDocument && this.nativeMatchesSelector) {
try {
return this.nativeMatchesSelector.call(
node,
selector.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g, '[$1="$2"]'),
);
} catch (matchError) {}
}
var parsed = this.Slick.parse(selector);
if (!parsed) return true;
// simple (single) selectors
var expressions = parsed.expressions,
simpleExpCounter = 0,
i;
for (i = 0; (currentExpression = expressions[i]); i++) {
if (currentExpression.length == 1) {
var exp = currentExpression[0];
if (
this.matchSelector(
node,
this.isXMLDocument ? exp.tag : exp.tag.toUpperCase(),
exp.id,
exp.classes,
exp.attributes,
exp.pseudos,
)
)
return true;
simpleExpCounter++;
}
}
if (simpleExpCounter == parsed.length) return false;
var nodes = this.search(this.document, parsed),
item;
for (i = 0; (item = nodes[i++]); ) {
if (item === node) return true;
}
return false;
};
local.matchPseudo = function (node, name, argument) {
var pseudoName = "pseudo:" + name;
if (this[pseudoName]) return this[pseudoName](node, argument);
var attribute = this.getAttribute(node, name);
return argument ? argument == attribute : !!attribute;
};
local.matchSelector = function (node, tag, id, classes, attributes, pseudos) {
if (tag) {
var nodeName = this.isXMLDocument
? node.nodeName
: node.nodeName.toUpperCase();
if (tag == "*") {
if (nodeName < "@") return false; // Fix for comment nodes and closed nodes
} else {
if (nodeName != tag) return false;
}
}
if (id && node.getAttribute("id") != id) return false;
var i, part, cls;
if (classes)
for (i = classes.length; i--; ) {
cls = this.getAttribute(node, "class");
if (!(cls && classes[i].regexp.test(cls))) return false;
}
if (attributes)
for (i = attributes.length; i--; ) {
part = attributes[i];
if (
part.operator
? !part.test(this.getAttribute(node, part.key))
: !this.hasAttribute(node, part.key)
)
return false;
}
if (pseudos)
for (i = pseudos.length; i--; ) {
part = pseudos[i];
if (!this.matchPseudo(node, part.key, part.value)) return false;
}
return true;
};
var combinators = {
" ": function (node, tag, id, classes, attributes, pseudos, classList) {
// all child nodes, any level
var i, item, children;
if (this.isHTMLDocument) {
getById: if (id) {
item = this.document.getElementById(id);
if (
(!item && node.all) ||
(this.idGetsName &&
item &&
item.getAttributeNode("id").nodeValue != id)
) {
// all[id] returns all the elements with that name or id inside node
// if theres just one it will return the element, else it will be a collection
children = node.all[id];
if (!children) return;
if (!children[0]) children = [children];
for (i = 0; (item = children[i++]); ) {
var idNode = item.getAttributeNode("id");
if (idNode && idNode.nodeValue == id) {
this.push(item, tag, null, classes, attributes, pseudos);
break;
}
}
return;
}
if (!item) {
// if the context is in the dom we return, else we will try GEBTN, breaking the getById label
if (this.contains(this.root, node)) return;
else break getById;
} else if (this.document !== node && !this.contains(node, item))
return;
this.push(item, tag, null, classes, attributes, pseudos);
return;
}
getByClass: if (
classes &&
node.getElementsByClassName &&
!this.brokenGEBCN
) {
children = node.getElementsByClassName(classList.join(" "));
if (!(children && children.length)) break getByClass;
for (i = 0; (item = children[i++]); )
this.push(item, tag, id, null, attributes, pseudos);
return;
}
}
getByTag: {
children = node.getElementsByTagName(tag);
if (!(children && children.length)) break getByTag;
if (!this.brokenStarGEBTN) tag = null;
for (i = 0; (item = children[i++]); )
this.push(item, tag, id, classes, attributes, pseudos);
}
},
">": function (node, tag, id, classes, attributes, pseudos) {
// direct children
if ((node = node.firstChild))
do {
if (node.nodeType == 1)
this.push(node, tag, id, classes, attributes, pseudos);
} while ((node = node.nextSibling));
},
"+": function (node, tag, id, classes, attributes, pseudos) {
// next sibling
while ((node = node.nextSibling))
if (node.nodeType == 1) {
this.push(node, tag, id, classes, attributes, pseudos);
break;
}
},
"^": function (node, tag, id, classes, attributes, pseudos) {
// first child
node = node.firstChild;
if (node) {
if (node.nodeType == 1)
this.push(node, tag, id, classes, attributes, pseudos);
else this["combinator:+"](node, tag, id, classes, attributes, pseudos);
}
},
"~": function (node, tag, id, classes, attributes, pseudos) {
// next siblings
while ((node = node.nextSibling)) {
if (node.nodeType != 1) continue;
var uid = this.getUID(node);
if (this.bitUniques[uid]) break;
this.bitUniques[uid] = true;
this.push(node, tag, id, classes, attributes, pseudos);
}
},
"++": function (node, tag, id, classes, attributes, pseudos) {
// next sibling and previous sibling
this["combinator:+"](node, tag, id, classes, attributes, pseudos);
this["combinator:!+"](node, tag, id, classes, attributes, pseudos);
},
"~~": function (node, tag, id, classes, attributes, pseudos) {
// next siblings and previous siblings
this["combinator:~"](node, tag, id, classes, attributes, pseudos);
this["combinator:!~"](node, tag, id, classes, attributes, pseudos);
},
"!": function (node, tag, id, classes, attributes, pseudos) {
// all parent nodes up to document
while ((node = node.parentNode))
if (node !== this.document)
this.push(node, tag, id, classes, attributes, pseudos);
},
"!>": function (node, tag, id, classes, attributes, pseudos) {
// direct parent (one level)
node = node.parentNode;
if (node !== this.document)
this.push(node, tag, id, classes, attributes, pseudos);
},
"!+": function (node, tag, id, classes, attributes, pseudos) {
// previous sibling
while ((node = node.previousSibling))
if (node.nodeType == 1) {
this.push(node, tag, id, classes, attributes, pseudos);
break;
}
},
"!^": function (node, tag, id, classes, attributes, pseudos) {
// last child
node = node.lastChild;
if (node) {
if (node.nodeType == 1)
this.push(node, tag, id, classes, attributes, pseudos);
else this["combinator:!+"](node, tag, id, classes, attributes, pseudos);
}
},
"!~": function (node, tag, id, classes, attributes, pseudos) {
// previous siblings
while ((node = node.previousSibling)) {
if (node.nodeType != 1) continue;
var uid = this.getUID(node);
if (this.bitUniques[uid]) break;
this.bitUniques[uid] = true;
this.push(node, tag, id, classes, attributes, pseudos);
}
},
};
for (var c in combinators) local["combinator:" + c] = combinators[c];
var pseudos = {
/*<pseudo-selectors>*/
empty: function (node) {
var child = node.firstChild;
return (
!(child && child.nodeType == 1) &&
!(node.innerText || node.textContent || "").length
);
},
not: function (node, expression) {
return !this.matchNode(node, expression);
},
contains: function (node, text) {
return (node.innerText || node.textContent || "").indexOf(text) > -1;
},
"first-child": function (node) {
while ((node = node.previousSibling))
if (node.nodeType == 1) return false;
return true;
},
"last-child": function (node) {
while ((node = node.nextSibling)) if (node.nodeType == 1) return false;
return true;
},
"only-child": function (node) {
var prev = node;
while ((prev = prev.previousSibling))
if (prev.nodeType == 1) return false;
var next = node;
while ((next = next.nextSibling)) if (next.nodeType == 1) return false;
return true;
},
/*<nth-pseudo-selectors>*/
"nth-child": local.createNTHPseudo("firstChild", "nextSibling", "posNTH"),
"nth-last-child": local.createNTHPseudo(
"lastChild",
"previousSibling",
"posNTHLast",
),
"nth-of-type": local.createNTHPseudo(
"firstChild",
"nextSibling",
"posNTHType",
true,
),
"nth-last-of-type": local.createNTHPseudo(
"lastChild",
"previousSibling",
"posNTHTypeLast",
true,
),
index: function (node, index) {
return this["pseudo:nth-child"](node, "" + (index + 1));
},
even: function (node) {
return this["pseudo:nth-child"](node, "2n");
},
odd: function (node) {
return this["pseudo:nth-child"](node, "2n+1");
},
/*</nth-pseudo-selectors>*/
/*<of-type-pseudo-selectors>*/
"first-of-type": function (node) {
var nodeName = node.nodeName;
while ((node = node.previousSibling))
if (node.nodeName == nodeName) return false;
return true;
},
"last-of-type": function (node) {
var nodeName = node.nodeName;
while ((node = node.nextSibling))
if (node.nodeName == nodeName) return false;
return true;
},
"only-of-type": function (node) {
var prev = node,
nodeName = node.nodeName;
while ((prev = prev.previousSibling))
if (prev.nodeName == nodeName) return false;
var next = node;
while ((next = next.nextSibling))
if (next.nodeName == nodeName) return false;
return true;
},
/*</of-type-pseudo-selectors>*/
// custom pseudos
enabled: function (node) {
return !node.disabled;
},
disabled: function (node) {
return node.disabled;
},
checked: function (node) {
return node.checked || node.selected;
},
focus: function (node) {
return (
this.isHTMLDocument &&
this.document.activeElement === node &&
(node.href || node.type || this.hasAttribute(node, "tabindex"))
);
},
root: function (node) {
return node === this.root;
},
selected: function (node) {
return node.selected;
},
/*</pseudo-selectors>*/
};
for (var p in pseudos) local["pseudo:" + p] = pseudos[p];
// attributes methods
var attributeGetters = (local.attributeGetters = {
for: function () {
return "htmlFor" in this ? this.htmlFor : this.getAttribute("for");
},
href: function () {
return "href" in this
? this.getAttribute("href", 2)
: this.getAttribute("href");
},
style: function () {
return this.style ? this.style.cssText : this.getAttribute("style");
},
tabindex: function () {
var attributeNode = this.getAttributeNode("tabindex");
return attributeNode && attributeNode.specified
? attributeNode.nodeValue
: null;
},
type: function () {
return this.getAttribute("type");
},
maxlength: function () {
var attributeNode = this.getAttributeNode("maxLength");
return attributeNode && attributeNode.specified
? attributeNode.nodeValue
: null;
},
});
attributeGetters.MAXLENGTH = attributeGetters.maxLength =
attributeGetters.maxlength;
// Slick
var Slick = (local.Slick = this.Slick || {});
Slick.version = "1.1.7";
// Slick finder
Slick.search = function (context, expression, append) {
return local.search(context, expression, append);
};
Slick.find = function (context, expression) {
return local.search(context, expression, null, true);
};
// Slick containment checker
Slick.contains = function (container, node) {
local.setDocument(container);
return local.contains(container, node);
};
// Slick attribute getter
Slick.getAttribute = function (node, name) {
local.setDocument(node);
return local.getAttribute(node, name);
};
Slick.hasAttribute = function (node, name) {
local.setDocument(node);
return local.hasAttribute(node, name);
};
// Slick matcher
Slick.match = function (node, selector) {
if (!(node && selector)) return false;
if (!selector || selector === node) return true;
local.setDocument(node);
return local.matchNode(node, selector);
};
// Slick attribute accessor
Slick.defineAttributeGetter = function (name, fn) {
local.attributeGetters[name] = fn;
return this;
};
Slick.lookupAttributeGetter = function (name) {
return local.attributeGetters[name];
};
// Slick pseudo accessor
Slick.definePseudo = function (name, fn) {
local["pseudo:" + name] = function (node, argument) {
return fn.call(node, argument);
};
return this;
};
Slick.lookupPseudo = function (name) {
var pseudo = local["pseudo:" + name];
if (pseudo)
return function (argument) {
return pseudo.call(this, argument);
};
return null;
};
// Slick overrides accessor
Slick.override = function (regexp, fn) {
local.override(regexp, fn);
return this;
};
Slick.isXML = local.isXML;
Slick.uidOf = function (node) {
return local.getUIDHTML(node);
};
if (!this.Slick) this.Slick = Slick;
}.apply(
/*<CommonJS>*/ typeof exports != "undefined" ? exports : /*</CommonJS>*/ this,
));
/*
---
name: Element
description: One of the most important items in MooTools. Contains the dollar function, the dollars function, and an handful of cross-browser, time-saver methods to let you easily work with HTML Elements.
license: MIT-style license.
requires: [Window, Document, Array, String, Function, Object, Number, Slick.Parser, Slick.Finder]
provides: [Element, Elements, $, $$, Iframe, Selectors]
...
*/
var Element = function (tag, props) {
var konstructor = Element.Constructors[tag];
if (konstructor) return konstructor(props);
if (typeof tag != "string") return document.id(tag).set(props);
if (!props) props = {};
if (!/^[\w-]+$/.test(tag)) {
var parsed = Slick.parse(tag).expressions[0][0];
tag = parsed.tag == "*" ? "div" : parsed.tag;
if (parsed.id && props.id == null) props.id = parsed.id;
var attributes = parsed.attributes;
if (attributes)
for (var attr, i = 0, l = attributes.length; i < l; i++) {
attr = attributes[i];
if (props[attr.key] != null) continue;
if (attr.value != null && attr.operator == "=")
props[attr.key] = attr.value;
else if (!attr.value && !attr.operator) props[attr.key] = true;
}
if (parsed.classList && props["class"] == null)
props["class"] = parsed.classList.join(" ");
}
return document.newElement(tag, props);
};
if (Browser.Element) {
Element.prototype = Browser.Element.prototype;
// IE8 and IE9 require the wrapping.
Element.prototype._fireEvent = (function (fireEvent) {
return function (type, event) {
return fireEvent.call(this, type, event);
};
})(Element.prototype.fireEvent);
}
new Type("Element", Element).mirror(function (name) {
if (Array.prototype[name]) return;
var obj = {};
obj[name] = function () {
var results = [],
args = arguments,
elements = true;
for (var i = 0, l = this.length; i < l; i++) {
var element = this[i],
result = (results[i] = element[name].apply(element, args));
elements = elements && typeOf(result) == "element";
}
return elements ? new Elements(results) : results;
};
Elements.implement(obj);
});
if (!Browser.Element) {
Element.parent = Object;
Element.Prototype = {
$constructor: Element,
$family: Function.from("element").hide(),
};
Element.mirror(function (name, method) {
Element.Prototype[name] = method;
});
}
Element.Constructors = {};
//<1.2compat>
Element.Constructors = new Hash();
//</1.2compat>
var IFrame = new Type("IFrame", function () {
var params = Array.link(arguments, {
properties: Type.isObject,
iframe: function (obj) {
return obj != null;
},
});
var props = params.properties || {},
iframe;
if (params.iframe) iframe = document.id(params.iframe);
var onload = props.onload || function () {};
delete props.onload;
props.id = props.name = [
props.id,
props.name,
iframe ? iframe.id || iframe.name : "IFrame_" + String.uniqueID(),
].pick();
iframe = new Element(iframe || "iframe", props);
var onLoad = function () {
onload.call(iframe.contentWindow);
};
if (window.frames[props.id]) onLoad();
else iframe.addListener("load", onLoad);
return iframe;
});
var Elements = (this.Elements = function (nodes) {
if (nodes && nodes.length) {
var uniques = {},
node;
for (var i = 0; (node = nodes[i++]); ) {
var uid = Slick.uidOf(node);
if (!uniques[uid]) {
uniques[uid] = true;
this.push(node);
}
}
}
});
Elements.prototype = { length: 0 };
Elements.parent = Array;
new Type("Elements", Elements).implement({
filter: function (filter, bind) {
if (!filter) return this;
return new Elements(
Array.filter(
this,
typeOf(filter) == "string"
? function (item) {
return item.match(filter);
}
: filter,
bind,
),
);
}.protect(),
push: function () {
var length = this.length;
for (var i = 0, l = arguments.length; i < l; i++) {
var item = document.id(arguments[i]);
if (item) this[length++] = item;
}
return (this.length = length);
}.protect(),
unshift: function () {
var items = [];
for (var i = 0, l = arguments.length; i < l; i++) {
var item = document.id(arguments[i]);
if (item) items.push(item);
}
return Array.prototype.unshift.apply(this, items);
}.protect(),
concat: function () {
var newElements = new Elements(this);
for (var i = 0, l = arguments.length; i < l; i++) {
var item = arguments[i];
if (Type.isEnumerable(item)) newElements.append(item);
else newElements.push(item);
}
return newElements;
}.protect(),
append: function (collection) {
for (var i = 0, l = collection.length; i < l; i++) this.push(collection[i]);
return this;
}.protect(),
empty: function () {
while (this.length) delete this[--this.length];
return this;
}.protect(),
});
//<1.2compat>
Elements.alias("extend", "append");
//</1.2compat>
(function () {
// FF, IE
var splice = Array.prototype.splice,
object = { 0: 0, 1: 1, length: 2 };
splice.call(object, 1, 1);
if (object[1] == 1)
Elements.implement(
"splice",
function () {
var length = this.length;
var result = splice.apply(this, arguments);
while (length >= this.length) delete this[length--];
return result;
}.protect(),
);
Array.forEachMethod(function (method, name) {
Elements.implement(name, method);
});
Array.mirror(Elements);
/*<ltIE8>*/
var createElementAcceptsHTML;
try {
createElementAcceptsHTML =
document.createElement("<input name=x>").name == "x";
} catch (e) {}
var escapeQuotes = function (html) {
return ("" + html).replace(/&/g, "&").replace(/"/g, """);
};
/*</ltIE8>*/
Document.implement({
newElement: function (tag, props) {
if (props && props.checked != null) props.defaultChecked = props.checked;
/*<ltIE8>*/ // Fix for readonly name and type properties in IE < 8
if (createElementAcceptsHTML && props) {
tag = "<" + tag;
if (props.name) tag += ' name="' + escapeQuotes(props.name) + '"';
if (props.type) tag += ' type="' + escapeQuotes(props.type) + '"';
tag += ">";
delete props.name;
delete props.type;
}
/*</ltIE8>*/
return this.id(this.createElement(tag)).set(props);
},
});
})();
(function () {
Slick.uidOf(window);
Slick.uidOf(document);
Document.implement({
newTextNode: function (text) {
return this.createTextNode(text);
},
getDocument: function () {
return this;
},
getWindow: function () {
return this.window;
},
id: (function () {
var types = {
string: function (id, nocash, doc) {
id = Slick.find(doc, "#" + id.replace(/(\W)/g, "\\$1"));
return id ? types.element(id, nocash) : null;
},
element: function (el, nocash) {
Slick.uidOf(el);
if (
!nocash &&
!el.$family &&
!/^(?:object|embed)$/i.test(el.tagName)
) {
var fireEvent = el.fireEvent;
// wrapping needed in IE7, or else crash
el._fireEvent = function (type, event) {
return fireEvent(type, event);
};
Object.append(el, Element.Prototype);
}
return el;
},
object: function (obj, nocash, doc) {
if (obj.toElement) return types.element(obj.toElement(doc), nocash);
return null;
},
};
types.textnode =
types.whitespace =
types.window =
types.document =
function (zero) {
return zero;
};
return function (el, nocash, doc) {
if (el && el.$family && el.uniqueNumber) return el;
var type = typeOf(el);
return types[type] ? types[type](el, nocash, doc || document) : null;
};
})(),
});
if (window.$ == null)
Window.implement("$", function (el, nc) {
return document.id(el, nc, this.document);
});
Window.implement({
getDocument: function () {
return this.document;
},
getWindow: function () {
return this;
},
});
[Document, Element].invoke("implement", {
getElements: function (expression) {
return Slick.search(this, expression, new Elements());
},
getElement: function (expression) {
return document.id(Slick.find(this, expression));
},
});
var contains = {
contains: function (element) {
return Slick.contains(this, element);
},
};
if (!document.contains) Document.implement(contains);
if (!document.createElement("div").contains) Element.implement(contains);
//<1.2compat>
Element.implement("hasChild", function (element) {
return this !== element && this.contains(element);
});
(function (search, find, match) {
this.Selectors = {};
var pseudos = (this.Selectors.Pseudo = new Hash());
var addSlickPseudos = function () {
for (var name in pseudos)
if (pseudos.hasOwnProperty(name)) {
Slick.definePseudo(name, pseudos[name]);
delete pseudos[name];
}
};
Slick.search = function (context, expression, append) {
addSlickPseudos();
return search.call(this, context, expression, append);
};
Slick.find = function (context, expression) {
addSlickPseudos();
return find.call(this, context, expression);
};
Slick.match = function (node, selector) {
addSlickPseudos();
return match.call(this, node, selector);
};
})(Slick.search, Slick.find, Slick.match);
//</1.2compat>
// tree walking
var injectCombinator = function (expression, combinator) {
if (!expression) return combinator;
expression = Object.clone(Slick.parse(expression));
var expressions = expression.expressions;
for (var i = expressions.length; i--; )
expressions[i][0].combinator = combinator;
return expression;
};
Object.forEach(
{
getNext: "~",
getPrevious: "!~",
getParent: "!",
},
function (combinator, method) {
Element.implement(method, function (expression) {
return this.getElement(injectCombinator(expression, combinator));
});
},
);
Object.forEach(
{
getAllNext: "~",
getAllPrevious: "!~",
getSiblings: "~~",
getChildren: ">",
getParents: "!",
},
function (combinator, method) {
Element.implement(method, function (expression) {
return this.getElements(injectCombinator(expression, combinator));
});
},
);
Element.implement({
getFirst: function (expression) {
return document.id(
Slick.search(this, injectCombinator(expression, ">"))[0],
);
},
getLast: function (expression) {
return document.id(
Slick.search(this, injectCombinator(expression, ">")).getLast(),
);
},
getWindow: function () {
return this.ownerDocument.window;
},
getDocument: function () {
return this.ownerDocument;
},
getElementById: function (id) {
return document.id(
Slick.find(this, "#" + ("" + id).replace(/(\W)/g, "\\$1")),
);
},
match: function (expression) {
return !expression || Slick.match(this, expression);
},
});
//<1.2compat>
if (window.$$ == null)
Window.implement("$$", function (selector) {
var elements = new Elements();
if (arguments.length == 1 && typeof selector == "string")
return Slick.search(this.document, selector, elements);
var args = Array.flatten(arguments);
for (var i = 0, l = args.length; i < l; i++) {
var item = args[i];
switch (typeOf(item)) {
case "element":
elements.push(item);
break;
case "string":
Slick.search(this.document, item, elements);
}
}
return elements;
});
//</1.2compat>
if (window.$$ == null)
Window.implement("$$", function (selector) {
if (arguments.length == 1) {
if (typeof selector == "string")
return Slick.search(this.document, selector, new Elements());
else if (Type.isEnumerable(selector)) return new Elements(selector);
}
return new Elements(arguments);
});
// Inserters
var inserters = {
before: function (context, element) {
var parent = element.parentNode;
if (parent) parent.insertBefore(context, element);
},
after: function (context, element) {
var parent = element.parentNode;
if (parent) parent.insertBefore(context, element.nextSibling);
},
bottom: function (context, element) {
element.appendChild(context);
},
top: function (context, element) {
element.insertBefore(context, element.firstChild);
},
};
inserters.inside = inserters.bottom;
//<1.2compat>
Object.each(inserters, function (inserter, where) {
where = where.capitalize();
var methods = {};
methods["inject" + where] = function (el) {
inserter(this, document.id(el, true));
return this;
};
methods["grab" + where] = function (el) {
inserter(document.id(el, true), this);
return this;
};
Element.implement(methods);
});
//</1.2compat>
// getProperty / setProperty
var propertyGetters = {},
propertySetters = {};
// properties
var properties = {};
Array.forEach(
[
"type",
"value",
"defaultValue",
"accessKey",
"cellPadding",
"cellSpacing",
"colSpan",
"frameBorder",
"rowSpan",
"tabIndex",
"useMap",
],
function (property) {
properties[property.toLowerCase()] = property;
},
);
properties.html = "innerHTML";
properties.text =
document.createElement("div").textContent == null
? "innerText"
: "textContent";
Object.forEach(properties, function (real, key) {
propertySetters[key] = function (node, value) {
node[real] = value;
};
propertyGetters[key] = function (node) {
return node[real];
};
});
// Booleans
var bools = [
"compact",
"nowrap",
"ismap",
"declare",
"noshade",
"checked",
"disabled",
"readOnly",
"multiple",
"selected",
"noresize",
"defer",
"defaultChecked",
"autofocus",
"controls",
"autoplay",
"loop",
];
var booleans = {};
Array.forEach(bools, function (bool) {
var lower = bool.toLowerCase();
booleans[lower] = bool;
propertySetters[lower] = function (node, value) {
node[bool] = !!value;
};
propertyGetters[lower] = function (node) {
return !!node[bool];
};
});
// Special cases
Object.append(propertySetters, {
class: function (node, value) {
"className" in node
? (node.className = value || "")
: node.setAttribute("class", value);
},
for: function (node, value) {
"htmlFor" in node
? (node.htmlFor = value)
: node.setAttribute("for", value);
},
style: function (node, value) {
node.style
? (node.style.cssText = value)
: node.setAttribute("style", value);
},
value: function (node, value) {
node.value = value != null ? value : "";
},
});
propertyGetters["class"] = function (node) {
return "className" in node
? node.className || null
: node.getAttribute("class");
};
/* <webkit> */
var el = document.createElement("button");
// IE sets type as readonly and throws
try {
el.type = "button";
} catch (e) {}
if (el.type != "button")
propertySetters.type = function (node, value) {
node.setAttribute("type", value);
};
el = null;
/* </webkit> */
/*<IE>*/
var input = document.createElement("input");
input.value = "t";
input.type = "submit";
if (input.value != "t")
propertySetters.type = function (node, type) {
var value = node.value;
node.type = type;
node.value = value;
};
input = null;
/*</IE>*/
/* getProperty, setProperty */
/* <ltIE9> */
var pollutesGetAttribute = (function (div) {
div.random = "attribute";
return div.getAttribute("random") == "attribute";
})(document.createElement("div"));
/* <ltIE9> */
Element.implement({
setProperty: function (name, value) {
var setter = propertySetters[name.toLowerCase()];
if (setter) {
setter(this, value);
} else {
/* <ltIE9> */
if (pollutesGetAttribute)
var attributeWhiteList = this.retrieve("$attributeWhiteList", {});
/* </ltIE9> */
if (value == null) {
this.removeAttribute(name);
/* <ltIE9> */
if (pollutesGetAttribute) delete attributeWhiteList[name];
/* </ltIE9> */
} else {
this.setAttribute(name, "" + value);
/* <ltIE9> */
if (pollutesGetAttribute) attributeWhiteList[name] = true;
/* </ltIE9> */
}
}
return this;
},
setProperties: function (attributes) {
for (var attribute in attributes)
this.setProperty(attribute, attributes[attribute]);
return this;
},
getProperty: function (name) {
var getter = propertyGetters[name.toLowerCase()];
if (getter) return getter(this);
/* <ltIE9> */
if (pollutesGetAttribute) {
var attr = this.getAttributeNode(name),
attributeWhiteList = this.retrieve("$attributeWhiteList", {});
if (!attr) return null;
if (attr.expando && !attributeWhiteList[name]) {
var outer = this.outerHTML;
// segment by the opening tag and find mention of attribute name
if (
outer
.substr(0, outer.search(/\/?['"]?>(?![^<]*<['"])/))
.indexOf(name) < 0
)
return null;
attributeWhiteList[name] = true;
}
}
/* </ltIE9> */
var result = Slick.getAttribute(this, name);
return !result && !Slick.hasAttribute(this, name) ? null : result;
},
getProperties: function () {
var args = Array.from(arguments);
return args.map(this.getProperty, this).associate(args);
},
removeProperty: function (name) {
return this.setProperty(name, null);
},
removeProperties: function () {
Array.each(arguments, this.removeProperty, this);
return this;
},
set: function (prop, value) {
var property = Element.Properties[prop];
property && property.set
? property.set.call(this, value)
: this.setProperty(prop, value);
}.overloadSetter(),
get: function (prop) {
var property = Element.Properties[prop];
return property && property.get
? property.get.apply(this)
: this.getProperty(prop);
}.overloadGetter(),
erase: function (prop) {
var property = Element.Properties[prop];
property && property.erase
? property.erase.apply(this)
: this.removeProperty(prop);
return this;
},
hasClass: function (className) {
return this.className.clean().contains(className, " ");
},
addClass: function (className) {
if (!this.hasClass(className))
this.className = (this.className + " " + className).clean();
return this;
},
removeClass: function (className) {
this.className = this.className.replace(
new RegExp("(^|\\s)" + className + "(?:\\s|$)"),
"$1",
);
return this;
},
toggleClass: function (className, force) {
if (force == null) force = !this.hasClass(className);
return force ? this.addClass(className) : this.removeClass(className);
},
adopt: function () {
var parent = this,
fragment,
elements = Array.flatten(arguments),
length = elements.length;
if (length > 1) parent = fragment = document.createDocumentFragment();
for (var i = 0; i < length; i++) {
var element = document.id(elements[i], true);
if (element) parent.appendChild(element);
}
if (fragment) this.appendChild(fragment);
return this;
},
appendText: function (text, where) {
return this.grab(this.getDocument().newTextNode(text), where);
},
grab: function (el, where) {
inserters[where || "bottom"](document.id(el, true), this);
return this;
},
inject: function (el, where) {
inserters[where || "bottom"](this, document.id(el, true));
return this;
},
replaces: function (el) {
el = document.id(el, true);
el.parentNode.replaceChild(this, el);
return this;
},
wraps: function (el, where) {
el = document.id(el, true);
return this.replaces(el).grab(el, where);
},
getSelected: function () {
this.selectedIndex; // Safari 3.2.1
return new Elements(
Array.from(this.options).filter(function (option) {
return option.selected;
}),
);
},
toQueryString: function () {
var queryString = [];
this.getElements("input, select, textarea").each(function (el) {
var type = el.type;
if (
!el.name ||
el.disabled ||
type == "submit" ||
type == "reset" ||
type == "file" ||
type == "image"
)
return;
var value =
el.get("tag") == "select"
? el.getSelected().map(function (opt) {
// IE
return document.id(opt).get("value");
})
: (type == "radio" || type == "checkbox") && !el.checked
? null
: el.get("value");
Array.from(value).each(function (val) {
if (typeof val != "undefined")
queryString.push(
encodeURIComponent(el.name) + "=" + encodeURIComponent(val),
);
});
});
return queryString.join("&");
},
});
var collected = {},
storage = {};
var get = function (uid) {
return storage[uid] || (storage[uid] = {});
};
var clean = function (item) {
var uid = item.uniqueNumber;
if (item.removeEvents) item.removeEvents();
if (item.clearAttributes) item.clearAttributes();
if (uid != null) {
delete collected[uid];
delete storage[uid];
}
return item;
};
var formProps = { input: "checked", option: "selected", textarea: "value" };
Element.implement({
destroy: function () {
var children = clean(this).getElementsByTagName("*");
Array.each(children, clean);
Element.dispose(this);
return null;
},
empty: function () {
Array.from(this.childNodes).each(Element.dispose);
return this;
},
dispose: function () {
return this.parentNode ? this.parentNode.removeChild(this) : this;
},
clone: function (contents, keepid) {
contents = contents !== false;
var clone = this.cloneNode(contents),
ce = [clone],
te = [this],
i;
if (contents) {
ce.append(Array.from(clone.getElementsByTagName("*")));
te.append(Array.from(this.getElementsByTagName("*")));
}
for (i = ce.length; i--; ) {
var node = ce[i],
element = te[i];
if (!keepid) node.removeAttribute("id");
/*<ltIE9>*/
if (node.clearAttributes) {
node.clearAttributes();
node.mergeAttributes(element);
node.removeAttribute("uniqueNumber");
if (node.options) {
var no = node.options,
eo = element.options;
for (var j = no.length; j--; ) no[j].selected = eo[j].selected;
}
}
/*</ltIE9>*/
var prop = formProps[element.tagName.toLowerCase()];
if (prop && element[prop]) node[prop] = element[prop];
}
/*<ltIE9>*/
if (Browser.ie) {
var co = clone.getElementsByTagName("object"),
to = this.getElementsByTagName("object");
for (i = co.length; i--; ) co[i].outerHTML = to[i].outerHTML;
}
/*</ltIE9>*/
return document.id(clone);
},
});
[Element, Window, Document].invoke("implement", {
addListener: function (type, fn) {
if (type == "unload") {
var old = fn,
self = this;
fn = function () {
self.removeListener("unload", fn);
old();
};
} else {
collected[Slick.uidOf(this)] = this;
}
if (this.addEventListener)
this.addEventListener(type, fn, !!arguments[2]);
else this.attachEvent("on" + type, fn);
return this;
},
removeListener: function (type, fn) {
if (this.removeEventListener)
this.removeEventListener(type, fn, !!arguments[2]);
else this.detachEvent("on" + type, fn);
return this;
},
retrieve: function (property, dflt) {
var storage = get(Slick.uidOf(this)),
prop = storage[property];
if (dflt != null && prop == null) prop = storage[property] = dflt;
return prop != null ? prop : null;
},
store: function (property, value) {
var storage = get(Slick.uidOf(this));
storage[property] = value;
return this;
},
eliminate: function (property) {
var storage = get(Slick.uidOf(this));
delete storage[property];
return this;
},
});
/*<ltIE9>*/
if (window.attachEvent && !window.addEventListener)
window.addListener("unload", function () {
Object.each(collected, clean);
if (window.CollectGarbage) CollectGarbage();
});
/*</ltIE9>*/
Element.Properties = {};
//<1.2compat>
Element.Properties = new Hash();
//</1.2compat>
Element.Properties.style = {
set: function (style) {
this.style.cssText = style;
},
get: function () {
return this.style.cssText;
},
erase: function () {
this.style.cssText = "";
},
};
Element.Properties.tag = {
get: function () {
return this.tagName.toLowerCase();
},
};
Element.Properties.html = {
set: function (html) {
if (html == null) html = "";
else if (typeOf(html) == "array") html = html.join("");
this.innerHTML = html;
},
erase: function () {
this.innerHTML = "";
},
};
/*<ltIE9>*/
// technique by jdbarlett - http://jdbartlett.com/innershiv/
var div = document.createElement("div");
div.innerHTML = "<nav></nav>";
var supportsHTML5Elements = div.childNodes.length == 1;
if (!supportsHTML5Elements) {
var tags =
"abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video".split(
" ",
),
fragment = document.createDocumentFragment(),
l = tags.length;
while (l--) fragment.createElement(tags[l]);
}
div = null;
/*</ltIE9>*/
/*<IE>*/
var supportsTableInnerHTML = Function.attempt(function () {
var table = document.createElement("table");
table.innerHTML = "<tr><td></td></tr>";
return true;
});
/*<ltFF4>*/
var tr = document.createElement("tr"),
html = "<td></td>";
tr.innerHTML = html;
var supportsTRInnerHTML = tr.innerHTML == html;
tr = null;
/*</ltFF4>*/
if (
!supportsTableInnerHTML ||
!supportsTRInnerHTML ||
!supportsHTML5Elements
) {
Element.Properties.html.set = (function (set) {
var translations = {
table: [1, "<table>", "</table>"],
select: [1, "<select>", "</select>"],
tbody: [2, "<table><tbody>", "</tbody></table>"],
tr: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
};
translations.thead = translations.tfoot = translations.tbody;
return function (html) {
var wrap = translations[this.get("tag")];
if (!wrap && !supportsHTML5Elements) wrap = [0, "", ""];
if (!wrap) return set.call(this, html);
var level = wrap[0],
wrapper = document.createElement("div"),
target = wrapper;
if (!supportsHTML5Elements) fragment.appendChild(wrapper);
wrapper.innerHTML = [wrap[1], html, wrap[2]].flatten().join("");
while (level--) target = target.firstChild;
this.empty().adopt(target.childNodes);
if (!supportsHTML5Elements) fragment.removeChild(wrapper);
wrapper = null;
};
})(Element.Properties.html.set);
}
/*</IE>*/
/*<ltIE9>*/
var testForm = document.createElement("form");
testForm.innerHTML = "<select><option>s</option></select>";
if (testForm.firstChild.value != "s")
Element.Properties.value = {
set: function (value) {
var tag = this.get("tag");
if (tag != "select") return this.setProperty("value", value);
var options = this.getElements("option");
for (var i = 0; i < options.length; i++) {
var option = options[i],
attr = option.getAttributeNode("value"),
optionValue =
attr && attr.specified ? option.value : option.get("text");
if (optionValue == value) return (option.selected = true);
}
},
get: function () {
var option = this,
tag = option.get("tag");
if (tag != "select" && tag != "option")
return this.getProperty("value");
if (tag == "select" && !(option = option.getSelected()[0])) return "";
var attr = option.getAttributeNode("value");
return attr && attr.specified ? option.value : option.get("text");
},
};
testForm = null;
/*</ltIE9>*/
/*<IE>*/
if (document.createElement("div").getAttributeNode("id"))
Element.Properties.id = {
set: function (id) {
this.id = this.getAttributeNode("id").value = id;
},
get: function () {
return this.id || null;
},
erase: function () {
this.id = this.getAttributeNode("id").value = "";
},
};
/*</IE>*/
})();
/*
---
name: Element.Style
description: Contains methods for interacting with the styles of Elements in a fashionable way.
license: MIT-style license.
requires: Element
provides: Element.Style
...
*/
(function () {
var html = document.html;
//<ltIE9>
// Check for oldIE, which does not remove styles when they're set to null
var el = document.createElement("div");
el.style.color = "red";
el.style.color = null;
var doesNotRemoveStyles = el.style.color == "red";
el = null;
//</ltIE9>
Element.Properties.styles = {
set: function (styles) {
this.setStyles(styles);
},
};
var hasOpacity = html.style.opacity != null,
hasFilter = html.style.filter != null,
reAlpha = /alpha\(opacity=([\d.]+)\)/i;
var setVisibility = function (element, opacity) {
element.store("$opacity", opacity);
element.style.visibility =
opacity > 0 || opacity == null ? "visible" : "hidden";
};
var setOpacity = hasOpacity
? function (element, opacity) {
element.style.opacity = opacity;
}
: hasFilter
? function (element, opacity) {
var style = element.style;
if (!element.currentStyle || !element.currentStyle.hasLayout)
style.zoom = 1;
if (opacity == null || opacity == 1) opacity = "";
else
opacity =
"alpha(opacity=" + (opacity * 100).limit(0, 100).round() + ")";
var filter = style.filter || element.getComputedStyle("filter") || "";
style.filter = reAlpha.test(filter)
? filter.replace(reAlpha, opacity)
: filter + opacity;
if (!style.filter) style.removeAttribute("filter");
}
: setVisibility;
var getOpacity = hasOpacity
? function (element) {
var opacity =
element.style.opacity || element.getComputedStyle("opacity");
return opacity == "" ? 1 : opacity.toFloat();
}
: hasFilter
? function (element) {
var filter = element.style.filter || element.getComputedStyle("filter"),
opacity;
if (filter) opacity = filter.match(reAlpha);
return opacity == null || filter == null ? 1 : opacity[1] / 100;
}
: function (element) {
var opacity = element.retrieve("$opacity");
if (opacity == null)
opacity = element.style.visibility == "hidden" ? 0 : 1;
return opacity;
};
var floatName = html.style.cssFloat == null ? "styleFloat" : "cssFloat";
Element.implement({
getComputedStyle: function (property) {
if (this.currentStyle) return this.currentStyle[property.camelCase()];
var defaultView = Element.getDocument(this).defaultView,
computed = defaultView
? defaultView.getComputedStyle(this, null)
: null;
return computed
? computed.getPropertyValue(
property == floatName ? "float" : property.hyphenate(),
)
: null;
},
setStyle: function (property, value) {
if (property == "opacity") {
if (value != null) value = parseFloat(value);
setOpacity(this, value);
return this;
}
property = (property == "float" ? floatName : property).camelCase();
if (typeOf(value) != "string") {
var map = (Element.Styles[property] || "@").split(" ");
value = Array.from(value)
.map(function (val, i) {
if (!map[i]) return "";
return typeOf(val) == "number"
? map[i].replace("@", Math.round(val))
: val;
})
.join(" ");
} else if (value == String(Number(value))) {
value = Math.round(value);
}
this.style[property] = value;
//<ltIE9>
if (
(value == "" || value == null) &&
doesNotRemoveStyles &&
this.style.removeAttribute
) {
this.style.removeAttribute(property);
}
//</ltIE9>
return this;
},
getStyle: function (property) {
if (property == "opacity") return getOpacity(this);
property = (property == "float" ? floatName : property).camelCase();
var result = this.style[property];
if (!result || property == "zIndex") {
result = [];
for (var style in Element.ShortStyles) {
if (property != style) continue;
for (var s in Element.ShortStyles[style])
result.push(this.getStyle(s));
return result.join(" ");
}
result = this.getComputedStyle(property);
}
if (result) {
result = String(result);
var color = result.match(/rgba?\([\d\s,]+\)/);
if (color) result = result.replace(color[0], color[0].rgbToHex());
}
if (Browser.opera || Browser.ie) {
if (/^(height|width)$/.test(property) && !/px$/.test(result)) {
var values =
property == "width" ? ["left", "right"] : ["top", "bottom"],
size = 0;
values.each(function (value) {
size +=
this.getStyle("border-" + value + "-width").toInt() +
this.getStyle("padding-" + value).toInt();
}, this);
return this["offset" + property.capitalize()] - size + "px";
}
if (
Browser.ie &&
/^border(.+)Width|margin|padding/.test(property) &&
isNaN(parseFloat(result))
) {
return "0px";
}
}
return result;
},
setStyles: function (styles) {
for (var style in styles) this.setStyle(style, styles[style]);
return this;
},
getStyles: function () {
var result = {};
Array.flatten(arguments).each(function (key) {
result[key] = this.getStyle(key);
}, this);
return result;
},
});
Element.Styles = {
left: "@px",
top: "@px",
bottom: "@px",
right: "@px",
width: "@px",
height: "@px",
maxWidth: "@px",
maxHeight: "@px",
minWidth: "@px",
minHeight: "@px",
backgroundColor: "rgb(@, @, @)",
backgroundPosition: "@px @px",
color: "rgb(@, @, @)",
fontSize: "@px",
letterSpacing: "@px",
lineHeight: "@px",
clip: "rect(@px @px @px @px)",
margin: "@px @px @px @px",
padding: "@px @px @px @px",
border: "@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)",
borderWidth: "@px @px @px @px",
borderStyle: "@ @ @ @",
borderColor: "rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)",
zIndex: "@",
zoom: "@",
fontWeight: "@",
textIndent: "@px",
opacity: "@",
};
//<1.3compat>
Element.implement({
setOpacity: function (value) {
setOpacity(this, value);
return this;
},
getOpacity: function () {
return getOpacity(this);
},
});
Element.Properties.opacity = {
set: function (opacity) {
setOpacity(this, opacity);
setVisibility(this, opacity);
},
get: function () {
return getOpacity(this);
},
};
//</1.3compat>
//<1.2compat>
Element.Styles = new Hash(Element.Styles);
//</1.2compat>
Element.ShortStyles = {
margin: {},
padding: {},
border: {},
borderWidth: {},
borderStyle: {},
borderColor: {},
};
["Top", "Right", "Bottom", "Left"].each(function (direction) {
var Short = Element.ShortStyles;
var All = Element.Styles;
["margin", "padding"].each(function (style) {
var sd = style + direction;
Short[style][sd] = All[sd] = "@px";
});
var bd = "border" + direction;
Short.border[bd] = All[bd] = "@px @ rgb(@, @, @)";
var bdw = bd + "Width",
bds = bd + "Style",
bdc = bd + "Color";
Short[bd] = {};
Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = "@px";
Short.borderStyle[bds] = Short[bd][bds] = All[bds] = "@";
Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = "rgb(@, @, @)";
});
})();
/*
---
name: Element.Event
description: Contains Element methods for dealing with events. This file also includes mouseenter and mouseleave custom Element Events, if necessary.
license: MIT-style license.
requires: [Element, Event]
provides: Element.Event
...
*/
(function () {
Element.Properties.events = {
set: function (events) {
this.addEvents(events);
},
};
[Element, Window, Document].invoke("implement", {
addEvent: function (type, fn) {
var events = this.retrieve("events", {});
if (!events[type]) events[type] = { keys: [], values: [] };
if (events[type].keys.contains(fn)) return this;
events[type].keys.push(fn);
var realType = type,
custom = Element.Events[type],
condition = fn,
self = this;
if (custom) {
if (custom.onAdd) custom.onAdd.call(this, fn, type);
if (custom.condition) {
condition = function (event) {
if (custom.condition.call(this, event, type))
return fn.call(this, event);
return true;
};
}
if (custom.base) realType = Function.from(custom.base).call(this, type);
}
var defn = function () {
return fn.call(self);
};
var nativeEvent = Element.NativeEvents[realType];
if (nativeEvent) {
if (nativeEvent == 2) {
defn = function (event) {
event = new DOMEvent(event, self.getWindow());
if (condition.call(self, event) === false) event.stop();
};
}
this.addListener(realType, defn, arguments[2]);
}
events[type].values.push(defn);
return this;
},
removeEvent: function (type, fn) {
var events = this.retrieve("events");
if (!events || !events[type]) return this;
var list = events[type];
var index = list.keys.indexOf(fn);
if (index == -1) return this;
var value = list.values[index];
delete list.keys[index];
delete list.values[index];
var custom = Element.Events[type];
if (custom) {
if (custom.onRemove) custom.onRemove.call(this, fn, type);
if (custom.base) type = Function.from(custom.base).call(this, type);
}
return Element.NativeEvents[type]
? this.removeListener(type, value, arguments[2])
: this;
},
addEvents: function (events) {
for (var event in events) this.addEvent(event, events[event]);
return this;
},
removeEvents: function (events) {
var type;
if (typeOf(events) == "object") {
for (type in events) this.removeEvent(type, events[type]);
return this;
}
var attached = this.retrieve("events");
if (!attached) return this;
if (!events) {
for (type in attached) this.removeEvents(type);
this.eliminate("events");
} else if (attached[events]) {
attached[events].keys.each(function (fn) {
this.removeEvent(events, fn);
}, this);
delete attached[events];
}
return this;
},
fireEvent: function (type, args, delay) {
var events = this.retrieve("events");
if (!events || !events[type]) return this;
args = Array.from(args);
events[type].keys.each(function (fn) {
if (delay) fn.delay(delay, this, args);
else fn.apply(this, args);
}, this);
return this;
},
cloneEvents: function (from, type) {
from = document.id(from);
var events = from.retrieve("events");
if (!events) return this;
if (!type) {
for (var eventType in events) this.cloneEvents(from, eventType);
} else if (events[type]) {
events[type].keys.each(function (fn) {
this.addEvent(type, fn);
}, this);
}
return this;
},
});
Element.NativeEvents = {
click: 2,
dblclick: 2,
mouseup: 2,
mousedown: 2,
contextmenu: 2, //mouse buttons
mousewheel: 2,
DOMMouseScroll: 2, //mouse wheel
mouseover: 2,
mouseout: 2,
mousemove: 2,
selectstart: 2,
selectend: 2, //mouse movement
keydown: 2,
keypress: 2,
keyup: 2, //keyboard
orientationchange: 2, // mobile
touchstart: 2,
touchmove: 2,
touchend: 2,
touchcancel: 2, // touch
gesturestart: 2,
gesturechange: 2,
gestureend: 2, // gesture
focus: 2,
blur: 2,
change: 2,
reset: 2,
select: 2,
submit: 2,
paste: 2,
input: 2, //form elements
load: 2,
unload: 1,
beforeunload: 2,
resize: 1,
move: 1,
DOMContentLoaded: 1,
readystatechange: 1, //window
error: 1,
abort: 1,
scroll: 1, //misc
};
Element.Events = {
mousewheel: {
base: Browser.firefox ? "DOMMouseScroll" : "mousewheel",
},
};
if ("onmouseenter" in document.documentElement) {
Element.NativeEvents.mouseenter = Element.NativeEvents.mouseleave = 2;
} else {
var check = function (event) {
var related = event.relatedTarget;
if (related == null) return true;
if (!related) return false;
return (
related != this &&
related.prefix != "xul" &&
typeOf(this) != "document" &&
!this.contains(related)
);
};
Element.Events.mouseenter = {
base: "mouseover",
condition: check,
};
Element.Events.mouseleave = {
base: "mouseout",
condition: check,
};
}
/*<ltIE9>*/
if (!window.addEventListener) {
Element.NativeEvents.propertychange = 2;
Element.Events.change = {
base: function () {
var type = this.type;
return this.get("tag") == "input" &&
(type == "radio" || type == "checkbox")
? "propertychange"
: "change";
},
condition: function (event) {
return (
this.type != "radio" ||
(event.event.propertyName == "checked" && this.checked)
);
},
};
}
/*</ltIE9>*/
//<1.2compat>
Element.Events = new Hash(Element.Events);
//</1.2compat>
})();
/*
---
name: Element.Delegation
description: Extends the Element native object to include the delegate method for more efficient event management.
license: MIT-style license.
requires: [Element.Event]
provides: [Element.Delegation]
...
*/
(function () {
var eventListenerSupport = !!window.addEventListener;
Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;
var bubbleUp = function (self, match, fn, event, target) {
while (target && target != self) {
if (match(target, event)) return fn.call(target, event, target);
target = document.id(target.parentNode);
}
};
var map = {
mouseenter: {
base: "mouseover",
},
mouseleave: {
base: "mouseout",
},
focus: {
base: "focus" + (eventListenerSupport ? "" : "in"),
capture: true,
},
blur: {
base: eventListenerSupport ? "blur" : "focusout",
capture: true,
},
};
/*<ltIE9>*/
var _key = "$delegation:";
var formObserver = function (type) {
return {
base: "focusin",
remove: function (self, uid) {
var list = self.retrieve(_key + type + "listeners", {})[uid];
if (list && list.forms)
for (var i = list.forms.length; i--; ) {
list.forms[i].removeEvent(type, list.fns[i]);
}
},
listen: function (self, match, fn, event, target, uid) {
var form =
target.get("tag") == "form" ? target : event.target.getParent("form");
if (!form) return;
var listeners = self.retrieve(_key + type + "listeners", {}),
listener = listeners[uid] || { forms: [], fns: [] },
forms = listener.forms,
fns = listener.fns;
if (forms.indexOf(form) != -1) return;
forms.push(form);
var _fn = function (event) {
bubbleUp(self, match, fn, event, target);
};
form.addEvent(type, _fn);
fns.push(_fn);
listeners[uid] = listener;
self.store(_key + type + "listeners", listeners);
},
};
};
var inputObserver = function (type) {
return {
base: "focusin",
listen: function (self, match, fn, event, target) {
var events = {
blur: function () {
this.removeEvents(events);
},
};
events[type] = function (event) {
bubbleUp(self, match, fn, event, target);
};
event.target.addEvents(events);
},
};
};
if (!eventListenerSupport)
Object.append(map, {
submit: formObserver("submit"),
reset: formObserver("reset"),
change: inputObserver("change"),
select: inputObserver("select"),
});
/*</ltIE9>*/
var proto = Element.prototype,
addEvent = proto.addEvent,
removeEvent = proto.removeEvent;
var relay = function (old, method) {
return function (type, fn, useCapture) {
if (type.indexOf(":relay") == -1)
return old.call(this, type, fn, useCapture);
var parsed = Slick.parse(type).expressions[0][0];
if (parsed.pseudos[0].key != "relay")
return old.call(this, type, fn, useCapture);
var newType = parsed.tag;
parsed.pseudos.slice(1).each(function (pseudo) {
newType +=
":" + pseudo.key + (pseudo.value ? "(" + pseudo.value + ")" : "");
});
old.call(this, type, fn);
return method.call(this, newType, parsed.pseudos[0].value, fn);
};
};
var delegation = {
addEvent: function (type, match, fn) {
var storage = this.retrieve("$delegates", {}),
stored = storage[type];
if (stored)
for (var _uid in stored) {
if (stored[_uid].fn == fn && stored[_uid].match == match) return this;
}
var _type = type,
_match = match,
_fn = fn,
_map = map[type] || {};
type = _map.base || _type;
match = function (target) {
return Slick.match(target, _match);
};
var elementEvent = Element.Events[_type];
if (elementEvent && elementEvent.condition) {
var __match = match,
condition = elementEvent.condition;
match = function (target, event) {
return __match(target, event) && condition.call(target, event, type);
};
}
var self = this,
uid = String.uniqueID();
var delegator = _map.listen
? function (event, target) {
if (!target && event && event.target) target = event.target;
if (target) _map.listen(self, match, fn, event, target, uid);
}
: function (event, target) {
if (!target && event && event.target) target = event.target;
if (target) bubbleUp(self, match, fn, event, target);
};
if (!stored) stored = {};
stored[uid] = {
match: _match,
fn: _fn,
delegator: delegator,
};
storage[_type] = stored;
return addEvent.call(this, type, delegator, _map.capture);
},
removeEvent: function (type, match, fn, _uid) {
var storage = this.retrieve("$delegates", {}),
stored = storage[type];
if (!stored) return this;
if (_uid) {
var _type = type,
delegator = stored[_uid].delegator,
_map = map[type] || {};
type = _map.base || _type;
if (_map.remove) _map.remove(this, _uid);
delete stored[_uid];
storage[_type] = stored;
return removeEvent.call(this, type, delegator);
}
var __uid, s;
if (fn)
for (__uid in stored) {
s = stored[__uid];
if (s.match == match && s.fn == fn)
return delegation.removeEvent.call(this, type, match, fn, __uid);
}
else
for (__uid in stored) {
s = stored[__uid];
if (s.match == match)
delegation.removeEvent.call(this, type, match, s.fn, __uid);
}
return this;
},
};
[Element, Window, Document].invoke("implement", {
addEvent: relay(addEvent, delegation.addEvent),
removeEvent: relay(removeEvent, delegation.removeEvent),
});
})();
/*
---
name: Element.Dimensions
description: Contains methods to work with size, scroll, or positioning of Elements and the window object.
license: MIT-style license.
credits:
- Element positioning based on the [qooxdoo](http://qooxdoo.org/) code and smart browser fixes, [LGPL License](http://www.gnu.org/licenses/lgpl.html).
- Viewport dimensions based on [YUI](http://developer.yahoo.com/yui/) code, [BSD License](http://developer.yahoo.com/yui/license.html).
requires: [Element, Element.Style]
provides: [Element.Dimensions]
...
*/
(function () {
var element = document.createElement("div"),
child = document.createElement("div");
element.style.height = "0";
element.appendChild(child);
var brokenOffsetParent = child.offsetParent === element;
element = child = null;
var isOffset = function (el) {
return styleString(el, "position") != "static" || isBody(el);
};
var isOffsetStatic = function (el) {
return isOffset(el) || /^(?:table|td|th)$/i.test(el.tagName);
};
Element.implement({
scrollTo: function (x, y) {
if (isBody(this)) {
this.getWindow().scrollTo(x, y);
} else {
this.scrollLeft = x;
this.scrollTop = y;
}
return this;
},
getSize: function () {
if (isBody(this)) return this.getWindow().getSize();
return { x: this.offsetWidth, y: this.offsetHeight };
},
getScrollSize: function () {
if (isBody(this)) return this.getWindow().getScrollSize();
return { x: this.scrollWidth, y: this.scrollHeight };
},
getScroll: function () {
if (isBody(this)) return this.getWindow().getScroll();
return { x: this.scrollLeft, y: this.scrollTop };
},
getScrolls: function () {
var element = this.parentNode,
position = { x: 0, y: 0 };
while (element && !isBody(element)) {
position.x += element.scrollLeft;
position.y += element.scrollTop;
element = element.parentNode;
}
return position;
},
getOffsetParent: brokenOffsetParent
? function () {
var element = this;
if (isBody(element) || styleString(element, "position") == "fixed")
return null;
var isOffsetCheck =
styleString(element, "position") == "static"
? isOffsetStatic
: isOffset;
while ((element = element.parentNode)) {
if (isOffsetCheck(element)) return element;
}
return null;
}
: function () {
var element = this;
if (isBody(element) || styleString(element, "position") == "fixed")
return null;
try {
return element.offsetParent;
} catch (e) {}
return null;
},
getOffsets: function () {
if (this.getBoundingClientRect && !Browser.Platform.ios) {
var bound = this.getBoundingClientRect(),
html = document.id(this.getDocument().documentElement),
htmlScroll = html.getScroll(),
elemScrolls = this.getScrolls(),
isFixed = styleString(this, "position") == "fixed";
return {
x:
bound.left.toInt() +
elemScrolls.x +
(isFixed ? 0 : htmlScroll.x) -
html.clientLeft,
y:
bound.top.toInt() +
elemScrolls.y +
(isFixed ? 0 : htmlScroll.y) -
html.clientTop,
};
}
var element = this,
position = { x: 0, y: 0 };
if (isBody(this)) return position;
while (element && !isBody(element)) {
position.x += element.offsetLeft;
position.y += element.offsetTop;
if (Browser.firefox) {
if (!borderBox(element)) {
position.x += leftBorder(element);
position.y += topBorder(element);
}
var parent = element.parentNode;
if (parent && styleString(parent, "overflow") != "visible") {
position.x += leftBorder(parent);
position.y += topBorder(parent);
}
} else if (element != this && Browser.safari) {
position.x += leftBorder(element);
position.y += topBorder(element);
}
element = element.offsetParent;
}
if (Browser.firefox && !borderBox(this)) {
position.x -= leftBorder(this);
position.y -= topBorder(this);
}
return position;
},
getPosition: function (relative) {
var offset = this.getOffsets(),
scroll = this.getScrolls();
var position = {
x: offset.x - scroll.x,
y: offset.y - scroll.y,
};
if (relative && (relative = document.id(relative))) {
var relativePosition = relative.getPosition();
return {
x: position.x - relativePosition.x - leftBorder(relative),
y: position.y - relativePosition.y - topBorder(relative),
};
}
return position;
},
getCoordinates: function (element) {
if (isBody(this)) return this.getWindow().getCoordinates();
var position = this.getPosition(element),
size = this.getSize();
var obj = {
left: position.x,
top: position.y,
width: size.x,
height: size.y,
};
obj.right = obj.left + obj.width;
obj.bottom = obj.top + obj.height;
return obj;
},
computePosition: function (obj) {
return {
left: obj.x - styleNumber(this, "margin-left"),
top: obj.y - styleNumber(this, "margin-top"),
};
},
setPosition: function (obj) {
return this.setStyles(this.computePosition(obj));
},
});
[Document, Window].invoke("implement", {
getSize: function () {
var doc = getCompatElement(this);
return { x: doc.clientWidth, y: doc.clientHeight };
},
getScroll: function () {
var win = this.getWindow(),
doc = getCompatElement(this);
return {
x: win.pageXOffset || doc.scrollLeft,
y: win.pageYOffset || doc.scrollTop,
};
},
getScrollSize: function () {
var doc = getCompatElement(this),
min = this.getSize(),
body = this.getDocument().body;
return {
x: Math.max(doc.scrollWidth, body.scrollWidth, min.x),
y: Math.max(doc.scrollHeight, body.scrollHeight, min.y),
};
},
getPosition: function () {
return { x: 0, y: 0 };
},
getCoordinates: function () {
var size = this.getSize();
return {
top: 0,
left: 0,
bottom: size.y,
right: size.x,
height: size.y,
width: size.x,
};
},
});
// private methods
var styleString = Element.getComputedStyle;
function styleNumber(element, style) {
return styleString(element, style).toInt() || 0;
}
function borderBox(element) {
return styleString(element, "-moz-box-sizing") == "border-box";
}
function topBorder(element) {
return styleNumber(element, "border-top-width");
}
function leftBorder(element) {
return styleNumber(element, "border-left-width");
}
function isBody(element) {
return /^(?:body|html)$/i.test(element.tagName);
}
function getCompatElement(element) {
var doc = element.getDocument();
return !doc.compatMode || doc.compatMode == "CSS1Compat"
? doc.html
: doc.body;
}
})();
//aliases
Element.alias({ position: "setPosition" }); //compatability
[Window, Document, Element].invoke("implement", {
getHeight: function () {
return this.getSize().y;
},
getWidth: function () {
return this.getSize().x;
},
getScrollTop: function () {
return this.getScroll().y;
},
getScrollLeft: function () {
return this.getScroll().x;
},
getScrollHeight: function () {
return this.getScrollSize().y;
},
getScrollWidth: function () {
return this.getScrollSize().x;
},
getTop: function () {
return this.getPosition().y;
},
getLeft: function () {
return this.getPosition().x;
},
});
/*
---
name: Fx
description: Contains the basic animation logic to be extended by all other Fx Classes.
license: MIT-style license.
requires: [Chain, Events, Options]
provides: Fx
...
*/
(function () {
var Fx = (this.Fx = new Class({
Implements: [Chain, Events, Options],
options: {
/*
onStart: nil,
onCancel: nil,
onComplete: nil,
*/
fps: 60,
unit: false,
duration: 500,
frames: null,
frameSkip: true,
link: "ignore",
},
initialize: function (options) {
this.subject = this.subject || this;
this.setOptions(options);
},
getTransition: function () {
return function (p) {
return -(Math.cos(Math.PI * p) - 1) / 2;
};
},
step: function (now) {
if (this.options.frameSkip) {
var diff = this.time != null ? now - this.time : 0,
frames = diff / this.frameInterval;
this.time = now;
this.frame += frames;
} else {
this.frame++;
}
if (this.frame < this.frames) {
var delta = this.transition(this.frame / this.frames);
this.set(this.compute(this.from, this.to, delta));
} else {
this.frame = this.frames;
this.set(this.compute(this.from, this.to, 1));
this.stop();
}
},
set: function (now) {
return now;
},
compute: function (from, to, delta) {
return Fx.compute(from, to, delta);
},
check: function () {
if (!this.isRunning()) return true;
switch (this.options.link) {
case "cancel":
this.cancel();
return true;
case "chain":
this.chain(this.caller.pass(arguments, this));
return false;
}
return false;
},
start: function (from, to) {
if (!this.check(from, to)) return this;
this.from = from;
this.to = to;
this.frame = this.options.frameSkip ? 0 : -1;
this.time = null;
this.transition = this.getTransition();
var frames = this.options.frames,
fps = this.options.fps,
duration = this.options.duration;
this.duration = Fx.Durations[duration] || duration.toInt();
this.frameInterval = 1000 / fps;
this.frames = frames || Math.round(this.duration / this.frameInterval);
this.fireEvent("start", this.subject);
pushInstance.call(this, fps);
return this;
},
stop: function () {
if (this.isRunning()) {
this.time = null;
pullInstance.call(this, this.options.fps);
if (this.frames == this.frame) {
this.fireEvent("complete", this.subject);
if (!this.callChain()) this.fireEvent("chainComplete", this.subject);
} else {
this.fireEvent("stop", this.subject);
}
}
return this;
},
cancel: function () {
if (this.isRunning()) {
this.time = null;
pullInstance.call(this, this.options.fps);
this.frame = this.frames;
this.fireEvent("cancel", this.subject).clearChain();
}
return this;
},
pause: function () {
if (this.isRunning()) {
this.time = null;
pullInstance.call(this, this.options.fps);
}
return this;
},
resume: function () {
if (this.frame < this.frames && !this.isRunning())
pushInstance.call(this, this.options.fps);
return this;
},
isRunning: function () {
var list = instances[this.options.fps];
return list && list.contains(this);
},
}));
Fx.compute = function (from, to, delta) {
return (to - from) * delta + from;
};
Fx.Durations = { short: 250, normal: 500, long: 1000 };
// global timers
var instances = {},
timers = {};
var loop = function () {
var now = Date.now();
for (var i = this.length; i--; ) {
var instance = this[i];
if (instance) instance.step(now);
}
};
var pushInstance = function (fps) {
var list = instances[fps] || (instances[fps] = []);
list.push(this);
if (!timers[fps])
timers[fps] = loop.periodical(Math.round(1000 / fps), list);
};
var pullInstance = function (fps) {
var list = instances[fps];
if (list) {
list.erase(this);
if (!list.length && timers[fps]) {
delete instances[fps];
timers[fps] = clearInterval(timers[fps]);
}
}
};
})();
/*
---
name: Fx.CSS
description: Contains the CSS animation logic. Used by Fx.Tween, Fx.Morph, Fx.Elements.
license: MIT-style license.
requires: [Fx, Element.Style]
provides: Fx.CSS
...
*/
Fx.CSS = new Class({
Extends: Fx,
//prepares the base from/to object
prepare: function (element, property, values) {
values = Array.from(values);
var from = values[0],
to = values[1];
if (to == null) {
to = from;
from = element.getStyle(property);
var unit = this.options.unit;
// adapted from: https://github.com/ryanmorr/fx/blob/master/fx.js#L299
if (unit && from.slice(-unit.length) != unit && parseFloat(from) != 0) {
element.setStyle(property, to + unit);
var value = element.getComputedStyle(property);
// IE and Opera support pixelLeft or pixelWidth
if (!/px$/.test(value)) {
value = element.style[("pixel-" + property).camelCase()];
if (value == null) {
// adapted from Dean Edwards' http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
var left = element.style.left;
element.style.left = to + unit;
value = element.style.pixelLeft;
element.style.left = left;
}
}
from = ((to || 1) / (parseFloat(value) || 1)) * (parseFloat(from) || 0);
element.setStyle(property, from + unit);
}
}
return { from: this.parse(from), to: this.parse(to) };
},
//parses a value into an array
parse: function (value) {
value = Function.from(value)();
value = typeof value == "string" ? value.split(" ") : Array.from(value);
return value.map(function (val) {
val = String(val);
var found = false;
Object.each(Fx.CSS.Parsers, function (parser, key) {
if (found) return;
var parsed = parser.parse(val);
if (parsed || parsed === 0) found = { value: parsed, parser: parser };
});
found = found || { value: val, parser: Fx.CSS.Parsers.String };
return found;
});
},
//computes by a from and to prepared objects, using their parsers.
compute: function (from, to, delta) {
var computed = [];
Math.min(from.length, to.length).times(function (i) {
computed.push({
value: from[i].parser.compute(from[i].value, to[i].value, delta),
parser: from[i].parser,
});
});
computed.$family = Function.from("fx:css:value");
return computed;
},
//serves the value as settable
serve: function (value, unit) {
if (typeOf(value) != "fx:css:value") value = this.parse(value);
var returned = [];
value.each(function (bit) {
returned = returned.concat(bit.parser.serve(bit.value, unit));
});
return returned;
},
//renders the change to an element
render: function (element, property, value, unit) {
element.setStyle(property, this.serve(value, unit));
},
//searches inside the page css to find the values for a selector
search: function (selector) {
if (Fx.CSS.Cache[selector]) return Fx.CSS.Cache[selector];
var to = {},
selectorTest = new RegExp("^" + selector.escapeRegExp() + "$");
Array.each(document.styleSheets, function (sheet, j) {
var href = sheet.href;
if (href && href.contains("://") && !href.contains(document.domain))
return;
var rules = sheet.rules || sheet.cssRules;
Array.each(rules, function (rule, i) {
if (!rule.style) return;
var selectorText = rule.selectorText
? rule.selectorText.replace(/^\w+/, function (m) {
return m.toLowerCase();
})
: null;
if (!selectorText || !selectorTest.test(selectorText)) return;
Object.each(Element.Styles, function (value, style) {
if (!rule.style[style] || Element.ShortStyles[style]) return;
value = String(rule.style[style]);
to[style] = /^rgb/.test(value) ? value.rgbToHex() : value;
});
});
});
return (Fx.CSS.Cache[selector] = to);
},
});
Fx.CSS.Cache = {};
Fx.CSS.Parsers = {
Color: {
parse: function (value) {
if (value.match(/^#[0-9a-f]{3,6}$/i)) return value.hexToRgb(true);
return (value = value.match(/(\d+),\s*(\d+),\s*(\d+)/))
? [value[1], value[2], value[3]]
: false;
},
compute: function (from, to, delta) {
return from.map(function (value, i) {
return Math.round(Fx.compute(from[i], to[i], delta));
});
},
serve: function (value) {
return value.map(Number);
},
},
Number: {
parse: parseFloat,
compute: Fx.compute,
serve: function (value, unit) {
return unit ? value + unit : value;
},
},
String: {
parse: Function.from(false),
compute: function (zero, one) {
return one;
},
serve: function (zero) {
return zero;
},
},
};
//<1.2compat>
Fx.CSS.Parsers = new Hash(Fx.CSS.Parsers);
//</1.2compat>
/*
---
name: Fx.Tween
description: Formerly Fx.Style, effect to transition any CSS property for an element.
license: MIT-style license.
requires: Fx.CSS
provides: [Fx.Tween, Element.fade, Element.highlight]
...
*/
Fx.Tween = new Class({
Extends: Fx.CSS,
initialize: function (element, options) {
this.element = this.subject = document.id(element);
this.parent(options);
},
set: function (property, now) {
if (arguments.length == 1) {
now = property;
property = this.property || this.options.property;
}
this.render(this.element, property, now, this.options.unit);
return this;
},
start: function (property, from, to) {
if (!this.check(property, from, to)) return this;
var args = Array.flatten(arguments);
this.property = this.options.property || args.shift();
var parsed = this.prepare(this.element, this.property, args);
return this.parent(parsed.from, parsed.to);
},
});
Element.Properties.tween = {
set: function (options) {
this.get("tween").cancel().setOptions(options);
return this;
},
get: function () {
var tween = this.retrieve("tween");
if (!tween) {
tween = new Fx.Tween(this, { link: "cancel" });
this.store("tween", tween);
}
return tween;
},
};
Element.implement({
tween: function (property, from, to) {
this.get("tween").start(property, from, to);
return this;
},
fade: function (how) {
var fade = this.get("tween"),
method,
args = ["opacity"].append(arguments),
toggle;
if (args[1] == null) args[1] = "toggle";
switch (args[1]) {
case "in":
method = "start";
args[1] = 1;
break;
case "out":
method = "start";
args[1] = 0;
break;
case "show":
method = "set";
args[1] = 1;
break;
case "hide":
method = "set";
args[1] = 0;
break;
case "toggle":
var flag = this.retrieve("fade:flag", this.getStyle("opacity") == 1);
method = "start";
args[1] = flag ? 0 : 1;
this.store("fade:flag", !flag);
toggle = true;
break;
default:
method = "start";
}
if (!toggle) this.eliminate("fade:flag");
fade[method].apply(fade, args);
var to = args[args.length - 1];
if (method == "set" || to != 0)
this.setStyle("visibility", to == 0 ? "hidden" : "visible");
else
fade.chain(function () {
this.element.setStyle("visibility", "hidden");
this.callChain();
});
return this;
},
highlight: function (start, end) {
if (!end) {
end = this.retrieve(
"highlight:original",
this.getStyle("background-color"),
);
end = end == "transparent" ? "#fff" : end;
}
var tween = this.get("tween");
tween.start("background-color", start || "#ffff88", end).chain(
function () {
this.setStyle("background-color", this.retrieve("highlight:original"));
tween.callChain();
}.bind(this),
);
return this;
},
});
/*
---
name: Fx.Morph
description: Formerly Fx.Styles, effect to transition any number of CSS properties for an element using an object of rules, or CSS based selector rules.
license: MIT-style license.
requires: Fx.CSS
provides: Fx.Morph
...
*/
Fx.Morph = new Class({
Extends: Fx.CSS,
initialize: function (element, options) {
this.element = this.subject = document.id(element);
this.parent(options);
},
set: function (now) {
if (typeof now == "string") now = this.search(now);
for (var p in now) this.render(this.element, p, now[p], this.options.unit);
return this;
},
compute: function (from, to, delta) {
var now = {};
for (var p in from) now[p] = this.parent(from[p], to[p], delta);
return now;
},
start: function (properties) {
if (!this.check(properties)) return this;
if (typeof properties == "string") properties = this.search(properties);
var from = {},
to = {};
for (var p in properties) {
var parsed = this.prepare(this.element, p, properties[p]);
from[p] = parsed.from;
to[p] = parsed.to;
}
return this.parent(from, to);
},
});
Element.Properties.morph = {
set: function (options) {
this.get("morph").cancel().setOptions(options);
return this;
},
get: function () {
var morph = this.retrieve("morph");
if (!morph) {
morph = new Fx.Morph(this, { link: "cancel" });
this.store("morph", morph);
}
return morph;
},
};
Element.implement({
morph: function (props) {
this.get("morph").start(props);
return this;
},
});
/*
---
name: Fx.Transitions
description: Contains a set of advanced transitions to be used with any of the Fx Classes.
license: MIT-style license.
credits:
- Easing Equations by Robert Penner, <http://www.robertpenner.com/easing/>, modified and optimized to be used with MooTools.
requires: Fx
provides: Fx.Transitions
...
*/
Fx.implement({
getTransition: function () {
var trans = this.options.transition || Fx.Transitions.Sine.easeInOut;
if (typeof trans == "string") {
var data = trans.split(":");
trans = Fx.Transitions;
trans = trans[data[0]] || trans[data[0].capitalize()];
if (data[1])
trans =
trans[
"ease" +
data[1].capitalize() +
(data[2] ? data[2].capitalize() : "")
];
}
return trans;
},
});
Fx.Transition = function (transition, params) {
params = Array.from(params);
var easeIn = function (pos) {
return transition(pos, params);
};
return Object.append(easeIn, {
easeIn: easeIn,
easeOut: function (pos) {
return 1 - transition(1 - pos, params);
},
easeInOut: function (pos) {
return (
(pos <= 0.5
? transition(2 * pos, params)
: 2 - transition(2 * (1 - pos), params)) / 2
);
},
});
};
Fx.Transitions = {
linear: function (zero) {
return zero;
},
};
//<1.2compat>
Fx.Transitions = new Hash(Fx.Transitions);
//</1.2compat>
Fx.Transitions.extend = function (transitions) {
for (var transition in transitions)
Fx.Transitions[transition] = new Fx.Transition(transitions[transition]);
};
Fx.Transitions.extend({
Pow: function (p, x) {
return Math.pow(p, (x && x[0]) || 6);
},
Expo: function (p) {
return Math.pow(2, 8 * (p - 1));
},
Circ: function (p) {
return 1 - Math.sin(Math.acos(p));
},
Sine: function (p) {
return 1 - Math.cos((p * Math.PI) / 2);
},
Back: function (p, x) {
x = (x && x[0]) || 1.618;
return Math.pow(p, 2) * ((x + 1) * p - x);
},
Bounce: function (p) {
var value;
for (var a = 0, b = 1; 1; a += b, b /= 2) {
if (p >= (7 - 4 * a) / 11) {
value = b * b - Math.pow((11 - 6 * a - 11 * p) / 4, 2);
break;
}
}
return value;
},
Elastic: function (p, x) {
return (
Math.pow(2, 10 * --p) *
Math.cos((20 * p * Math.PI * ((x && x[0]) || 1)) / 3)
);
},
});
["Quad", "Cubic", "Quart", "Quint"].each(function (transition, i) {
Fx.Transitions[transition] = new Fx.Transition(function (p) {
return Math.pow(p, i + 2);
});
});
/*
---
name: Request
description: Powerful all purpose Request Class. Uses XMLHTTPRequest.
license: MIT-style license.
requires: [Object, Element, Chain, Events, Options, Browser]
provides: Request
...
*/
(function () {
var empty = function () {},
progressSupport = "onprogress" in new Browser.Request();
var Request = (this.Request = new Class({
Implements: [Chain, Events, Options],
options: {
/*
onRequest: function(){},
onLoadstart: function(event, xhr){},
onProgress: function(event, xhr){},
onComplete: function(){},
onCancel: function(){},
onSuccess: function(responseText, responseXML){},
onFailure: function(xhr){},
onException: function(headerName, value){},
onTimeout: function(){},
user: '',
password: '',*/
url: "",
data: "",
headers: {
"X-Requested-With": "XMLHttpRequest",
Accept: "text/javascript, text/html, application/xml, text/xml, */*",
},
async: true,
format: false,
method: "post",
link: "ignore",
isSuccess: null,
emulation: true,
urlEncoded: true,
encoding: "utf-8",
evalScripts: false,
evalResponse: false,
timeout: 0,
noCache: false,
},
initialize: function (options) {
this.xhr = new Browser.Request();
this.setOptions(options);
this.headers = this.options.headers;
},
onStateChange: function () {
var xhr = this.xhr;
if (xhr.readyState != 4 || !this.running) return;
this.running = false;
this.status = 0;
Function.attempt(
function () {
var status = xhr.status;
this.status = status == 1223 ? 204 : status;
}.bind(this),
);
xhr.onreadystatechange = empty;
if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
clearTimeout(this.timer);
this.response = {
text: this.xhr.responseText || "",
xml: this.xhr.responseXML,
};
if (this.options.isSuccess.call(this, this.status))
this.success(this.response.text, this.response.xml);
else this.failure();
},
isSuccess: function () {
var status = this.status;
return status >= 200 && status < 300;
},
isRunning: function () {
return !!this.running;
},
processScripts: function (text) {
if (
this.options.evalResponse ||
/(ecma|java)script/.test(this.getHeader("Content-type"))
)
return Browser.exec(text);
return text.stripScripts(this.options.evalScripts);
},
success: function (text, xml) {
this.onSuccess(this.processScripts(text), xml);
},
onSuccess: function () {
this.fireEvent("complete", arguments)
.fireEvent("success", arguments)
.callChain();
},
failure: function () {
this.onFailure();
},
onFailure: function () {
this.fireEvent("complete").fireEvent("failure", this.xhr);
},
loadstart: function (event) {
this.fireEvent("loadstart", [event, this.xhr]);
},
progress: function (event) {
this.fireEvent("progress", [event, this.xhr]);
},
timeout: function () {
this.fireEvent("timeout", this.xhr);
},
setHeader: function (name, value) {
this.headers[name] = value;
return this;
},
getHeader: function (name) {
return Function.attempt(
function () {
return this.xhr.getResponseHeader(name);
}.bind(this),
);
},
check: function () {
if (!this.running) return true;
switch (this.options.link) {
case "cancel":
this.cancel();
return true;
case "chain":
this.chain(this.caller.pass(arguments, this));
return false;
}
return false;
},
send: function (options) {
if (!this.check(options)) return this;
this.options.isSuccess = this.options.isSuccess || this.isSuccess;
this.running = true;
var type = typeOf(options);
if (type == "string" || type == "element") options = { data: options };
var old = this.options;
options = Object.append(
{ data: old.data, url: old.url, method: old.method },
options,
);
var data = options.data,
url = String(options.url),
method = options.method.toLowerCase();
switch (typeOf(data)) {
case "element":
data = document.id(data).toQueryString();
break;
case "object":
case "hash":
data = Object.toQueryString(data);
}
if (this.options.format) {
var format = "format=" + this.options.format;
data = data ? format + "&" + data : format;
}
if (this.options.emulation && !["get", "post"].contains(method)) {
var _method = "_method=" + method;
data = data ? _method + "&" + data : _method;
method = "post";
}
if (this.options.urlEncoded && ["post", "put"].contains(method)) {
var encoding = this.options.encoding
? "; charset=" + this.options.encoding
: "";
this.headers["Content-type"] =
"application/x-www-form-urlencoded" + encoding;
}
if (!url) url = document.location.pathname;
var trimPosition = url.lastIndexOf("/");
if (trimPosition > -1 && (trimPosition = url.indexOf("#")) > -1)
url = url.substr(0, trimPosition);
if (this.options.noCache)
url += (url.contains("?") ? "&" : "?") + String.uniqueID();
if (data && method == "get") {
url += (url.contains("?") ? "&" : "?") + data;
data = null;
}
var xhr = this.xhr;
if (progressSupport) {
xhr.onloadstart = this.loadstart.bind(this);
xhr.onprogress = this.progress.bind(this);
}
xhr.open(
method.toUpperCase(),
url,
this.options.async,
this.options.user,
this.options.password,
);
if (this.options.user && "withCredentials" in xhr)
xhr.withCredentials = true;
xhr.onreadystatechange = this.onStateChange.bind(this);
Object.each(
this.headers,
function (value, key) {
try {
xhr.setRequestHeader(key, value);
} catch (e) {
this.fireEvent("exception", [key, value]);
}
},
this,
);
this.fireEvent("request");
xhr.send(data);
if (!this.options.async) this.onStateChange();
else if (this.options.timeout)
this.timer = this.timeout.delay(this.options.timeout, this);
return this;
},
cancel: function () {
if (!this.running) return this;
this.running = false;
var xhr = this.xhr;
xhr.abort();
clearTimeout(this.timer);
xhr.onreadystatechange = empty;
if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
this.xhr = new Browser.Request();
this.fireEvent("cancel");
return this;
},
}));
var methods = {};
["get", "post", "put", "delete", "GET", "POST", "PUT", "DELETE"].each(
function (method) {
methods[method] = function (data) {
var object = {
method: method,
};
if (data != null) object.data = data;
return this.send(object);
};
},
);
Request.implement(methods);
Element.Properties.send = {
set: function (options) {
var send = this.get("send").cancel();
send.setOptions(options);
return this;
},
get: function () {
var send = this.retrieve("send");
if (!send) {
send = new Request({
data: this,
link: "cancel",
method: this.get("method") || "post",
url: this.get("action"),
});
this.store("send", send);
}
return send;
},
};
Element.implement({
send: function (url) {
var sender = this.get("send");
sender.send({ data: this, url: url || sender.options.url });
return this;
},
});
})();
/*
---
name: Request.HTML
description: Extends the basic Request Class with additional methods for interacting with HTML responses.
license: MIT-style license.
requires: [Element, Request]
provides: Request.HTML
...
*/
Request.HTML = new Class({
Extends: Request,
options: {
update: false,
append: false,
evalScripts: true,
filter: false,
headers: {
Accept: "text/html, application/xml, text/xml, */*",
},
},
success: function (text) {
var options = this.options,
response = this.response;
response.html = text.stripScripts(function (script) {
response.javascript = script;
});
var match = response.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
if (match) response.html = match[1];
var temp = new Element("div").set("html", response.html);
response.tree = temp.childNodes;
response.elements = temp.getElements(options.filter || "*");
if (options.filter) response.tree = response.elements;
if (options.update) {
var update = document.id(options.update).empty();
if (options.filter) update.adopt(response.elements);
else update.set("html", response.html);
} else if (options.append) {
var append = document.id(options.append);
if (options.filter) response.elements.reverse().inject(append);
else append.adopt(temp.getChildren());
}
if (options.evalScripts) Browser.exec(response.javascript);
this.onSuccess(
response.tree,
response.elements,
response.html,
response.javascript,
);
},
});
Element.Properties.load = {
set: function (options) {
var load = this.get("load").cancel();
load.setOptions(options);
return this;
},
get: function () {
var load = this.retrieve("load");
if (!load) {
load = new Request.HTML({
data: this,
link: "cancel",
update: this,
method: "get",
});
this.store("load", load);
}
return load;
},
};
Element.implement({
load: function () {
this.get("load").send(
Array.link(arguments, { data: Type.isObject, url: Type.isString }),
);
return this;
},
});
/*
---
name: JSON
description: JSON encoder and decoder.
license: MIT-style license.
SeeAlso: <http://www.json.org/>
requires: [Array, String, Number, Function]
provides: JSON
...
*/
if (typeof JSON == "undefined") this.JSON = {};
//<1.2compat>
JSON = new Hash({
stringify: JSON.stringify,
parse: JSON.parse,
});
//</1.2compat>
(function () {
var special = {
"\b": "\\b",
"\t": "\\t",
"\n": "\\n",
"\f": "\\f",
"\r": "\\r",
'"': '\\"',
"\\": "\\\\",
};
var escape = function (chr) {
return (
special[chr] ||
"\\u" + ("0000" + chr.charCodeAt(0).toString(16)).slice(-4)
);
};
JSON.validate = function (string) {
string = string
.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
.replace(
/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
"]",
)
.replace(/(?:^|:|,)(?:\s*\[)+/g, "");
return /^[\],:{}\s]*$/.test(string);
};
JSON.encode = JSON.stringify
? function (obj) {
return JSON.stringify(obj);
}
: function (obj) {
if (obj && obj.toJSON) obj = obj.toJSON();
switch (typeOf(obj)) {
case "string":
return '"' + obj.replace(/[\x00-\x1f\\"]/g, escape) + '"';
case "array":
return "[" + obj.map(JSON.encode).clean() + "]";
case "object":
case "hash":
var string = [];
Object.each(obj, function (value, key) {
var json = JSON.encode(value);
if (json) string.push(JSON.encode(key) + ":" + json);
});
return "{" + string + "}";
case "number":
case "boolean":
return "" + obj;
case "null":
return "null";
}
return null;
};
JSON.decode = function (string, secure) {
if (!string || typeOf(string) != "string") return null;
if (secure || JSON.secure) {
if (JSON.parse) return JSON.parse(string);
if (!JSON.validate(string))
throw new Error(
"JSON could not decode the input; security is enabled and the value is not secure.",
);
}
return eval("(" + string + ")");
};
})();
/*
---
name: Request.JSON
description: Extends the basic Request Class with additional methods for sending and receiving JSON data.
license: MIT-style license.
requires: [Request, JSON]
provides: Request.JSON
...
*/
Request.JSON = new Class({
Extends: Request,
options: {
/*onError: function(text, error){},*/
secure: true,
},
initialize: function (options) {
this.parent(options);
Object.append(this.headers, {
Accept: "application/json",
"X-Request": "JSON",
});
},
success: function (text) {
var json;
try {
json = this.response.json = JSON.decode(text, this.options.secure);
} catch (error) {
this.fireEvent("error", [text, error]);
return;
}
if (json == null) this.onFailure();
else this.onSuccess(json, text);
},
});
/*
---
name: Cookie
description: Class for creating, reading, and deleting browser Cookies.
license: MIT-style license.
credits:
- Based on the functions by Peter-Paul Koch (http://quirksmode.org).
requires: [Options, Browser]
provides: Cookie
...
*/
var Cookie = new Class({
Implements: Options,
options: {
path: "/",
domain: false,
duration: false,
secure: false,
document: document,
encode: true,
},
initialize: function (key, options) {
this.key = key;
this.setOptions(options);
},
write: function (value) {
if (this.options.encode) value = encodeURIComponent(value);
if (this.options.domain) value += "; domain=" + this.options.domain;
if (this.options.path) value += "; path=" + this.options.path;
if (this.options.duration) {
var date = new Date();
date.setTime(
date.getTime() + this.options.duration * 24 * 60 * 60 * 1000,
);
value += "; expires=" + date.toGMTString();
}
if (this.options.secure) value += "; secure";
this.options.document.cookie = this.key + "=" + value;
return this;
},
read: function () {
var value = this.options.document.cookie.match(
"(?:^|;)\\s*" + this.key.escapeRegExp() + "=([^;]*)",
);
return value ? decodeURIComponent(value[1]) : null;
},
dispose: function () {
new Cookie(
this.key,
Object.merge({}, this.options, { duration: -1 }),
).write("");
return this;
},
});
Cookie.write = function (key, value, options) {
return new Cookie(key, options).write(value);
};
Cookie.read = function (key) {
return new Cookie(key).read();
};
Cookie.dispose = function (key, options) {
return new Cookie(key, options).dispose();
};
/*
---
name: DOMReady
description: Contains the custom event domready.
license: MIT-style license.
requires: [Browser, Element, Element.Event]
provides: [DOMReady, DomReady]
...
*/
(function (window, document) {
var ready,
loaded,
checks = [],
shouldPoll,
timer,
testElement = document.createElement("div");
var domready = function () {
clearTimeout(timer);
if (ready) return;
Browser.loaded = ready = true;
document
.removeListener("DOMContentLoaded", domready)
.removeListener("readystatechange", check);
document.fireEvent("domready");
window.fireEvent("domready");
};
var check = function () {
for (var i = checks.length; i--; )
if (checks[i]()) {
domready();
return true;
}
return false;
};
var poll = function () {
clearTimeout(timer);
if (!check()) timer = setTimeout(poll, 10);
};
document.addListener("DOMContentLoaded", domready);
/*<ltIE8>*/
// doScroll technique by Diego Perini http://javascript.nwbox.com/IEContentLoaded/
// testElement.doScroll() throws when the DOM is not ready, only in the top window
var doScrollWorks = function () {
try {
testElement.doScroll();
return true;
} catch (e) {}
return false;
};
// If doScroll works already, it can't be used to determine domready
// e.g. in an iframe
if (testElement.doScroll && !doScrollWorks()) {
checks.push(doScrollWorks);
shouldPoll = true;
}
/*</ltIE8>*/
if (document.readyState)
checks.push(function () {
var state = document.readyState;
return state == "loaded" || state == "complete";
});
if ("onreadystatechange" in document)
document.addListener("readystatechange", check);
else shouldPoll = true;
if (shouldPoll) poll();
Element.Events.domready = {
onAdd: function (fn) {
if (ready) fn.call(this);
},
};
// Make sure that domready fires before load
Element.Events.load = {
base: "load",
onAdd: function (fn) {
if (loaded && this == window) fn.call(this);
},
condition: function () {
if (this == window) {
domready();
delete Element.Events.load;
}
return true;
},
};
// This is based on the custom load event
window.addEvent("load", function () {
loaded = true;
});
})(window, document);
/*
---
name: Swiff
description: Wrapper for embedding SWF movies. Supports External Interface Communication.
license: MIT-style license.
credits:
- Flash detection & Internet Explorer + Flash Player 9 fix inspired by SWFObject.
requires: [Options, Object, Element]
provides: Swiff
...
*/
(function () {
var Swiff = (this.Swiff = new Class({
Implements: Options,
options: {
id: null,
height: 1,
width: 1,
container: null,
properties: {},
params: {
quality: "high",
allowScriptAccess: "always",
wMode: "window",
swLiveConnect: true,
},
callBacks: {},
vars: {},
},
toElement: function () {
return this.object;
},
initialize: function (path, options) {
this.instance = "Swiff_" + String.uniqueID();
this.setOptions(options);
options = this.options;
var id = (this.id = options.id || this.instance);
var container = document.id(options.container);
Swiff.CallBacks[this.instance] = {};
var params = options.params,
vars = options.vars,
callBacks = options.callBacks;
var properties = Object.append(
{ height: options.height, width: options.width },
options.properties,
);
var self = this;
for (var callBack in callBacks) {
Swiff.CallBacks[this.instance][callBack] = (function (option) {
return function () {
return option.apply(self.object, arguments);
};
})(callBacks[callBack]);
vars[callBack] = "Swiff.CallBacks." + this.instance + "." + callBack;
}
params.flashVars = Object.toQueryString(vars);
if (Browser.ie) {
properties.classid = "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000";
params.movie = path;
} else {
properties.type = "application/x-shockwave-flash";
}
properties.data = path;
var build = '<object id="' + id + '"';
for (var property in properties)
build += " " + property + '="' + properties[property] + '"';
build += ">";
for (var param in params) {
if (params[param])
build +=
'<param name="' + param + '" value="' + params[param] + '" />';
}
build += "</object>";
this.object = (container ? container.empty() : new Element("div")).set(
"html",
build,
).firstChild;
},
replaces: function (element) {
element = document.id(element, true);
element.parentNode.replaceChild(this.toElement(), element);
return this;
},
inject: function (element) {
document.id(element, true).appendChild(this.toElement());
return this;
},
remote: function () {
return Swiff.remote.apply(Swiff, [this.toElement()].append(arguments));
},
}));
Swiff.CallBacks = {};
Swiff.remote = function (obj, fn) {
var rs = obj.CallFunction(
'<invoke name="' +
fn +
'" returntype="javascript">' +
__flash__argumentsToXML(arguments, 2) +
"</invoke>",
);
return eval(rs);
};
})();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/react-17.0.1.js | JavaScript | /** @license React v17.0.1
* react.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
"use strict";
if (process.env.NODE_ENV !== "production") {
(function () {
"use strict";
var _assign = require("object-assign");
// TODO: this is special because it gets imported during build.
var ReactVersion = "17.0.1";
// ATTENTION
// When adding new symbols to this file,
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var REACT_ELEMENT_TYPE = 0xeac7;
var REACT_PORTAL_TYPE = 0xeaca;
exports.Fragment = 0xeacb;
exports.StrictMode = 0xeacc;
exports.Profiler = 0xead2;
var REACT_PROVIDER_TYPE = 0xeacd;
var REACT_CONTEXT_TYPE = 0xeace;
var REACT_FORWARD_REF_TYPE = 0xead0;
exports.Suspense = 0xead1;
var REACT_SUSPENSE_LIST_TYPE = 0xead8;
var REACT_MEMO_TYPE = 0xead3;
var REACT_LAZY_TYPE = 0xead4;
var REACT_BLOCK_TYPE = 0xead9;
var REACT_SERVER_BLOCK_TYPE = 0xeada;
var REACT_FUNDAMENTAL_TYPE = 0xead5;
var REACT_SCOPE_TYPE = 0xead7;
var REACT_OPAQUE_ID_TYPE = 0xeae0;
var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
var REACT_OFFSCREEN_TYPE = 0xeae2;
var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
if (typeof Symbol === "function" && Symbol.for) {
var symbolFor = Symbol.for;
REACT_ELEMENT_TYPE = symbolFor("react.element");
REACT_PORTAL_TYPE = symbolFor("react.portal");
exports.Fragment = symbolFor("react.fragment");
exports.StrictMode = symbolFor("react.strict_mode");
exports.Profiler = symbolFor("react.profiler");
REACT_PROVIDER_TYPE = symbolFor("react.provider");
REACT_CONTEXT_TYPE = symbolFor("react.context");
REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
exports.Suspense = symbolFor("react.suspense");
REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
REACT_MEMO_TYPE = symbolFor("react.memo");
REACT_LAZY_TYPE = symbolFor("react.lazy");
REACT_BLOCK_TYPE = symbolFor("react.block");
REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
REACT_SCOPE_TYPE = symbolFor("react.scope");
REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
}
var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = "@@iterator";
function getIteratorFn(maybeIterable) {
if (maybeIterable === null || typeof maybeIterable !== "object") {
return null;
}
var maybeIterator =
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
maybeIterable[FAUX_ITERATOR_SYMBOL];
if (typeof maybeIterator === "function") {
return maybeIterator;
}
return null;
}
/**
* Keeps track of the current dispatcher.
*/
var ReactCurrentDispatcher = {
/**
* @internal
* @type {ReactComponent}
*/
current: null,
};
/**
* Keeps track of the current batch's configuration such as how long an update
* should suspend for if it needs to.
*/
var ReactCurrentBatchConfig = {
transition: 0,
};
/**
* Keeps track of the current owner.
*
* The current owner is the component who should own any components that are
* currently being constructed.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null,
};
var ReactDebugCurrentFrame = {};
var currentExtraStackFrame = null;
function setExtraStackFrame(stack) {
{
currentExtraStackFrame = stack;
}
}
{
ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {
{
currentExtraStackFrame = stack;
}
}; // Stack implementation injected by the current renderer.
ReactDebugCurrentFrame.getCurrentStack = null;
ReactDebugCurrentFrame.getStackAddendum = function () {
var stack = ""; // Add an extra top frame while an element is being validated
if (currentExtraStackFrame) {
stack += currentExtraStackFrame;
} // Delegate to the injected renderer-specific implementation
var impl = ReactDebugCurrentFrame.getCurrentStack;
if (impl) {
stack += impl() || "";
}
return stack;
};
}
/**
* Used by act() to track whether you're inside an act() scope.
*/
var IsSomeRendererActing = {
current: false,
};
var ReactSharedInternals = {
ReactCurrentDispatcher: ReactCurrentDispatcher,
ReactCurrentBatchConfig: ReactCurrentBatchConfig,
ReactCurrentOwner: ReactCurrentOwner,
IsSomeRendererActing: IsSomeRendererActing,
// Used by renderers to avoid bundling object-assign twice in UMD bundles:
assign: _assign,
};
{
ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
}
// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
function warn(format) {
{
for (
var _len = arguments.length,
args = new Array(_len > 1 ? _len - 1 : 0),
_key = 1;
_key < _len;
_key++
) {
args[_key - 1] = arguments[_key];
}
printWarning("warn", format, args);
}
}
function error(format) {
{
for (
var _len2 = arguments.length,
args = new Array(_len2 > 1 ? _len2 - 1 : 0),
_key2 = 1;
_key2 < _len2;
_key2++
) {
args[_key2 - 1] = arguments[_key2];
}
printWarning("error", format, args);
}
}
function printWarning(level, format, args) {
// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{
var ReactDebugCurrentFrame =
ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame.getStackAddendum();
if (stack !== "") {
format += "%s";
args = args.concat([stack]);
}
var argsWithFormat = args.map(function (item) {
return "" + item;
}); // Careful: RN currently depends on this prefix
argsWithFormat.unshift("Warning: " + format); // We intentionally don't use spread (or .apply) directly because it
// breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
}
var didWarnStateUpdateForUnmountedComponent = {};
function warnNoop(publicInstance, callerName) {
{
var _constructor = publicInstance.constructor;
var componentName =
(_constructor && (_constructor.displayName || _constructor.name)) ||
"ReactClass";
var warningKey = componentName + "." + callerName;
if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
return;
}
error(
"Can't call %s on a component that is not yet mounted. " +
"This is a no-op, but it might indicate a bug in your application. " +
"Instead, assign to `this.state` directly or define a `state = {};` " +
"class property with the desired state in the %s component.",
callerName,
componentName,
);
didWarnStateUpdateForUnmountedComponent[warningKey] = true;
}
}
/**
* This is the abstract API for an update queue.
*/
var ReactNoopUpdateQueue = {
/**
* Checks whether or not this composite component is mounted.
* @param {ReactClass} publicInstance The instance we want to test.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function (publicInstance) {
return false;
},
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/
enqueueForceUpdate: function (publicInstance, callback, callerName) {
warnNoop(publicInstance, "forceUpdate");
},
/**
* Replaces all of the state. Always use this or `setState` to mutate state.
* You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} completeState Next state.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/
enqueueReplaceState: function (
publicInstance,
completeState,
callback,
callerName,
) {
warnNoop(publicInstance, "replaceState");
},
/**
* Sets a subset of the state. This only exists because _pendingState is
* internal. This provides a merging strategy that is not available to deep
* properties which is confusing. TODO: Expose pendingState or don't use it
* during the merge.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialState Next partial state to be merged with state.
* @param {?function} callback Called after component is updated.
* @param {?string} Name of the calling function in the public API.
* @internal
*/
enqueueSetState: function (
publicInstance,
partialState,
callback,
callerName,
) {
warnNoop(publicInstance, "setState");
},
};
var emptyObject = {};
{
Object.freeze(emptyObject);
}
/**
* Base class helpers for the updating state of a component.
*/
function Component(props, context, updater) {
this.props = props;
this.context = context; // If a component has string refs, we will assign a different object later.
this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
// renderer.
this.updater = updater || ReactNoopUpdateQueue;
}
Component.prototype.isReactComponent = {};
/**
* Sets a subset of the state. Always use this to mutate
* state. You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* There is no guarantee that calls to `setState` will run synchronously,
* as they may eventually be batched together. You can provide an optional
* callback that will be executed when the call to setState is actually
* completed.
*
* When a function is provided to setState, it will be called at some point in
* the future (not synchronously). It will be called with the up to date
* component arguments (state, props, context). These values can be different
* from this.* because your function may be called after receiveProps but before
* shouldComponentUpdate, and this new state, props, and context will not yet be
* assigned to this.
*
* @param {object|function} partialState Next partial state or function to
* produce next partial state to be merged with current state.
* @param {?function} callback Called after state is updated.
* @final
* @protected
*/
Component.prototype.setState = function (partialState, callback) {
if (
!(
typeof partialState === "object" ||
typeof partialState === "function" ||
partialState == null
)
) {
{
throw Error(
"setState(...): takes an object of state variables to update or a function which returns an object of state variables.",
);
}
}
this.updater.enqueueSetState(this, partialState, callback, "setState");
};
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {?function} callback Called after update is complete.
* @final
* @protected
*/
Component.prototype.forceUpdate = function (callback) {
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
};
/**
* Deprecated APIs. These APIs used to exist on classic React classes but since
* we would like to deprecate them, we're not going to move them over to this
* modern base class. Instead, we define a getter that warns if it's accessed.
*/
{
var deprecatedAPIs = {
isMounted: [
"isMounted",
"Instead, make sure to clean up subscriptions and pending requests in " +
"componentWillUnmount to prevent memory leaks.",
],
replaceState: [
"replaceState",
"Refactor your code to use setState instead (see " +
"https://github.com/facebook/react/issues/3236).",
],
};
var defineDeprecationWarning = function (methodName, info) {
Object.defineProperty(Component.prototype, methodName, {
get: function () {
warn(
"%s(...) is deprecated in plain JavaScript React classes. %s",
info[0],
info[1],
);
return undefined;
},
});
};
for (var fnName in deprecatedAPIs) {
if (deprecatedAPIs.hasOwnProperty(fnName)) {
defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
}
}
}
function ComponentDummy() {}
ComponentDummy.prototype = Component.prototype;
/**
* Convenience component with default shallow equality check for sCU.
*/
function PureComponent(props, context, updater) {
this.props = props;
this.context = context; // If a component has string refs, we will assign a different object later.
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
}
var pureComponentPrototype = (PureComponent.prototype =
new ComponentDummy());
pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
_assign(pureComponentPrototype, Component.prototype);
pureComponentPrototype.isPureReactComponent = true;
// an immutable object with a single mutable value
function createRef() {
var refObject = {
current: null,
};
{
Object.seal(refObject);
}
return refObject;
}
function getWrappedName(outerType, innerType, wrapperName) {
var functionName = innerType.displayName || innerType.name || "";
return (
outerType.displayName ||
(functionName !== ""
? wrapperName + "(" + functionName + ")"
: wrapperName)
);
}
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentName(type) {
if (type == null) {
// Host root, text node or just invalid type.
return null;
}
{
if (typeof type.tag === "number") {
error(
"Received an unexpected object in getComponentName(). " +
"This is likely a bug in React. Please file an issue.",
);
}
}
if (typeof type === "function") {
return type.displayName || type.name || null;
}
if (typeof type === "string") {
return type;
}
switch (type) {
case exports.Fragment:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case exports.Profiler:
return "Profiler";
case exports.StrictMode:
return "StrictMode";
case exports.Suspense:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_CONTEXT_TYPE:
var context = type;
return getContextName(context) + ".Consumer";
case REACT_PROVIDER_TYPE:
var provider = type;
return getContextName(provider._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
return getWrappedName(type, type.render, "ForwardRef");
case REACT_MEMO_TYPE:
return getComponentName(type.type);
case REACT_BLOCK_TYPE:
return getComponentName(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
return getComponentName(init(payload));
} catch (x) {
return null;
}
}
}
}
return null;
}
var hasOwnProperty = Object.prototype.hasOwnProperty;
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true,
};
var specialPropKeyWarningShown,
specialPropRefWarningShown,
didWarnAboutStringRefs;
{
didWarnAboutStringRefs = {};
}
function hasValidRef(config) {
{
if (hasOwnProperty.call(config, "ref")) {
var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.ref !== undefined;
}
function hasValidKey(config) {
{
if (hasOwnProperty.call(config, "key")) {
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.key !== undefined;
}
function defineKeyPropWarningGetter(props, displayName) {
var warnAboutAccessingKey = function () {
{
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
error(
"%s: `key` is not a prop. Trying to access it will result " +
"in `undefined` being returned. If you need to access the same " +
"value within the child component, you should pass it as a different " +
"prop. (https://reactjs.org/link/special-props)",
displayName,
);
}
}
};
warnAboutAccessingKey.isReactWarning = true;
Object.defineProperty(props, "key", {
get: warnAboutAccessingKey,
configurable: true,
});
}
function defineRefPropWarningGetter(props, displayName) {
var warnAboutAccessingRef = function () {
{
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
error(
"%s: `ref` is not a prop. Trying to access it will result " +
"in `undefined` being returned. If you need to access the same " +
"value within the child component, you should pass it as a different " +
"prop. (https://reactjs.org/link/special-props)",
displayName,
);
}
}
};
warnAboutAccessingRef.isReactWarning = true;
Object.defineProperty(props, "ref", {
get: warnAboutAccessingRef,
configurable: true,
});
}
function warnIfStringRefCannotBeAutoConverted(config) {
{
if (
typeof config.ref === "string" &&
ReactCurrentOwner.current &&
config.__self &&
ReactCurrentOwner.current.stateNode !== config.__self
) {
var componentName = getComponentName(ReactCurrentOwner.current.type);
if (!didWarnAboutStringRefs[componentName]) {
error(
'Component "%s" contains the string ref "%s". ' +
"Support for string refs will be removed in a future major release. " +
"This case cannot be automatically converted to an arrow function. " +
"We ask you to manually fix this case by using useRef() or createRef() instead. " +
"Learn more about using refs safely here: " +
"https://reactjs.org/link/strict-mode-string-ref",
componentName,
config.ref,
);
didWarnAboutStringRefs[componentName] = true;
}
}
}
}
/**
* Factory method to create a new React element. This no longer adheres to
* the class pattern, so do not use new to call it. Also, instanceof check
* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
* if something is a React Element.
*
* @param {*} type
* @param {*} props
* @param {*} key
* @param {string|object} ref
* @param {*} owner
* @param {*} self A *temporary* helper to detect places where `this` is
* different from the `owner` when React.createElement is called, so that we
* can warn. We want to get rid of owner and replace string `ref`s with arrow
* functions, and as long as `this` and owner are the same, there will be no
* change in behavior.
* @param {*} source An annotation object (added by a transpiler or otherwise)
* indicating filename, line number, and/or other information.
* @internal
*/
var ReactElement = function (type, key, ref, self, source, owner, props) {
var element = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner,
};
{
// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
// the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
Object.defineProperty(element._store, "validated", {
configurable: false,
enumerable: false,
writable: true,
value: false,
}); // self and source are DEV only properties.
Object.defineProperty(element, "_self", {
configurable: false,
enumerable: false,
writable: false,
value: self,
}); // Two elements created in two different places should be considered
// equal for testing purposes and therefore we hide it from enumeration.
Object.defineProperty(element, "_source", {
configurable: false,
enumerable: false,
writable: false,
value: source,
});
if (Object.freeze) {
Object.freeze(element.props);
Object.freeze(element);
}
}
return element;
};
/**
* Create and return a new ReactElement of the given type.
* See https://reactjs.org/docs/react-api.html#createelement
*/
function createElement(type, config, children) {
var propName; // Reserved names are extracted
var props = {};
var key = null;
var ref = null;
var self = null;
var source = null;
if (config != null) {
if (hasValidRef(config)) {
ref = config.ref;
{
warnIfStringRefCannotBeAutoConverted(config);
}
}
if (hasValidKey(config)) {
key = "" + config.key;
}
self = config.__self === undefined ? null : config.__self;
source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
for (propName in config) {
if (
hasOwnProperty.call(config, propName) &&
!RESERVED_PROPS.hasOwnProperty(propName)
) {
props[propName] = config[propName];
}
}
} // Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
{
if (Object.freeze) {
Object.freeze(childArray);
}
}
props.children = childArray;
} // Resolve default props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for (propName in defaultProps) {
if (props[propName] === undefined) {
props[propName] = defaultProps[propName];
}
}
}
{
if (key || ref) {
var displayName =
typeof type === "function"
? type.displayName || type.name || "Unknown"
: type;
if (key) {
defineKeyPropWarningGetter(props, displayName);
}
if (ref) {
defineRefPropWarningGetter(props, displayName);
}
}
}
return ReactElement(
type,
key,
ref,
self,
source,
ReactCurrentOwner.current,
props,
);
}
function cloneAndReplaceKey(oldElement, newKey) {
var newElement = ReactElement(
oldElement.type,
newKey,
oldElement.ref,
oldElement._self,
oldElement._source,
oldElement._owner,
oldElement.props,
);
return newElement;
}
/**
* Clone and return a new ReactElement using element as the starting point.
* See https://reactjs.org/docs/react-api.html#cloneelement
*/
function cloneElement(element, config, children) {
if (!!(element === null || element === undefined)) {
{
throw Error(
"React.cloneElement(...): The argument must be a React element, but you passed " +
element +
".",
);
}
}
var propName; // Original props are copied
var props = _assign({}, element.props); // Reserved names are extracted
var key = element.key;
var ref = element.ref; // Self is preserved since the owner is preserved.
var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
// transpiler, and the original source is probably a better indicator of the
// true owner.
var source = element._source; // Owner will be preserved, unless ref is overridden
var owner = element._owner;
if (config != null) {
if (hasValidRef(config)) {
// Silently steal the ref from the parent.
ref = config.ref;
owner = ReactCurrentOwner.current;
}
if (hasValidKey(config)) {
key = "" + config.key;
} // Remaining properties override existing props
var defaultProps;
if (element.type && element.type.defaultProps) {
defaultProps = element.type.defaultProps;
}
for (propName in config) {
if (
hasOwnProperty.call(config, propName) &&
!RESERVED_PROPS.hasOwnProperty(propName)
) {
if (config[propName] === undefined && defaultProps !== undefined) {
// Resolve default props
props[propName] = defaultProps[propName];
} else {
props[propName] = config[propName];
}
}
}
} // Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
props.children = childArray;
}
return ReactElement(element.type, key, ref, self, source, owner, props);
}
/**
* Verifies the object is a ReactElement.
* See https://reactjs.org/docs/react-api.html#isvalidelement
* @param {?object} object
* @return {boolean} True if `object` is a ReactElement.
* @final
*/
function isValidElement(object) {
return (
typeof object === "object" &&
object !== null &&
object.$$typeof === REACT_ELEMENT_TYPE
);
}
var SEPARATOR = ".";
var SUBSEPARATOR = ":";
/**
* Escape and wrap key so it is safe to use as a reactid
*
* @param {string} key to be escaped.
* @return {string} the escaped key.
*/
function escape(key) {
var escapeRegex = /[=:]/g;
var escaperLookup = {
"=": "=0",
":": "=2",
};
var escapedString = key.replace(escapeRegex, function (match) {
return escaperLookup[match];
});
return "$" + escapedString;
}
/**
* TODO: Test that a single child and an array with one item have the same key
* pattern.
*/
var didWarnAboutMaps = false;
var userProvidedKeyEscapeRegex = /\/+/g;
function escapeUserProvidedKey(text) {
return text.replace(userProvidedKeyEscapeRegex, "$&/");
}
/**
* Generate a key string that identifies a element within a set.
*
* @param {*} element A element that could contain a manual key.
* @param {number} index Index that is used if a manual key is not provided.
* @return {string}
*/
function getElementKey(element, index) {
// Do some typechecking here since we call this blindly. We want to ensure
// that we don't block potential future ES APIs.
if (
typeof element === "object" &&
element !== null &&
element.key != null
) {
// Explicit key
return escape("" + element.key);
} // Implicit key determined by the index in the set
return index.toString(36);
}
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
var type = typeof children;
if (type === "undefined" || type === "boolean") {
// All of the above are perceived as null.
children = null;
}
var invokeCallback = false;
if (children === null) {
invokeCallback = true;
} else {
switch (type) {
case "string":
case "number":
invokeCallback = true;
break;
case "object":
switch (children.$$typeof) {
case REACT_ELEMENT_TYPE:
case REACT_PORTAL_TYPE:
invokeCallback = true;
}
}
}
if (invokeCallback) {
var _child = children;
var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
// so that it's consistent if the number of children grows:
var childKey =
nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
if (Array.isArray(mappedChild)) {
var escapedChildKey = "";
if (childKey != null) {
escapedChildKey = escapeUserProvidedKey(childKey) + "/";
}
mapIntoArray(mappedChild, array, escapedChildKey, "", function (c) {
return c;
});
} else if (mappedChild != null) {
if (isValidElement(mappedChild)) {
mappedChild = cloneAndReplaceKey(
mappedChild, // Keep both the (mapped) and old keys if they differ, just as
// traverseAllChildren used to do for objects as children
escapedPrefix + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
(mappedChild.key && (!_child || _child.key !== mappedChild.key) // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
? escapeUserProvidedKey("" + mappedChild.key) + "/"
: "") +
childKey,
);
}
array.push(mappedChild);
}
return 1;
}
var child;
var nextName;
var subtreeCount = 0; // Count of children found in the current subtree.
var nextNamePrefix =
nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
child = children[i];
nextName = nextNamePrefix + getElementKey(child, i);
subtreeCount += mapIntoArray(
child,
array,
escapedPrefix,
nextName,
callback,
);
}
} else {
var iteratorFn = getIteratorFn(children);
if (typeof iteratorFn === "function") {
var iterableChildren = children;
{
// Warn about using Maps as children
if (iteratorFn === iterableChildren.entries) {
if (!didWarnAboutMaps) {
warn(
"Using Maps as children is not supported. " +
"Use an array of keyed ReactElements instead.",
);
}
didWarnAboutMaps = true;
}
}
var iterator = iteratorFn.call(iterableChildren);
var step;
var ii = 0;
while (!(step = iterator.next()).done) {
child = step.value;
nextName = nextNamePrefix + getElementKey(child, ii++);
subtreeCount += mapIntoArray(
child,
array,
escapedPrefix,
nextName,
callback,
);
}
} else if (type === "object") {
var childrenString = "" + children;
{
{
throw Error(
"Objects are not valid as a React child (found: " +
(childrenString === "[object Object]"
? "object with keys {" +
Object.keys(children).join(", ") +
"}"
: childrenString) +
"). If you meant to render a collection of children, use an array instead.",
);
}
}
}
}
return subtreeCount;
}
/**
* Maps children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenmap
*
* The provided mapFunction(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} func The map function.
* @param {*} context Context for mapFunction.
* @return {object} Object containing the ordered map of results.
*/
function mapChildren(children, func, context) {
if (children == null) {
return children;
}
var result = [];
var count = 0;
mapIntoArray(children, result, "", "", function (child) {
return func.call(context, child, count++);
});
return result;
}
/**
* Count the number of children that are typically specified as
* `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrencount
*
* @param {?*} children Children tree container.
* @return {number} The number of children.
*/
function countChildren(children) {
var n = 0;
mapChildren(children, function () {
n++; // Don't return anything
});
return n;
}
/**
* Iterates through children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenforeach
*
* The provided forEachFunc(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} forEachFunc
* @param {*} forEachContext Context for forEachContext.
*/
function forEachChildren(children, forEachFunc, forEachContext) {
mapChildren(
children,
function () {
forEachFunc.apply(this, arguments); // Don't return anything.
},
forEachContext,
);
}
/**
* Flatten a children object (typically specified as `props.children`) and
* return an array with appropriately re-keyed children.
*
* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
*/
function toArray(children) {
return (
mapChildren(children, function (child) {
return child;
}) || []
);
}
/**
* Returns the first child in a collection of children and verifies that there
* is only one child in the collection.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenonly
*
* The current implementation of this function assumes that a single child gets
* passed without a wrapper, but the purpose of this helper function is to
* abstract away the particular structure of children.
*
* @param {?object} children Child collection structure.
* @return {ReactElement} The first and only `ReactElement` contained in the
* structure.
*/
function onlyChild(children) {
if (!isValidElement(children)) {
{
throw Error(
"React.Children.only expected to receive a single React element child.",
);
}
}
return children;
}
function createContext(defaultValue, calculateChangedBits) {
if (calculateChangedBits === undefined) {
calculateChangedBits = null;
} else {
{
if (
calculateChangedBits !== null &&
typeof calculateChangedBits !== "function"
) {
error(
"createContext: Expected the optional second argument to be a " +
"function. Instead received: %s",
calculateChangedBits,
);
}
}
}
var context = {
$$typeof: REACT_CONTEXT_TYPE,
_calculateChangedBits: calculateChangedBits,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
_currentValue: defaultValue,
_currentValue2: defaultValue,
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount: 0,
// These are circular
Provider: null,
Consumer: null,
};
context.Provider = {
$$typeof: REACT_PROVIDER_TYPE,
_context: context,
};
var hasWarnedAboutUsingNestedContextConsumers = false;
var hasWarnedAboutUsingConsumerProvider = false;
var hasWarnedAboutDisplayNameOnConsumer = false;
{
// A separate object, but proxies back to the original context object for
// backwards compatibility. It has a different $$typeof, so we can properly
// warn for the incorrect usage of Context as a Consumer.
var Consumer = {
$$typeof: REACT_CONTEXT_TYPE,
_context: context,
_calculateChangedBits: context._calculateChangedBits,
}; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
Object.defineProperties(Consumer, {
Provider: {
get: function () {
if (!hasWarnedAboutUsingConsumerProvider) {
hasWarnedAboutUsingConsumerProvider = true;
error(
"Rendering <Context.Consumer.Provider> is not supported and will be removed in " +
"a future major release. Did you mean to render <Context.Provider> instead?",
);
}
return context.Provider;
},
set: function (_Provider) {
context.Provider = _Provider;
},
},
_currentValue: {
get: function () {
return context._currentValue;
},
set: function (_currentValue) {
context._currentValue = _currentValue;
},
},
_currentValue2: {
get: function () {
return context._currentValue2;
},
set: function (_currentValue2) {
context._currentValue2 = _currentValue2;
},
},
_threadCount: {
get: function () {
return context._threadCount;
},
set: function (_threadCount) {
context._threadCount = _threadCount;
},
},
Consumer: {
get: function () {
if (!hasWarnedAboutUsingNestedContextConsumers) {
hasWarnedAboutUsingNestedContextConsumers = true;
error(
"Rendering <Context.Consumer.Consumer> is not supported and will be removed in " +
"a future major release. Did you mean to render <Context.Consumer> instead?",
);
}
return context.Consumer;
},
},
displayName: {
get: function () {
return context.displayName;
},
set: function (displayName) {
if (!hasWarnedAboutDisplayNameOnConsumer) {
warn(
"Setting `displayName` on Context.Consumer has no effect. " +
"You should set it directly on the context with Context.displayName = '%s'.",
displayName,
);
hasWarnedAboutDisplayNameOnConsumer = true;
}
},
},
}); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
context.Consumer = Consumer;
}
{
context._currentRenderer = null;
context._currentRenderer2 = null;
}
return context;
}
var Uninitialized = -1;
var Pending = 0;
var Resolved = 1;
var Rejected = 2;
function lazyInitializer(payload) {
if (payload._status === Uninitialized) {
var ctor = payload._result;
var thenable = ctor(); // Transition to the next state.
var pending = payload;
pending._status = Pending;
pending._result = thenable;
thenable.then(
function (moduleObject) {
if (payload._status === Pending) {
var defaultExport = moduleObject.default;
{
if (defaultExport === undefined) {
error(
"lazy: Expected the result of a dynamic import() call. " +
"Instead received: %s\n\nYour code should look like: \n " + // Break up imports to avoid accidentally parsing them as dependencies.
"const MyComponent = lazy(() => imp" +
"ort('./MyComponent'))",
moduleObject,
);
}
} // Transition to the next state.
var resolved = payload;
resolved._status = Resolved;
resolved._result = defaultExport;
}
},
function (error) {
if (payload._status === Pending) {
// Transition to the next state.
var rejected = payload;
rejected._status = Rejected;
rejected._result = error;
}
},
);
}
if (payload._status === Resolved) {
return payload._result;
} else {
throw payload._result;
}
}
function lazy(ctor) {
var payload = {
// We use these fields to store the result.
_status: -1,
_result: ctor,
};
var lazyType = {
$$typeof: REACT_LAZY_TYPE,
_payload: payload,
_init: lazyInitializer,
};
{
// In production, this would just set it on the object.
var defaultProps;
var propTypes; // $FlowFixMe
Object.defineProperties(lazyType, {
defaultProps: {
configurable: true,
get: function () {
return defaultProps;
},
set: function (newDefaultProps) {
error(
"React.lazy(...): It is not supported to assign `defaultProps` to " +
"a lazy component import. Either specify them where the component " +
"is defined, or create a wrapping component around it.",
);
defaultProps = newDefaultProps; // Match production behavior more closely:
// $FlowFixMe
Object.defineProperty(lazyType, "defaultProps", {
enumerable: true,
});
},
},
propTypes: {
configurable: true,
get: function () {
return propTypes;
},
set: function (newPropTypes) {
error(
"React.lazy(...): It is not supported to assign `propTypes` to " +
"a lazy component import. Either specify them where the component " +
"is defined, or create a wrapping component around it.",
);
propTypes = newPropTypes; // Match production behavior more closely:
// $FlowFixMe
Object.defineProperty(lazyType, "propTypes", {
enumerable: true,
});
},
},
});
}
return lazyType;
}
function forwardRef(render) {
{
if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
error(
"forwardRef requires a render function but received a `memo` " +
"component. Instead of forwardRef(memo(...)), use " +
"memo(forwardRef(...)).",
);
} else if (typeof render !== "function") {
error(
"forwardRef requires a render function but was given %s.",
render === null ? "null" : typeof render,
);
} else {
if (render.length !== 0 && render.length !== 2) {
error(
"forwardRef render functions accept exactly two parameters: props and ref. %s",
render.length === 1
? "Did you forget to use the ref parameter?"
: "Any additional parameter will be undefined.",
);
}
}
if (render != null) {
if (render.defaultProps != null || render.propTypes != null) {
error(
"forwardRef render functions do not support propTypes or defaultProps. " +
"Did you accidentally pass a React component?",
);
}
}
}
var elementType = {
$$typeof: REACT_FORWARD_REF_TYPE,
render: render,
};
{
var ownName;
Object.defineProperty(elementType, "displayName", {
enumerable: false,
configurable: true,
get: function () {
return ownName;
},
set: function (name) {
ownName = name;
if (render.displayName == null) {
render.displayName = name;
}
},
});
}
return elementType;
}
// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
var enableScopeAPI = false; // Experimental Create Event Handle API.
function isValidElementType(type) {
if (typeof type === "string" || typeof type === "function") {
return true;
} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
if (
type === exports.Fragment ||
type === exports.Profiler ||
type === REACT_DEBUG_TRACING_MODE_TYPE ||
type === exports.StrictMode ||
type === exports.Suspense ||
type === REACT_SUSPENSE_LIST_TYPE ||
type === REACT_LEGACY_HIDDEN_TYPE ||
enableScopeAPI
) {
return true;
}
if (typeof type === "object" && type !== null) {
if (
type.$$typeof === REACT_LAZY_TYPE ||
type.$$typeof === REACT_MEMO_TYPE ||
type.$$typeof === REACT_PROVIDER_TYPE ||
type.$$typeof === REACT_CONTEXT_TYPE ||
type.$$typeof === REACT_FORWARD_REF_TYPE ||
type.$$typeof === REACT_FUNDAMENTAL_TYPE ||
type.$$typeof === REACT_BLOCK_TYPE ||
type[0] === REACT_SERVER_BLOCK_TYPE
) {
return true;
}
}
return false;
}
function memo(type, compare) {
{
if (!isValidElementType(type)) {
error(
"memo: The first argument must be a component. Instead " +
"received: %s",
type === null ? "null" : typeof type,
);
}
}
var elementType = {
$$typeof: REACT_MEMO_TYPE,
type: type,
compare: compare === undefined ? null : compare,
};
{
var ownName;
Object.defineProperty(elementType, "displayName", {
enumerable: false,
configurable: true,
get: function () {
return ownName;
},
set: function (name) {
ownName = name;
if (type.displayName == null) {
type.displayName = name;
}
},
});
}
return elementType;
}
function resolveDispatcher() {
var dispatcher = ReactCurrentDispatcher.current;
if (!(dispatcher !== null)) {
{
throw Error(
"Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.",
);
}
}
return dispatcher;
}
function useContext(Context, unstable_observedBits) {
var dispatcher = resolveDispatcher();
{
if (unstable_observedBits !== undefined) {
error(
"useContext() second argument is reserved for future " +
"use in React. Passing it is not supported. " +
"You passed: %s.%s",
unstable_observedBits,
typeof unstable_observedBits === "number" &&
Array.isArray(arguments[2])
? "\n\nDid you call array.map(useContext)? " +
"Calling Hooks inside a loop is not supported. " +
"Learn more at https://reactjs.org/link/rules-of-hooks"
: "",
);
} // TODO: add a more generic warning for invalid values.
if (Context._context !== undefined) {
var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
// and nobody should be using this in existing code.
if (realContext.Consumer === Context) {
error(
"Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be " +
"removed in a future major release. Did you mean to call useContext(Context) instead?",
);
} else if (realContext.Provider === Context) {
error(
"Calling useContext(Context.Provider) is not supported. " +
"Did you mean to call useContext(Context) instead?",
);
}
}
}
return dispatcher.useContext(Context, unstable_observedBits);
}
function useState(initialState) {
var dispatcher = resolveDispatcher();
return dispatcher.useState(initialState);
}
function useReducer(reducer, initialArg, init) {
var dispatcher = resolveDispatcher();
return dispatcher.useReducer(reducer, initialArg, init);
}
function useRef(initialValue) {
var dispatcher = resolveDispatcher();
return dispatcher.useRef(initialValue);
}
function useEffect(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useEffect(create, deps);
}
function useLayoutEffect(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useLayoutEffect(create, deps);
}
function useCallback(callback, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useCallback(callback, deps);
}
function useMemo(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useMemo(create, deps);
}
function useImperativeHandle(ref, create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useImperativeHandle(ref, create, deps);
}
function useDebugValue(value, formatterFn) {
{
var dispatcher = resolveDispatcher();
return dispatcher.useDebugValue(value, formatterFn);
}
}
// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
// We could also eagerly patch the method.
var disabledDepth = 0;
var prevLog;
var prevInfo;
var prevWarn;
var prevError;
var prevGroup;
var prevGroupCollapsed;
var prevGroupEnd;
function disabledLog() {}
disabledLog.__reactDisabledLog = true;
function disableLogs() {
{
if (disabledDepth === 0) {
/* eslint-disable react-internal/no-production-logging */
prevLog = console.log;
prevInfo = console.info;
prevWarn = console.warn;
prevError = console.error;
prevGroup = console.group;
prevGroupCollapsed = console.groupCollapsed;
prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
var props = {
configurable: true,
enumerable: true,
value: disabledLog,
writable: true,
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props,
});
/* eslint-enable react-internal/no-production-logging */
}
disabledDepth++;
}
}
function reenableLogs() {
{
disabledDepth--;
if (disabledDepth === 0) {
/* eslint-disable react-internal/no-production-logging */
var props = {
configurable: true,
enumerable: true,
writable: true,
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
log: _assign({}, props, {
value: prevLog,
}),
info: _assign({}, props, {
value: prevInfo,
}),
warn: _assign({}, props, {
value: prevWarn,
}),
error: _assign({}, props, {
value: prevError,
}),
group: _assign({}, props, {
value: prevGroup,
}),
groupCollapsed: _assign({}, props, {
value: prevGroupCollapsed,
}),
groupEnd: _assign({}, props, {
value: prevGroupEnd,
}),
});
/* eslint-enable react-internal/no-production-logging */
}
if (disabledDepth < 0) {
error(
"disabledDepth fell below zero. " +
"This is a bug in React. Please file an issue.",
);
}
}
}
var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
var prefix;
function describeBuiltInComponentFrame(name, source, ownerFn) {
{
if (prefix === undefined) {
// Extract the VM specific prefix used by each line.
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = (match && match[1]) || "";
}
} // We use the prefix to ensure our stacks line up with native stack frames.
return "\n" + prefix + name;
}
}
var reentry = false;
var componentFrameCache;
{
var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
componentFrameCache = new PossiblyWeakMap();
}
function describeNativeComponentFrame(fn, construct) {
// If something asked for a stack inside a fake render, it should get ignored.
if (!fn || reentry) {
return "";
}
{
var frame = componentFrameCache.get(fn);
if (frame !== undefined) {
return frame;
}
}
var control;
reentry = true;
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
Error.prepareStackTrace = undefined;
var previousDispatcher;
{
previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
// for warnings.
ReactCurrentDispatcher$1.current = null;
disableLogs();
}
try {
// This should throw.
if (construct) {
// Something should be setting the props in the constructor.
var Fake = function () {
throw Error();
}; // $FlowFixMe
Object.defineProperty(Fake.prototype, "props", {
set: function () {
// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throw Error();
},
});
if (typeof Reflect === "object" && Reflect.construct) {
// We construct a different control for this case to include any extra
// frames added by the construct call.
try {
Reflect.construct(Fake, []);
} catch (x) {
control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x) {
control = x;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x) {
control = x;
}
fn();
}
} catch (sample) {
// This is inlined manually because closure doesn't do it for us.
if (sample && control && typeof sample.stack === "string") {
// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
var sampleLines = sample.stack.split("\n");
var controlLines = control.stack.split("\n");
var s = sampleLines.length - 1;
var c = controlLines.length - 1;
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;
}
for (; s >= 1 && c >= 0; s--, c--) {
// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if (sampleLines[s] !== controlLines[c]) {
// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if (s !== 1 || c !== 1) {
do {
s--;
c--; // We may still have similar intermediate frames from the construct call.
// The next one that isn't the same should be our match though.
if (c < 0 || sampleLines[s] !== controlLines[c]) {
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var _frame =
"\n" + sampleLines[s].replace(" at new ", " at ");
{
if (typeof fn === "function") {
componentFrameCache.set(fn, _frame);
}
} // Return the line we found.
return _frame;
}
} while (s >= 1 && c >= 0);
}
break;
}
}
}
} finally {
reentry = false;
{
ReactCurrentDispatcher$1.current = previousDispatcher;
reenableLogs();
}
Error.prepareStackTrace = previousPrepareStackTrace;
} // Fallback to just using the name if we couldn't make it throw.
var name = fn ? fn.displayName || fn.name : "";
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
{
if (typeof fn === "function") {
componentFrameCache.set(fn, syntheticFrame);
}
}
return syntheticFrame;
}
function describeFunctionComponentFrame(fn, source, ownerFn) {
{
return describeNativeComponentFrame(fn, false);
}
}
function shouldConstruct(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (type == null) {
return "";
}
if (typeof type === "function") {
{
return describeNativeComponentFrame(type, shouldConstruct(type));
}
}
if (typeof type === "string") {
return describeBuiltInComponentFrame(type);
}
switch (type) {
case exports.Suspense:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_FORWARD_REF_TYPE:
return describeFunctionComponentFrame(type.render);
case REACT_MEMO_TYPE:
// Memo may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(
type.type,
source,
ownerFn,
);
case REACT_BLOCK_TYPE:
return describeFunctionComponentFrame(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
// Lazy may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(
init(payload),
source,
ownerFn,
);
} catch (x) {}
}
}
}
return "";
}
var loggedTypeFailures = {};
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(
element.type,
element._source,
owner ? owner.type : null,
);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
}
}
function checkPropTypes(
typeSpecs,
values,
location,
componentName,
element,
) {
{
// $FlowFixMe This is okay but Flow doesn't know it.
var has = Function.call.bind(Object.prototype.hasOwnProperty);
for (var typeSpecName in typeSpecs) {
if (has(typeSpecs, typeSpecName)) {
var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if (typeof typeSpecs[typeSpecName] !== "function") {
var err = Error(
(componentName || "React class") +
": " +
location +
" type `" +
typeSpecName +
"` is invalid; " +
"it must be a function, usually from the `prop-types` package, but received `" +
typeof typeSpecs[typeSpecName] +
"`." +
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.",
);
err.name = "Invariant Violation";
throw err;
}
error$1 = typeSpecs[typeSpecName](
values,
typeSpecName,
componentName,
location,
null,
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED",
);
} catch (ex) {
error$1 = ex;
}
if (error$1 && !(error$1 instanceof Error)) {
setCurrentlyValidatingElement(element);
error(
"%s: type specification of %s" +
" `%s` is invalid; the type checker " +
"function must return `null` or an `Error` but returned a %s. " +
"You may have forgotten to pass an argument to the type checker " +
"creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
"shape all require an argument).",
componentName || "React class",
location,
typeSpecName,
typeof error$1,
);
setCurrentlyValidatingElement(null);
}
if (
error$1 instanceof Error &&
!(error$1.message in loggedTypeFailures)
) {
// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message] = true;
setCurrentlyValidatingElement(element);
error("Failed %s type: %s", location, error$1.message);
setCurrentlyValidatingElement(null);
}
}
}
}
}
function setCurrentlyValidatingElement$1(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(
element.type,
element._source,
owner ? owner.type : null,
);
setExtraStackFrame(stack);
} else {
setExtraStackFrame(null);
}
}
}
var propTypesMisspellWarningShown;
{
propTypesMisspellWarningShown = false;
}
function getDeclarationErrorAddendum() {
if (ReactCurrentOwner.current) {
var name = getComponentName(ReactCurrentOwner.current.type);
if (name) {
return "\n\nCheck the render method of `" + name + "`.";
}
}
return "";
}
function getSourceInfoErrorAddendum(source) {
if (source !== undefined) {
var fileName = source.fileName.replace(/^.*[\\\/]/, "");
var lineNumber = source.lineNumber;
return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
}
return "";
}
function getSourceInfoErrorAddendumForProps(elementProps) {
if (elementProps !== null && elementProps !== undefined) {
return getSourceInfoErrorAddendum(elementProps.__source);
}
return "";
}
/**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/
var ownerHasKeyUseWarning = {};
function getCurrentComponentErrorInfo(parentType) {
var info = getDeclarationErrorAddendum();
if (!info) {
var parentName =
typeof parentType === "string"
? parentType
: parentType.displayName || parentType.name;
if (parentName) {
info =
"\n\nCheck the top-level render call using <" + parentName + ">.";
}
}
return info;
}
/**
* Warn if the element doesn't have an explicit key assigned to it.
* This element is in an array. The array could grow and shrink or be
* reordered. All children that haven't already been validated are required to
* have a "key" property assigned to it. Error statuses are cached so a warning
* will only be shown once.
*
* @internal
* @param {ReactElement} element Element that requires a key.
* @param {*} parentType element's parent's type.
*/
function validateExplicitKey(element, parentType) {
if (!element._store || element._store.validated || element.key != null) {
return;
}
element._store.validated = true;
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
return;
}
ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
// property, it may be the creator of the child that's responsible for
// assigning it a key.
var childOwner = "";
if (
element &&
element._owner &&
element._owner !== ReactCurrentOwner.current
) {
// Give the component that originally created this child.
childOwner =
" It was passed a child from " +
getComponentName(element._owner.type) +
".";
}
{
setCurrentlyValidatingElement$1(element);
error(
'Each child in a list should have a unique "key" prop.' +
"%s%s See https://reactjs.org/link/warning-keys for more information.",
currentComponentErrorInfo,
childOwner,
);
setCurrentlyValidatingElement$1(null);
}
}
/**
* Ensure that every element either is passed in a static location, in an
* array with an explicit keys property defined, or in an object literal
* with valid key property.
*
* @internal
* @param {ReactNode} node Statically passed child of any type.
* @param {*} parentType node's parent's type.
*/
function validateChildKeys(node, parentType) {
if (typeof node !== "object") {
return;
}
if (Array.isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i];
if (isValidElement(child)) {
validateExplicitKey(child, parentType);
}
}
} else if (isValidElement(node)) {
// This element was passed in a valid location.
if (node._store) {
node._store.validated = true;
}
} else if (node) {
var iteratorFn = getIteratorFn(node);
if (typeof iteratorFn === "function") {
// Entry iterators used to provide implicit keys,
// but now we print a separate warning for them later.
if (iteratorFn !== node.entries) {
var iterator = iteratorFn.call(node);
var step;
while (!(step = iterator.next()).done) {
if (isValidElement(step.value)) {
validateExplicitKey(step.value, parentType);
}
}
}
}
}
}
/**
* Given an element, validate that its props follow the propTypes definition,
* provided by the type.
*
* @param {ReactElement} element
*/
function validatePropTypes(element) {
{
var type = element.type;
if (type === null || type === undefined || typeof type === "string") {
return;
}
var propTypes;
if (typeof type === "function") {
propTypes = type.propTypes;
} else if (
typeof type === "object" &&
(type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
type.$$typeof === REACT_MEMO_TYPE)
) {
propTypes = type.propTypes;
} else {
return;
}
if (propTypes) {
// Intentionally inside to avoid triggering lazy initializers:
var name = getComponentName(type);
checkPropTypes(propTypes, element.props, "prop", name, element);
} else if (
type.PropTypes !== undefined &&
!propTypesMisspellWarningShown
) {
propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
var _name = getComponentName(type);
error(
"Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?",
_name || "Unknown",
);
}
if (
typeof type.getDefaultProps === "function" &&
!type.getDefaultProps.isReactClassApproved
) {
error(
"getDefaultProps is only used on classic React.createClass " +
"definitions. Use a static property named `defaultProps` instead.",
);
}
}
}
/**
* Given a fragment, validate that it can only be provided with fragment props
* @param {ReactElement} fragment
*/
function validateFragmentProps(fragment) {
{
var keys = Object.keys(fragment.props);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (key !== "children" && key !== "key") {
setCurrentlyValidatingElement$1(fragment);
error(
"Invalid prop `%s` supplied to `React.Fragment`. " +
"React.Fragment can only have `key` and `children` props.",
key,
);
setCurrentlyValidatingElement$1(null);
break;
}
}
if (fragment.ref !== null) {
setCurrentlyValidatingElement$1(fragment);
error("Invalid attribute `ref` supplied to `React.Fragment`.");
setCurrentlyValidatingElement$1(null);
}
}
}
function createElementWithValidation(type, props, children) {
var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
// succeed and there will likely be errors in render.
if (!validType) {
var info = "";
if (
type === undefined ||
(typeof type === "object" &&
type !== null &&
Object.keys(type).length === 0)
) {
info +=
" You likely forgot to export your component from the file " +
"it's defined in, or you might have mixed up default and named imports.";
}
var sourceInfo = getSourceInfoErrorAddendumForProps(props);
if (sourceInfo) {
info += sourceInfo;
} else {
info += getDeclarationErrorAddendum();
}
var typeString;
if (type === null) {
typeString = "null";
} else if (Array.isArray(type)) {
typeString = "array";
} else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
info =
" Did you accidentally export a JSX literal instead of a component?";
} else {
typeString = typeof type;
}
{
error(
"React.createElement: type is invalid -- expected a string (for " +
"built-in components) or a class/function (for composite " +
"components) but got: %s.%s",
typeString,
info,
);
}
}
var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
// TODO: Drop this when these are no longer allowed as the type argument.
if (element == null) {
return element;
} // Skip key warning if the type isn't valid since our key validation logic
// doesn't expect a non-string/function type and can throw confusing errors.
// We don't want exception behavior to differ between dev and prod.
// (Rendering will throw with a helpful message and as soon as the type is
// fixed, the key warnings will appear.)
if (validType) {
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], type);
}
}
if (type === exports.Fragment) {
validateFragmentProps(element);
} else {
validatePropTypes(element);
}
return element;
}
var didWarnAboutDeprecatedCreateFactory = false;
function createFactoryWithValidation(type) {
var validatedFactory = createElementWithValidation.bind(null, type);
validatedFactory.type = type;
{
if (!didWarnAboutDeprecatedCreateFactory) {
didWarnAboutDeprecatedCreateFactory = true;
warn(
"React.createFactory() is deprecated and will be removed in " +
"a future major release. Consider using JSX " +
"or use React.createElement() directly instead.",
);
} // Legacy hook: remove it
Object.defineProperty(validatedFactory, "type", {
enumerable: false,
get: function () {
warn(
"Factory.type is deprecated. Access the class directly " +
"before passing it to createFactory.",
);
Object.defineProperty(this, "type", {
value: type,
});
return type;
},
});
}
return validatedFactory;
}
function cloneElementWithValidation(element, props, children) {
var newElement = cloneElement.apply(this, arguments);
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], newElement.type);
}
validatePropTypes(newElement);
return newElement;
}
{
try {
var frozenObject = Object.freeze({});
/* eslint-disable no-new */
new Map([[frozenObject, null]]);
new Set([frozenObject]);
/* eslint-enable no-new */
} catch (e) {}
}
var createElement$1 = createElementWithValidation;
var cloneElement$1 = cloneElementWithValidation;
var createFactory = createFactoryWithValidation;
var Children = {
map: mapChildren,
forEach: forEachChildren,
count: countChildren,
toArray: toArray,
only: onlyChild,
};
exports.Children = Children;
exports.Component = Component;
exports.PureComponent = PureComponent;
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =
ReactSharedInternals;
exports.cloneElement = cloneElement$1;
exports.createContext = createContext;
exports.createElement = createElement$1;
exports.createFactory = createFactory;
exports.createRef = createRef;
exports.forwardRef = forwardRef;
exports.isValidElement = isValidElement;
exports.lazy = lazy;
exports.memo = memo;
exports.useCallback = useCallback;
exports.useContext = useContext;
exports.useDebugValue = useDebugValue;
exports.useEffect = useEffect;
exports.useImperativeHandle = useImperativeHandle;
exports.useLayoutEffect = useLayoutEffect;
exports.useMemo = useMemo;
exports.useReducer = useReducer;
exports.useRef = useRef;
exports.useState = useState;
exports.version = ReactVersion;
})();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/react-dom-17.0.2.js | JavaScript | /** @license React v17.0.2
* react-dom.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
(function (global, factory) {
typeof exports === "object" && typeof module !== "undefined"
? factory(exports, require("react"))
: typeof define === "function" && define.amd
? define(["exports", "react"], factory)
: ((global = global || self),
factory((global.ReactDOM = {}), global.React));
})(this, function (exports, React) {
"use strict";
var ReactSharedInternals =
React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
function warn(format) {
{
for (
var _len = arguments.length,
args = new Array(_len > 1 ? _len - 1 : 0),
_key = 1;
_key < _len;
_key++
) {
args[_key - 1] = arguments[_key];
}
printWarning("warn", format, args);
}
}
function error(format) {
{
for (
var _len2 = arguments.length,
args = new Array(_len2 > 1 ? _len2 - 1 : 0),
_key2 = 1;
_key2 < _len2;
_key2++
) {
args[_key2 - 1] = arguments[_key2];
}
printWarning("error", format, args);
}
}
function printWarning(level, format, args) {
// When changing this logic, you might want to also
// update consoleWithStackDev.www.js as well.
{
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame.getStackAddendum();
if (stack !== "") {
format += "%s";
args = args.concat([stack]);
}
var argsWithFormat = args.map(function (item) {
return "" + item;
}); // Careful: RN currently depends on this prefix
argsWithFormat.unshift("Warning: " + format); // We intentionally don't use spread (or .apply) directly because it
// breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
}
if (!React) {
{
throw Error(
"ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.",
);
}
}
var FunctionComponent = 0;
var ClassComponent = 1;
var IndeterminateComponent = 2; // Before we know whether it is function or class
var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
var HostPortal = 4; // A subtree. Could be an entry point to a different renderer.
var HostComponent = 5;
var HostText = 6;
var Fragment = 7;
var Mode = 8;
var ContextConsumer = 9;
var ContextProvider = 10;
var ForwardRef = 11;
var Profiler = 12;
var SuspenseComponent = 13;
var MemoComponent = 14;
var SimpleMemoComponent = 15;
var LazyComponent = 16;
var IncompleteClassComponent = 17;
var DehydratedFragment = 18;
var SuspenseListComponent = 19;
var FundamentalComponent = 20;
var ScopeComponent = 21;
var Block = 22;
var OffscreenComponent = 23;
var LegacyHiddenComponent = 24;
// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
var enableProfilerTimer = true; // Record durations for commit and passive effects phases.
var enableFundamentalAPI = false; // Experimental Scope support.
var enableNewReconciler = false; // Errors that are thrown while unmounting (or after in the case of passive effects)
var warnAboutStringRefs = false;
var allNativeEvents = new Set();
/**
* Mapping from registration name to event name
*/
var registrationNameDependencies = {};
/**
* Mapping from lowercase registration names to the properly cased version,
* used to warn in the case of missing event handlers. Available
* only in true.
* @type {Object}
*/
var possibleRegistrationNames = {}; // Trust the developer to only use possibleRegistrationNames in true
function registerTwoPhaseEvent(registrationName, dependencies) {
registerDirectEvent(registrationName, dependencies);
registerDirectEvent(registrationName + "Capture", dependencies);
}
function registerDirectEvent(registrationName, dependencies) {
{
if (registrationNameDependencies[registrationName]) {
error(
"EventRegistry: More than one plugin attempted to publish the same " +
"registration name, `%s`.",
registrationName,
);
}
}
registrationNameDependencies[registrationName] = dependencies;
{
var lowerCasedName = registrationName.toLowerCase();
possibleRegistrationNames[lowerCasedName] = registrationName;
if (registrationName === "onDoubleClick") {
possibleRegistrationNames.ondblclick = registrationName;
}
}
for (var i = 0; i < dependencies.length; i++) {
allNativeEvents.add(dependencies[i]);
}
}
var canUseDOM = !!(
typeof window !== "undefined" &&
typeof window.document !== "undefined" &&
typeof window.document.createElement !== "undefined"
);
// A reserved attribute.
// It is handled by React separately and shouldn't be written to the DOM.
var RESERVED = 0; // A simple string attribute.
// Attributes that aren't in the filter are presumed to have this type.
var STRING = 1; // A string attribute that accepts booleans in React. In HTML, these are called
// "enumerated" attributes with "true" and "false" as possible values.
// When true, it should be set to a "true" string.
// When false, it should be set to a "false" string.
var BOOLEANISH_STRING = 2; // A real boolean attribute.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
var BOOLEAN = 3; // An attribute that can be used as a flag as well as with a value.
// When true, it should be present (set either to an empty string or its name).
// When false, it should be omitted.
// For any other value, should be present with that value.
var OVERLOADED_BOOLEAN = 4; // An attribute that must be numeric or parse as a numeric.
// When falsy, it should be removed.
var NUMERIC = 5; // An attribute that must be positive numeric or parse as a positive numeric.
// When falsy, it should be removed.
var POSITIVE_NUMERIC = 6;
/* eslint-disable max-len */
var ATTRIBUTE_NAME_START_CHAR =
":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
/* eslint-enable max-len */
var ATTRIBUTE_NAME_CHAR =
ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
var ROOT_ATTRIBUTE_NAME = "data-reactroot";
var VALID_ATTRIBUTE_NAME_REGEX = new RegExp(
"^[" + ATTRIBUTE_NAME_START_CHAR + "][" + ATTRIBUTE_NAME_CHAR + "]*$",
);
var hasOwnProperty = Object.prototype.hasOwnProperty;
var illegalAttributeNameCache = {};
var validatedAttributeNameCache = {};
function isAttributeNameSafe(attributeName) {
if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
return true;
}
if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
return false;
}
if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
validatedAttributeNameCache[attributeName] = true;
return true;
}
illegalAttributeNameCache[attributeName] = true;
{
error("Invalid attribute name: `%s`", attributeName);
}
return false;
}
function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) {
if (propertyInfo !== null) {
return propertyInfo.type === RESERVED;
}
if (isCustomComponentTag) {
return false;
}
if (
name.length > 2 &&
(name[0] === "o" || name[0] === "O") &&
(name[1] === "n" || name[1] === "N")
) {
return true;
}
return false;
}
function shouldRemoveAttributeWithWarning(
name,
value,
propertyInfo,
isCustomComponentTag,
) {
if (propertyInfo !== null && propertyInfo.type === RESERVED) {
return false;
}
switch (typeof value) {
case "function": // $FlowIssue symbol is perfectly valid here
case "symbol":
// eslint-disable-line
return true;
case "boolean": {
if (isCustomComponentTag) {
return false;
}
if (propertyInfo !== null) {
return !propertyInfo.acceptsBooleans;
} else {
var prefix = name.toLowerCase().slice(0, 5);
return prefix !== "data-" && prefix !== "aria-";
}
}
default:
return false;
}
}
function shouldRemoveAttribute(
name,
value,
propertyInfo,
isCustomComponentTag,
) {
if (value === null || typeof value === "undefined") {
return true;
}
if (
shouldRemoveAttributeWithWarning(
name,
value,
propertyInfo,
isCustomComponentTag,
)
) {
return true;
}
if (isCustomComponentTag) {
return false;
}
if (propertyInfo !== null) {
switch (propertyInfo.type) {
case BOOLEAN:
return !value;
case OVERLOADED_BOOLEAN:
return value === false;
case NUMERIC:
return isNaN(value);
case POSITIVE_NUMERIC:
return isNaN(value) || value < 1;
}
}
return false;
}
function getPropertyInfo(name) {
return properties.hasOwnProperty(name) ? properties[name] : null;
}
function PropertyInfoRecord(
name,
type,
mustUseProperty,
attributeName,
attributeNamespace,
sanitizeURL,
removeEmptyString,
) {
this.acceptsBooleans =
type === BOOLEANISH_STRING ||
type === BOOLEAN ||
type === OVERLOADED_BOOLEAN;
this.attributeName = attributeName;
this.attributeNamespace = attributeNamespace;
this.mustUseProperty = mustUseProperty;
this.propertyName = name;
this.type = type;
this.sanitizeURL = sanitizeURL;
this.removeEmptyString = removeEmptyString;
} // When adding attributes to this list, be sure to also add them to
// the `possibleStandardNames` module to ensure casing and incorrect
// name warnings.
var properties = {}; // These props are reserved by React. They shouldn't be written to the DOM.
var reservedProps = [
"children",
"dangerouslySetInnerHTML", // TODO: This prevents the assignment of defaultValue to regular
// elements (not just inputs). Now that ReactDOMInput assigns to the
// defaultValue property -- do we need this?
"defaultValue",
"defaultChecked",
"innerHTML",
"suppressContentEditableWarning",
"suppressHydrationWarning",
"style",
];
reservedProps.forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
RESERVED,
false, // mustUseProperty
name, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // A few React string attributes have a different name.
// This is a mapping from React prop names to the attribute names.
[
["acceptCharset", "accept-charset"],
["className", "class"],
["htmlFor", "for"],
["httpEquiv", "http-equiv"],
].forEach(function (_ref) {
var name = _ref[0],
attributeName = _ref[1];
properties[name] = new PropertyInfoRecord(
name,
STRING,
false, // mustUseProperty
attributeName, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are "enumerated" HTML attributes that accept "true" and "false".
// In React, we let users pass `true` and `false` even though technically
// these aren't boolean attributes (they are coerced to strings).
["contentEditable", "draggable", "spellCheck", "value"].forEach(function (
name,
) {
properties[name] = new PropertyInfoRecord(
name,
BOOLEANISH_STRING,
false, // mustUseProperty
name.toLowerCase(), // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are "enumerated" SVG attributes that accept "true" and "false".
// In React, we let users pass `true` and `false` even though technically
// these aren't boolean attributes (they are coerced to strings).
// Since these are SVG attributes, their attribute names are case-sensitive.
[
"autoReverse",
"externalResourcesRequired",
"focusable",
"preserveAlpha",
].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
BOOLEANISH_STRING,
false, // mustUseProperty
name, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are HTML boolean attributes.
[
"allowFullScreen",
"async", // Note: there is a special case that prevents it from being written to the DOM
// on the client side because the browsers are inconsistent. Instead we call focus().
"autoFocus",
"autoPlay",
"controls",
"default",
"defer",
"disabled",
"disablePictureInPicture",
"disableRemotePlayback",
"formNoValidate",
"hidden",
"loop",
"noModule",
"noValidate",
"open",
"playsInline",
"readOnly",
"required",
"reversed",
"scoped",
"seamless", // Microdata
"itemScope",
].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
BOOLEAN,
false, // mustUseProperty
name.toLowerCase(), // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are the few React props that we set as DOM properties
// rather than attributes. These are all booleans.
[
"checked", // Note: `option.selected` is not updated if `select.multiple` is
// disabled with `removeAttribute`. We have special logic for handling this.
"multiple",
"muted",
"selected", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
BOOLEAN,
true, // mustUseProperty
name, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are HTML attributes that are "overloaded booleans": they behave like
// booleans, but can also accept a string value.
[
"capture",
"download", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
OVERLOADED_BOOLEAN,
false, // mustUseProperty
name, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are HTML attributes that must be positive numbers.
[
"cols",
"rows",
"size",
"span", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
POSITIVE_NUMERIC,
false, // mustUseProperty
name, // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These are HTML attributes that must be numbers.
["rowSpan", "start"].forEach(function (name) {
properties[name] = new PropertyInfoRecord(
name,
NUMERIC,
false, // mustUseProperty
name.toLowerCase(), // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
});
var CAMELIZE = /[\-\:]([a-z])/g;
var capitalize = function (token) {
return token[1].toUpperCase();
}; // This is a list of all SVG attributes that need special casing, namespacing,
// or boolean value assignment. Regular attributes that just accept strings
// and have the same names are omitted, just like in the HTML attribute filter.
// Some of these attributes can be hard to find. This list was created by
// scraping the MDN documentation.
[
"accent-height",
"alignment-baseline",
"arabic-form",
"baseline-shift",
"cap-height",
"clip-path",
"clip-rule",
"color-interpolation",
"color-interpolation-filters",
"color-profile",
"color-rendering",
"dominant-baseline",
"enable-background",
"fill-opacity",
"fill-rule",
"flood-color",
"flood-opacity",
"font-family",
"font-size",
"font-size-adjust",
"font-stretch",
"font-style",
"font-variant",
"font-weight",
"glyph-name",
"glyph-orientation-horizontal",
"glyph-orientation-vertical",
"horiz-adv-x",
"horiz-origin-x",
"image-rendering",
"letter-spacing",
"lighting-color",
"marker-end",
"marker-mid",
"marker-start",
"overline-position",
"overline-thickness",
"paint-order",
"panose-1",
"pointer-events",
"rendering-intent",
"shape-rendering",
"stop-color",
"stop-opacity",
"strikethrough-position",
"strikethrough-thickness",
"stroke-dasharray",
"stroke-dashoffset",
"stroke-linecap",
"stroke-linejoin",
"stroke-miterlimit",
"stroke-opacity",
"stroke-width",
"text-anchor",
"text-decoration",
"text-rendering",
"underline-position",
"underline-thickness",
"unicode-bidi",
"unicode-range",
"units-per-em",
"v-alphabetic",
"v-hanging",
"v-ideographic",
"v-mathematical",
"vector-effect",
"vert-adv-y",
"vert-origin-x",
"vert-origin-y",
"word-spacing",
"writing-mode",
"xmlns:xlink",
"x-height", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(
name,
STRING,
false, // mustUseProperty
attributeName,
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // String SVG attributes with the xlink namespace.
[
"xlink:actuate",
"xlink:arcrole",
"xlink:role",
"xlink:show",
"xlink:title",
"xlink:type", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(
name,
STRING,
false, // mustUseProperty
attributeName,
"http://www.w3.org/1999/xlink",
false, // sanitizeURL
false,
);
}); // String SVG attributes with the xml namespace.
[
"xml:base",
"xml:lang",
"xml:space", // NOTE: if you add a camelCased prop to this list,
// you'll need to set attributeName to name.toLowerCase()
// instead in the assignment below.
].forEach(function (attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(
name,
STRING,
false, // mustUseProperty
attributeName,
"http://www.w3.org/XML/1998/namespace",
false, // sanitizeURL
false,
);
}); // These attribute exists both in HTML and SVG.
// The attribute name is case-sensitive in SVG so we can't just use
// the React name like we do for attributes that exist only in HTML.
["tabIndex", "crossOrigin"].forEach(function (attributeName) {
properties[attributeName] = new PropertyInfoRecord(
attributeName,
STRING,
false, // mustUseProperty
attributeName.toLowerCase(), // attributeName
null, // attributeNamespace
false, // sanitizeURL
false,
);
}); // These attributes accept URLs. These must not allow javascript: URLS.
// These will also need to accept Trusted Types object in the future.
var xlinkHref = "xlinkHref";
properties[xlinkHref] = new PropertyInfoRecord(
"xlinkHref",
STRING,
false, // mustUseProperty
"xlink:href",
"http://www.w3.org/1999/xlink",
true, // sanitizeURL
false,
);
["src", "href", "action", "formAction"].forEach(function (attributeName) {
properties[attributeName] = new PropertyInfoRecord(
attributeName,
STRING,
false, // mustUseProperty
attributeName.toLowerCase(), // attributeName
null, // attributeNamespace
true, // sanitizeURL
true,
);
});
// and any newline or tab are filtered out as if they're not part of the URL.
// https://url.spec.whatwg.org/#url-parsing
// Tab or newline are defined as \r\n\t:
// https://infra.spec.whatwg.org/#ascii-tab-or-newline
// A C0 control is a code point in the range \u0000 NULL to \u001F
// INFORMATION SEPARATOR ONE, inclusive:
// https://infra.spec.whatwg.org/#c0-control-or-space
/* eslint-disable max-len */
var isJavaScriptProtocol =
/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i;
var didWarn = false;
function sanitizeURL(url) {
{
if (!didWarn && isJavaScriptProtocol.test(url)) {
didWarn = true;
error(
"A future version of React will block javascript: URLs as a security precaution. " +
"Use event handlers instead if you can. If you need to generate unsafe HTML try " +
"using dangerouslySetInnerHTML instead. React was passed %s.",
JSON.stringify(url),
);
}
}
}
/**
* Get the value for a property on a node. Only used in DEV for SSR validation.
* The "expected" argument is used as a hint of what the expected value is.
* Some properties have multiple equivalent values.
*/
function getValueForProperty(node, name, expected, propertyInfo) {
{
if (propertyInfo.mustUseProperty) {
var propertyName = propertyInfo.propertyName;
return node[propertyName];
} else {
if (propertyInfo.sanitizeURL) {
// If we haven't fully disabled javascript: URLs, and if
// the hydration is successful of a javascript: URL, we
// still want to warn on the client.
sanitizeURL("" + expected);
}
var attributeName = propertyInfo.attributeName;
var stringValue = null;
if (propertyInfo.type === OVERLOADED_BOOLEAN) {
if (node.hasAttribute(attributeName)) {
var value = node.getAttribute(attributeName);
if (value === "") {
return true;
}
if (shouldRemoveAttribute(name, expected, propertyInfo, false)) {
return value;
}
if (value === "" + expected) {
return expected;
}
return value;
}
} else if (node.hasAttribute(attributeName)) {
if (shouldRemoveAttribute(name, expected, propertyInfo, false)) {
// We had an attribute but shouldn't have had one, so read it
// for the error message.
return node.getAttribute(attributeName);
}
if (propertyInfo.type === BOOLEAN) {
// If this was a boolean, it doesn't matter what the value is
// the fact that we have it is the same as the expected.
return expected;
} // Even if this property uses a namespace we use getAttribute
// because we assume its namespaced name is the same as our config.
// To use getAttributeNS we need the local name which we don't have
// in our config atm.
stringValue = node.getAttribute(attributeName);
}
if (shouldRemoveAttribute(name, expected, propertyInfo, false)) {
return stringValue === null ? expected : stringValue;
} else if (stringValue === "" + expected) {
return expected;
} else {
return stringValue;
}
}
}
}
/**
* Get the value for a attribute on a node. Only used in DEV for SSR validation.
* The third argument is used as a hint of what the expected value is. Some
* attributes have multiple equivalent values.
*/
function getValueForAttribute(node, name, expected) {
{
if (!isAttributeNameSafe(name)) {
return;
} // If the object is an opaque reference ID, it's expected that
// the next prop is different than the server value, so just return
// expected
if (isOpaqueHydratingObject(expected)) {
return expected;
}
if (!node.hasAttribute(name)) {
return expected === undefined ? undefined : null;
}
var value = node.getAttribute(name);
if (value === "" + expected) {
return expected;
}
return value;
}
}
/**
* Sets the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
* @param {*} value
*/
function setValueForProperty(node, name, value, isCustomComponentTag) {
var propertyInfo = getPropertyInfo(name);
if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) {
return;
}
if (
shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)
) {
value = null;
} // If the prop isn't in the special list, treat it as a simple attribute.
if (isCustomComponentTag || propertyInfo === null) {
if (isAttributeNameSafe(name)) {
var _attributeName = name;
if (value === null) {
node.removeAttribute(_attributeName);
} else {
node.setAttribute(_attributeName, "" + value);
}
}
return;
}
var mustUseProperty = propertyInfo.mustUseProperty;
if (mustUseProperty) {
var propertyName = propertyInfo.propertyName;
if (value === null) {
var type = propertyInfo.type;
node[propertyName] = type === BOOLEAN ? false : "";
} else {
// Contrary to `setAttribute`, object properties are properly
// `toString`ed by IE8/9.
node[propertyName] = value;
}
return;
} // The rest are treated as attributes with special cases.
var attributeName = propertyInfo.attributeName,
attributeNamespace = propertyInfo.attributeNamespace;
if (value === null) {
node.removeAttribute(attributeName);
} else {
var _type = propertyInfo.type;
var attributeValue;
if (
_type === BOOLEAN ||
(_type === OVERLOADED_BOOLEAN && value === true)
) {
// If attribute type is boolean, we know for sure it won't be an execution sink
// and we won't require Trusted Type here.
attributeValue = "";
} else {
// `setAttribute` with objects becomes only `[object]` in IE8/9,
// ('' + value) makes it output the correct toString()-value.
{
attributeValue = "" + value;
}
if (propertyInfo.sanitizeURL) {
sanitizeURL(attributeValue.toString());
}
}
if (attributeNamespace) {
node.setAttributeNS(attributeNamespace, attributeName, attributeValue);
} else {
node.setAttribute(attributeName, attributeValue);
}
}
}
var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
var _assign = ReactInternals.assign;
// ATTENTION
// When adding new symbols to this file,
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var REACT_ELEMENT_TYPE = 0xeac7;
var REACT_PORTAL_TYPE = 0xeaca;
var REACT_FRAGMENT_TYPE = 0xeacb;
var REACT_STRICT_MODE_TYPE = 0xeacc;
var REACT_PROFILER_TYPE = 0xead2;
var REACT_PROVIDER_TYPE = 0xeacd;
var REACT_CONTEXT_TYPE = 0xeace;
var REACT_FORWARD_REF_TYPE = 0xead0;
var REACT_SUSPENSE_TYPE = 0xead1;
var REACT_SUSPENSE_LIST_TYPE = 0xead8;
var REACT_MEMO_TYPE = 0xead3;
var REACT_LAZY_TYPE = 0xead4;
var REACT_BLOCK_TYPE = 0xead9;
var REACT_SERVER_BLOCK_TYPE = 0xeada;
var REACT_FUNDAMENTAL_TYPE = 0xead5;
var REACT_SCOPE_TYPE = 0xead7;
var REACT_OPAQUE_ID_TYPE = 0xeae0;
var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
var REACT_OFFSCREEN_TYPE = 0xeae2;
var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
if (typeof Symbol === "function" && Symbol.for) {
var symbolFor = Symbol.for;
REACT_ELEMENT_TYPE = symbolFor("react.element");
REACT_PORTAL_TYPE = symbolFor("react.portal");
REACT_FRAGMENT_TYPE = symbolFor("react.fragment");
REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
REACT_PROFILER_TYPE = symbolFor("react.profiler");
REACT_PROVIDER_TYPE = symbolFor("react.provider");
REACT_CONTEXT_TYPE = symbolFor("react.context");
REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
REACT_MEMO_TYPE = symbolFor("react.memo");
REACT_LAZY_TYPE = symbolFor("react.lazy");
REACT_BLOCK_TYPE = symbolFor("react.block");
REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
REACT_SCOPE_TYPE = symbolFor("react.scope");
REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
}
var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = "@@iterator";
function getIteratorFn(maybeIterable) {
if (maybeIterable === null || typeof maybeIterable !== "object") {
return null;
}
var maybeIterator =
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
maybeIterable[FAUX_ITERATOR_SYMBOL];
if (typeof maybeIterator === "function") {
return maybeIterator;
}
return null;
}
// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
// We could also eagerly patch the method.
var disabledDepth = 0;
var prevLog;
var prevInfo;
var prevWarn;
var prevError;
var prevGroup;
var prevGroupCollapsed;
var prevGroupEnd;
function disabledLog() {}
disabledLog.__reactDisabledLog = true;
function disableLogs() {
{
if (disabledDepth === 0) {
/* eslint-disable react-internal/no-production-logging */
prevLog = console.log;
prevInfo = console.info;
prevWarn = console.warn;
prevError = console.error;
prevGroup = console.group;
prevGroupCollapsed = console.groupCollapsed;
prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
var props = {
configurable: true,
enumerable: true,
value: disabledLog,
writable: true,
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props,
});
/* eslint-enable react-internal/no-production-logging */
}
disabledDepth++;
}
}
function reenableLogs() {
{
disabledDepth--;
if (disabledDepth === 0) {
/* eslint-disable react-internal/no-production-logging */
var props = {
configurable: true,
enumerable: true,
writable: true,
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
log: _assign({}, props, {
value: prevLog,
}),
info: _assign({}, props, {
value: prevInfo,
}),
warn: _assign({}, props, {
value: prevWarn,
}),
error: _assign({}, props, {
value: prevError,
}),
group: _assign({}, props, {
value: prevGroup,
}),
groupCollapsed: _assign({}, props, {
value: prevGroupCollapsed,
}),
groupEnd: _assign({}, props, {
value: prevGroupEnd,
}),
});
/* eslint-enable react-internal/no-production-logging */
}
if (disabledDepth < 0) {
error(
"disabledDepth fell below zero. " +
"This is a bug in React. Please file an issue.",
);
}
}
}
var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
var prefix;
function describeBuiltInComponentFrame(name, source, ownerFn) {
{
if (prefix === undefined) {
// Extract the VM specific prefix used by each line.
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = (match && match[1]) || "";
}
} // We use the prefix to ensure our stacks line up with native stack frames.
return "\n" + prefix + name;
}
}
var reentry = false;
var componentFrameCache;
{
var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
componentFrameCache = new PossiblyWeakMap();
}
function describeNativeComponentFrame(fn, construct) {
// If something asked for a stack inside a fake render, it should get ignored.
if (!fn || reentry) {
return "";
}
{
var frame = componentFrameCache.get(fn);
if (frame !== undefined) {
return frame;
}
}
var control;
reentry = true;
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
Error.prepareStackTrace = undefined;
var previousDispatcher;
{
previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
// for warnings.
ReactCurrentDispatcher.current = null;
disableLogs();
}
try {
// This should throw.
if (construct) {
// Something should be setting the props in the constructor.
var Fake = function () {
throw Error();
}; // $FlowFixMe
Object.defineProperty(Fake.prototype, "props", {
set: function () {
// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throw Error();
},
});
if (typeof Reflect === "object" && Reflect.construct) {
// We construct a different control for this case to include any extra
// frames added by the construct call.
try {
Reflect.construct(Fake, []);
} catch (x) {
control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x) {
control = x;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x) {
control = x;
}
fn();
}
} catch (sample) {
// This is inlined manually because closure doesn't do it for us.
if (sample && control && typeof sample.stack === "string") {
// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
var sampleLines = sample.stack.split("\n");
var controlLines = control.stack.split("\n");
var s = sampleLines.length - 1;
var c = controlLines.length - 1;
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;
}
for (; s >= 1 && c >= 0; s--, c--) {
// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if (sampleLines[s] !== controlLines[c]) {
// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if (s !== 1 || c !== 1) {
do {
s--;
c--; // We may still have similar intermediate frames from the construct call.
// The next one that isn't the same should be our match though.
if (c < 0 || sampleLines[s] !== controlLines[c]) {
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var _frame =
"\n" + sampleLines[s].replace(" at new ", " at ");
{
if (typeof fn === "function") {
componentFrameCache.set(fn, _frame);
}
} // Return the line we found.
return _frame;
}
} while (s >= 1 && c >= 0);
}
break;
}
}
}
} finally {
reentry = false;
{
ReactCurrentDispatcher.current = previousDispatcher;
reenableLogs();
}
Error.prepareStackTrace = previousPrepareStackTrace;
} // Fallback to just using the name if we couldn't make it throw.
var name = fn ? fn.displayName || fn.name : "";
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
{
if (typeof fn === "function") {
componentFrameCache.set(fn, syntheticFrame);
}
}
return syntheticFrame;
}
function describeClassComponentFrame(ctor, source, ownerFn) {
{
return describeNativeComponentFrame(ctor, true);
}
}
function describeFunctionComponentFrame(fn, source, ownerFn) {
{
return describeNativeComponentFrame(fn, false);
}
}
function shouldConstruct(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (type == null) {
return "";
}
if (typeof type === "function") {
{
return describeNativeComponentFrame(type, shouldConstruct(type));
}
}
if (typeof type === "string") {
return describeBuiltInComponentFrame(type);
}
switch (type) {
case REACT_SUSPENSE_TYPE:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_FORWARD_REF_TYPE:
return describeFunctionComponentFrame(type.render);
case REACT_MEMO_TYPE:
// Memo may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(
type.type,
source,
ownerFn,
);
case REACT_BLOCK_TYPE:
return describeFunctionComponentFrame(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
// Lazy may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(
init(payload),
source,
ownerFn,
);
} catch (x) {}
}
}
}
return "";
}
function describeFiber(fiber) {
var owner = fiber._debugOwner ? fiber._debugOwner.type : null;
var source = fiber._debugSource;
switch (fiber.tag) {
case HostComponent:
return describeBuiltInComponentFrame(fiber.type);
case LazyComponent:
return describeBuiltInComponentFrame("Lazy");
case SuspenseComponent:
return describeBuiltInComponentFrame("Suspense");
case SuspenseListComponent:
return describeBuiltInComponentFrame("SuspenseList");
case FunctionComponent:
case IndeterminateComponent:
case SimpleMemoComponent:
return describeFunctionComponentFrame(fiber.type);
case ForwardRef:
return describeFunctionComponentFrame(fiber.type.render);
case Block:
return describeFunctionComponentFrame(fiber.type._render);
case ClassComponent:
return describeClassComponentFrame(fiber.type);
default:
return "";
}
}
function getStackByFiberInDevAndProd(workInProgress) {
try {
var info = "";
var node = workInProgress;
do {
info += describeFiber(node);
node = node.return;
} while (node);
return info;
} catch (x) {
return "\nError generating stack: " + x.message + "\n" + x.stack;
}
}
function getWrappedName(outerType, innerType, wrapperName) {
var functionName = innerType.displayName || innerType.name || "";
return (
outerType.displayName ||
(functionName !== ""
? wrapperName + "(" + functionName + ")"
: wrapperName)
);
}
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentName(type) {
if (type == null) {
// Host root, text node or just invalid type.
return null;
}
{
if (typeof type.tag === "number") {
error(
"Received an unexpected object in getComponentName(). " +
"This is likely a bug in React. Please file an issue.",
);
}
}
if (typeof type === "function") {
return type.displayName || type.name || null;
}
if (typeof type === "string") {
return type;
}
switch (type) {
case REACT_FRAGMENT_TYPE:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case REACT_PROFILER_TYPE:
return "Profiler";
case REACT_STRICT_MODE_TYPE:
return "StrictMode";
case REACT_SUSPENSE_TYPE:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_CONTEXT_TYPE:
var context = type;
return getContextName(context) + ".Consumer";
case REACT_PROVIDER_TYPE:
var provider = type;
return getContextName(provider._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
return getWrappedName(type, type.render, "ForwardRef");
case REACT_MEMO_TYPE:
return getComponentName(type.type);
case REACT_BLOCK_TYPE:
return getComponentName(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
return getComponentName(init(payload));
} catch (x) {
return null;
}
}
}
}
return null;
}
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
var current = null;
var isRendering = false;
function getCurrentFiberOwnerNameInDevOrNull() {
{
if (current === null) {
return null;
}
var owner = current._debugOwner;
if (owner !== null && typeof owner !== "undefined") {
return getComponentName(owner.type);
}
}
return null;
}
function getCurrentFiberStackInDev() {
{
if (current === null) {
return "";
} // Safe because if current fiber exists, we are reconciling,
// and it is guaranteed to be the work-in-progress version.
return getStackByFiberInDevAndProd(current);
}
}
function resetCurrentFiber() {
{
ReactDebugCurrentFrame.getCurrentStack = null;
current = null;
isRendering = false;
}
}
function setCurrentFiber(fiber) {
{
ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
current = fiber;
isRendering = false;
}
}
function setIsRendering(rendering) {
{
isRendering = rendering;
}
}
function getIsRendering() {
{
return isRendering;
}
}
// Flow does not allow string concatenation of most non-string types. To work
// around this limitation, we use an opaque type that can only be obtained by
// passing the value through getToStringValue first.
function toString(value) {
return "" + value;
}
function getToStringValue(value) {
switch (typeof value) {
case "boolean":
case "number":
case "object":
case "string":
case "undefined":
return value;
default:
// function, symbol are assigned as empty strings
return "";
}
}
var hasReadOnlyValue = {
button: true,
checkbox: true,
image: true,
hidden: true,
radio: true,
reset: true,
submit: true,
};
function checkControlledValueProps(tagName, props) {
{
if (
!(
hasReadOnlyValue[props.type] ||
props.onChange ||
props.onInput ||
props.readOnly ||
props.disabled ||
props.value == null
)
) {
error(
"You provided a `value` prop to a form field without an " +
"`onChange` handler. This will render a read-only field. If " +
"the field should be mutable use `defaultValue`. Otherwise, " +
"set either `onChange` or `readOnly`.",
);
}
if (
!(
props.onChange ||
props.readOnly ||
props.disabled ||
props.checked == null
)
) {
error(
"You provided a `checked` prop to a form field without an " +
"`onChange` handler. This will render a read-only field. If " +
"the field should be mutable use `defaultChecked`. Otherwise, " +
"set either `onChange` or `readOnly`.",
);
}
}
}
function isCheckable(elem) {
var type = elem.type;
var nodeName = elem.nodeName;
return (
nodeName &&
nodeName.toLowerCase() === "input" &&
(type === "checkbox" || type === "radio")
);
}
function getTracker(node) {
return node._valueTracker;
}
function detachTracker(node) {
node._valueTracker = null;
}
function getValueFromNode(node) {
var value = "";
if (!node) {
return value;
}
if (isCheckable(node)) {
value = node.checked ? "true" : "false";
} else {
value = node.value;
}
return value;
}
function trackValueOnNode(node) {
var valueField = isCheckable(node) ? "checked" : "value";
var descriptor = Object.getOwnPropertyDescriptor(
node.constructor.prototype,
valueField,
);
var currentValue = "" + node[valueField]; // if someone has already defined a value or Safari, then bail
// and don't track value will cause over reporting of changes,
// but it's better then a hard failure
// (needed for certain tests that spyOn input values and Safari)
if (
node.hasOwnProperty(valueField) ||
typeof descriptor === "undefined" ||
typeof descriptor.get !== "function" ||
typeof descriptor.set !== "function"
) {
return;
}
var get = descriptor.get,
set = descriptor.set;
Object.defineProperty(node, valueField, {
configurable: true,
get: function () {
return get.call(this);
},
set: function (value) {
currentValue = "" + value;
set.call(this, value);
},
}); // We could've passed this the first time
// but it triggers a bug in IE11 and Edge 14/15.
// Calling defineProperty() again should be equivalent.
// https://github.com/facebook/react/issues/11768
Object.defineProperty(node, valueField, {
enumerable: descriptor.enumerable,
});
var tracker = {
getValue: function () {
return currentValue;
},
setValue: function (value) {
currentValue = "" + value;
},
stopTracking: function () {
detachTracker(node);
delete node[valueField];
},
};
return tracker;
}
function track(node) {
if (getTracker(node)) {
return;
} // TODO: Once it's just Fiber we can move this to node._wrapperState
node._valueTracker = trackValueOnNode(node);
}
function updateValueIfChanged(node) {
if (!node) {
return false;
}
var tracker = getTracker(node); // if there is no tracker at this point it's unlikely
// that trying again will succeed
if (!tracker) {
return true;
}
var lastValue = tracker.getValue();
var nextValue = getValueFromNode(node);
if (nextValue !== lastValue) {
tracker.setValue(nextValue);
return true;
}
return false;
}
function getActiveElement(doc) {
doc = doc || (typeof document !== "undefined" ? document : undefined);
if (typeof doc === "undefined") {
return null;
}
try {
return doc.activeElement || doc.body;
} catch (e) {
return doc.body;
}
}
var didWarnValueDefaultValue = false;
var didWarnCheckedDefaultChecked = false;
var didWarnControlledToUncontrolled = false;
var didWarnUncontrolledToControlled = false;
function isControlled(props) {
var usesChecked = props.type === "checkbox" || props.type === "radio";
return usesChecked ? props.checked != null : props.value != null;
}
/**
* Implements an <input> host component that allows setting these optional
* props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
*
* If `checked` or `value` are not supplied (or null/undefined), user actions
* that affect the checked state or value will trigger updates to the element.
*
* If they are supplied (and not null/undefined), the rendered element will not
* trigger updates to the element. Instead, the props must change in order for
* the rendered element to be updated.
*
* The rendered element will be initialized as unchecked (or `defaultChecked`)
* with an empty value (or `defaultValue`).
*
* See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
*/
function getHostProps(element, props) {
var node = element;
var checked = props.checked;
var hostProps = _assign({}, props, {
defaultChecked: undefined,
defaultValue: undefined,
value: undefined,
checked: checked != null ? checked : node._wrapperState.initialChecked,
});
return hostProps;
}
function initWrapperState(element, props) {
{
checkControlledValueProps("input", props);
if (
props.checked !== undefined &&
props.defaultChecked !== undefined &&
!didWarnCheckedDefaultChecked
) {
error(
"%s contains an input of type %s with both checked and defaultChecked props. " +
"Input elements must be either controlled or uncontrolled " +
"(specify either the checked prop, or the defaultChecked prop, but not " +
"both). Decide between using a controlled or uncontrolled input " +
"element and remove one of these props. More info: " +
"https://reactjs.org/link/controlled-components",
getCurrentFiberOwnerNameInDevOrNull() || "A component",
props.type,
);
didWarnCheckedDefaultChecked = true;
}
if (
props.value !== undefined &&
props.defaultValue !== undefined &&
!didWarnValueDefaultValue
) {
error(
"%s contains an input of type %s with both value and defaultValue props. " +
"Input elements must be either controlled or uncontrolled " +
"(specify either the value prop, or the defaultValue prop, but not " +
"both). Decide between using a controlled or uncontrolled input " +
"element and remove one of these props. More info: " +
"https://reactjs.org/link/controlled-components",
getCurrentFiberOwnerNameInDevOrNull() || "A component",
props.type,
);
didWarnValueDefaultValue = true;
}
}
var node = element;
var defaultValue = props.defaultValue == null ? "" : props.defaultValue;
node._wrapperState = {
initialChecked:
props.checked != null ? props.checked : props.defaultChecked,
initialValue: getToStringValue(
props.value != null ? props.value : defaultValue,
),
controlled: isControlled(props),
};
}
function updateChecked(element, props) {
var node = element;
var checked = props.checked;
if (checked != null) {
setValueForProperty(node, "checked", checked, false);
}
}
function updateWrapper(element, props) {
var node = element;
{
var controlled = isControlled(props);
if (
!node._wrapperState.controlled &&
controlled &&
!didWarnUncontrolledToControlled
) {
error(
"A component is changing an uncontrolled input to be controlled. " +
"This is likely caused by the value changing from undefined to " +
"a defined value, which should not happen. " +
"Decide between using a controlled or uncontrolled input " +
"element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components",
);
didWarnUncontrolledToControlled = true;
}
if (
node._wrapperState.controlled &&
!controlled &&
!didWarnControlledToUncontrolled
) {
error(
"A component is changing a controlled input to be uncontrolled. " +
"This is likely caused by the value changing from a defined to " +
"undefined, which should not happen. " +
"Decide between using a controlled or uncontrolled input " +
"element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components",
);
didWarnControlledToUncontrolled = true;
}
}
updateChecked(element, props);
var value = getToStringValue(props.value);
var type = props.type;
if (value != null) {
if (type === "number") {
if (
(value === 0 && node.value === "") || // We explicitly want to coerce to number here if possible.
// eslint-disable-next-line
node.value != value
) {
node.value = toString(value);
}
} else if (node.value !== toString(value)) {
node.value = toString(value);
}
} else if (type === "submit" || type === "reset") {
// Submit/reset inputs need the attribute removed completely to avoid
// blank-text buttons.
node.removeAttribute("value");
return;
}
{
// When syncing the value attribute, the value comes from a cascade of
// properties:
// 1. The value React property
// 2. The defaultValue React property
// 3. Otherwise there should be no change
if (props.hasOwnProperty("value")) {
setDefaultValue(node, props.type, value);
} else if (props.hasOwnProperty("defaultValue")) {
setDefaultValue(node, props.type, getToStringValue(props.defaultValue));
}
}
{
// When syncing the checked attribute, it only changes when it needs
// to be removed, such as transitioning from a checkbox into a text input
if (props.checked == null && props.defaultChecked != null) {
node.defaultChecked = !!props.defaultChecked;
}
}
}
function postMountWrapper(element, props, isHydrating) {
var node = element; // Do not assign value if it is already set. This prevents user text input
// from being lost during SSR hydration.
if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) {
var type = props.type;
var isButton = type === "submit" || type === "reset"; // Avoid setting value attribute on submit/reset inputs as it overrides the
// default value provided by the browser. See: #12872
if (isButton && (props.value === undefined || props.value === null)) {
return;
}
var initialValue = toString(node._wrapperState.initialValue); // Do not assign value if it is already set. This prevents user text input
// from being lost during SSR hydration.
if (!isHydrating) {
{
// When syncing the value attribute, the value property should use
// the wrapperState._initialValue property. This uses:
//
// 1. The value React property when present
// 2. The defaultValue React property when present
// 3. An empty string
if (initialValue !== node.value) {
node.value = initialValue;
}
}
}
{
// Otherwise, the value attribute is synchronized to the property,
// so we assign defaultValue to the same thing as the value property
// assignment step above.
node.defaultValue = initialValue;
}
} // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
// this is needed to work around a chrome bug where setting defaultChecked
// will sometimes influence the value of checked (even after detachment).
// Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
// We need to temporarily unset name to avoid disrupting radio button groups.
var name = node.name;
if (name !== "") {
node.name = "";
}
{
// When syncing the checked attribute, both the checked property and
// attribute are assigned at the same time using defaultChecked. This uses:
//
// 1. The checked React property when present
// 2. The defaultChecked React property when present
// 3. Otherwise, false
node.defaultChecked = !node.defaultChecked;
node.defaultChecked = !!node._wrapperState.initialChecked;
}
if (name !== "") {
node.name = name;
}
}
function restoreControlledState(element, props) {
var node = element;
updateWrapper(node, props);
updateNamedCousins(node, props);
}
function updateNamedCousins(rootNode, props) {
var name = props.name;
if (props.type === "radio" && name != null) {
var queryRoot = rootNode;
while (queryRoot.parentNode) {
queryRoot = queryRoot.parentNode;
} // If `rootNode.form` was non-null, then we could try `form.elements`,
// but that sometimes behaves strangely in IE8. We could also try using
// `form.getElementsByName`, but that will only return direct children
// and won't include inputs that use the HTML5 `form=` attribute. Since
// the input might not even be in a form. It might not even be in the
// document. Let's just use the local `querySelectorAll` to ensure we don't
// miss anything.
var group = queryRoot.querySelectorAll(
"input[name=" + JSON.stringify("" + name) + '][type="radio"]',
);
for (var i = 0; i < group.length; i++) {
var otherNode = group[i];
if (otherNode === rootNode || otherNode.form !== rootNode.form) {
continue;
} // This will throw if radio buttons rendered by different copies of React
// and the same name are rendered into the same form (same as #1939).
// That's probably okay; we don't support it just as we don't support
// mixing React radio buttons with non-React ones.
var otherProps = getFiberCurrentPropsFromNode(otherNode);
if (!otherProps) {
{
throw Error(
"ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.",
);
}
} // We need update the tracked value on the named cousin since the value
// was changed but the input saw no event or value set
updateValueIfChanged(otherNode); // If this is a controlled radio button group, forcing the input that
// was previously checked to update will cause it to be come re-checked
// as appropriate.
updateWrapper(otherNode, otherProps);
}
}
} // In Chrome, assigning defaultValue to certain input types triggers input validation.
// For number inputs, the display value loses trailing decimal points. For email inputs,
// Chrome raises "The specified value <x> is not a valid email address".
//
// Here we check to see if the defaultValue has actually changed, avoiding these problems
// when the user is inputting text
//
// https://github.com/facebook/react/issues/7253
function setDefaultValue(node, type, value) {
if (
// Focused number inputs synchronize on blur. See ChangeEventPlugin.js
type !== "number" ||
getActiveElement(node.ownerDocument) !== node
) {
if (value == null) {
node.defaultValue = toString(node._wrapperState.initialValue);
} else if (node.defaultValue !== toString(value)) {
node.defaultValue = toString(value);
}
}
}
var didWarnSelectedSetOnOption = false;
var didWarnInvalidChild = false;
function flattenChildren(children) {
var content = ""; // Flatten children. We'll warn if they are invalid
// during validateProps() which runs for hydration too.
// Note that this would throw on non-element objects.
// Elements are stringified (which is normally irrelevant
// but matters for <fbt>).
React.Children.forEach(children, function (child) {
if (child == null) {
return;
}
content += child; // Note: we don't warn about invalid children here.
// Instead, this is done separately below so that
// it happens during the hydration code path too.
});
return content;
}
/**
* Implements an <option> host component that warns when `selected` is set.
*/
function validateProps(element, props) {
{
// This mirrors the code path above, but runs for hydration too.
// Warn about invalid children here so that client and hydration are consistent.
// TODO: this seems like it could cause a DEV-only throw for hydration
// if children contains a non-element object. We should try to avoid that.
if (typeof props.children === "object" && props.children !== null) {
React.Children.forEach(props.children, function (child) {
if (child == null) {
return;
}
if (typeof child === "string" || typeof child === "number") {
return;
}
if (typeof child.type !== "string") {
return;
}
if (!didWarnInvalidChild) {
didWarnInvalidChild = true;
error(
"Only strings and numbers are supported as <option> children.",
);
}
});
} // TODO: Remove support for `selected` in <option>.
if (props.selected != null && !didWarnSelectedSetOnOption) {
error(
"Use the `defaultValue` or `value` props on <select> instead of " +
"setting `selected` on <option>.",
);
didWarnSelectedSetOnOption = true;
}
}
}
function postMountWrapper$1(element, props) {
// value="" should make a value attribute (#6219)
if (props.value != null) {
element.setAttribute("value", toString(getToStringValue(props.value)));
}
}
function getHostProps$1(element, props) {
var hostProps = _assign(
{
children: undefined,
},
props,
);
var content = flattenChildren(props.children);
if (content) {
hostProps.children = content;
}
return hostProps;
}
var didWarnValueDefaultValue$1;
{
didWarnValueDefaultValue$1 = false;
}
function getDeclarationErrorAddendum() {
var ownerName = getCurrentFiberOwnerNameInDevOrNull();
if (ownerName) {
return "\n\nCheck the render method of `" + ownerName + "`.";
}
return "";
}
var valuePropNames = ["value", "defaultValue"];
/**
* Validation function for `value` and `defaultValue`.
*/
function checkSelectPropTypes(props) {
{
checkControlledValueProps("select", props);
for (var i = 0; i < valuePropNames.length; i++) {
var propName = valuePropNames[i];
if (props[propName] == null) {
continue;
}
var isArray = Array.isArray(props[propName]);
if (props.multiple && !isArray) {
error(
"The `%s` prop supplied to <select> must be an array if " +
"`multiple` is true.%s",
propName,
getDeclarationErrorAddendum(),
);
} else if (!props.multiple && isArray) {
error(
"The `%s` prop supplied to <select> must be a scalar " +
"value if `multiple` is false.%s",
propName,
getDeclarationErrorAddendum(),
);
}
}
}
}
function updateOptions(node, multiple, propValue, setDefaultSelected) {
var options = node.options;
if (multiple) {
var selectedValues = propValue;
var selectedValue = {};
for (var i = 0; i < selectedValues.length; i++) {
// Prefix to avoid chaos with special keys.
selectedValue["$" + selectedValues[i]] = true;
}
for (var _i = 0; _i < options.length; _i++) {
var selected = selectedValue.hasOwnProperty("$" + options[_i].value);
if (options[_i].selected !== selected) {
options[_i].selected = selected;
}
if (selected && setDefaultSelected) {
options[_i].defaultSelected = true;
}
}
} else {
// Do not set `select.value` as exact behavior isn't consistent across all
// browsers for all cases.
var _selectedValue = toString(getToStringValue(propValue));
var defaultSelected = null;
for (var _i2 = 0; _i2 < options.length; _i2++) {
if (options[_i2].value === _selectedValue) {
options[_i2].selected = true;
if (setDefaultSelected) {
options[_i2].defaultSelected = true;
}
return;
}
if (defaultSelected === null && !options[_i2].disabled) {
defaultSelected = options[_i2];
}
}
if (defaultSelected !== null) {
defaultSelected.selected = true;
}
}
}
/**
* Implements a <select> host component that allows optionally setting the
* props `value` and `defaultValue`. If `multiple` is false, the prop must be a
* stringable. If `multiple` is true, the prop must be an array of stringables.
*
* If `value` is not supplied (or null/undefined), user actions that change the
* selected option will trigger updates to the rendered options.
*
* If it is supplied (and not null/undefined), the rendered options will not
* update in response to user actions. Instead, the `value` prop must change in
* order for the rendered options to update.
*
* If `defaultValue` is provided, any options with the supplied values will be
* selected.
*/
function getHostProps$2(element, props) {
return _assign({}, props, {
value: undefined,
});
}
function initWrapperState$1(element, props) {
var node = element;
{
checkSelectPropTypes(props);
}
node._wrapperState = {
wasMultiple: !!props.multiple,
};
{
if (
props.value !== undefined &&
props.defaultValue !== undefined &&
!didWarnValueDefaultValue$1
) {
error(
"Select elements must be either controlled or uncontrolled " +
"(specify either the value prop, or the defaultValue prop, but not " +
"both). Decide between using a controlled or uncontrolled select " +
"element and remove one of these props. More info: " +
"https://reactjs.org/link/controlled-components",
);
didWarnValueDefaultValue$1 = true;
}
}
}
function postMountWrapper$2(element, props) {
var node = element;
node.multiple = !!props.multiple;
var value = props.value;
if (value != null) {
updateOptions(node, !!props.multiple, value, false);
} else if (props.defaultValue != null) {
updateOptions(node, !!props.multiple, props.defaultValue, true);
}
}
function postUpdateWrapper(element, props) {
var node = element;
var wasMultiple = node._wrapperState.wasMultiple;
node._wrapperState.wasMultiple = !!props.multiple;
var value = props.value;
if (value != null) {
updateOptions(node, !!props.multiple, value, false);
} else if (wasMultiple !== !!props.multiple) {
// For simplicity, reapply `defaultValue` if `multiple` is toggled.
if (props.defaultValue != null) {
updateOptions(node, !!props.multiple, props.defaultValue, true);
} else {
// Revert the select back to its default unselected state.
updateOptions(node, !!props.multiple, props.multiple ? [] : "", false);
}
}
}
function restoreControlledState$1(element, props) {
var node = element;
var value = props.value;
if (value != null) {
updateOptions(node, !!props.multiple, value, false);
}
}
var didWarnValDefaultVal = false;
/**
* Implements a <textarea> host component that allows setting `value`, and
* `defaultValue`. This differs from the traditional DOM API because value is
* usually set as PCDATA children.
*
* If `value` is not supplied (or null/undefined), user actions that affect the
* value will trigger updates to the element.
*
* If `value` is supplied (and not null/undefined), the rendered element will
* not trigger updates to the element. Instead, the `value` prop must change in
* order for the rendered element to be updated.
*
* The rendered element will be initialized with an empty value, the prop
* `defaultValue` if specified, or the children content (deprecated).
*/
function getHostProps$3(element, props) {
var node = element;
if (!(props.dangerouslySetInnerHTML == null)) {
{
throw Error(
"`dangerouslySetInnerHTML` does not make sense on <textarea>.",
);
}
} // Always set children to the same thing. In IE9, the selection range will
// get reset if `textContent` is mutated. We could add a check in setTextContent
// to only set the value if/when the value differs from the node value (which would
// completely solve this IE9 bug), but Sebastian+Sophie seemed to like this
// solution. The value can be a boolean or object so that's why it's forced
// to be a string.
var hostProps = _assign({}, props, {
value: undefined,
defaultValue: undefined,
children: toString(node._wrapperState.initialValue),
});
return hostProps;
}
function initWrapperState$2(element, props) {
var node = element;
{
checkControlledValueProps("textarea", props);
if (
props.value !== undefined &&
props.defaultValue !== undefined &&
!didWarnValDefaultVal
) {
error(
"%s contains a textarea with both value and defaultValue props. " +
"Textarea elements must be either controlled or uncontrolled " +
"(specify either the value prop, or the defaultValue prop, but not " +
"both). Decide between using a controlled or uncontrolled textarea " +
"and remove one of these props. More info: " +
"https://reactjs.org/link/controlled-components",
getCurrentFiberOwnerNameInDevOrNull() || "A component",
);
didWarnValDefaultVal = true;
}
}
var initialValue = props.value; // Only bother fetching default value if we're going to use it
if (initialValue == null) {
var children = props.children,
defaultValue = props.defaultValue;
if (children != null) {
{
error(
"Use the `defaultValue` or `value` props instead of setting " +
"children on <textarea>.",
);
}
{
if (!(defaultValue == null)) {
{
throw Error(
"If you supply `defaultValue` on a <textarea>, do not pass children.",
);
}
}
if (Array.isArray(children)) {
if (!(children.length <= 1)) {
{
throw Error("<textarea> can only have at most one child.");
}
}
children = children[0];
}
defaultValue = children;
}
}
if (defaultValue == null) {
defaultValue = "";
}
initialValue = defaultValue;
}
node._wrapperState = {
initialValue: getToStringValue(initialValue),
};
}
function updateWrapper$1(element, props) {
var node = element;
var value = getToStringValue(props.value);
var defaultValue = getToStringValue(props.defaultValue);
if (value != null) {
// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
var newValue = toString(value); // To avoid side effects (such as losing text selection), only set value if changed
if (newValue !== node.value) {
node.value = newValue;
}
if (props.defaultValue == null && node.defaultValue !== newValue) {
node.defaultValue = newValue;
}
}
if (defaultValue != null) {
node.defaultValue = toString(defaultValue);
}
}
function postMountWrapper$3(element, props) {
var node = element; // This is in postMount because we need access to the DOM node, which is not
// available until after the component has mounted.
var textContent = node.textContent; // Only set node.value if textContent is equal to the expected
// initial value. In IE10/IE11 there is a bug where the placeholder attribute
// will populate textContent as well.
// https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
if (textContent === node._wrapperState.initialValue) {
if (textContent !== "" && textContent !== null) {
node.value = textContent;
}
}
}
function restoreControlledState$2(element, props) {
// DOM component is still mounted; update
updateWrapper$1(element, props);
}
var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
var MATH_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
var Namespaces = {
html: HTML_NAMESPACE,
mathml: MATH_NAMESPACE,
svg: SVG_NAMESPACE,
}; // Assumes there is no parent namespace.
function getIntrinsicNamespace(type) {
switch (type) {
case "svg":
return SVG_NAMESPACE;
case "math":
return MATH_NAMESPACE;
default:
return HTML_NAMESPACE;
}
}
function getChildNamespace(parentNamespace, type) {
if (parentNamespace == null || parentNamespace === HTML_NAMESPACE) {
// No (or default) parent namespace: potential entry point.
return getIntrinsicNamespace(type);
}
if (parentNamespace === SVG_NAMESPACE && type === "foreignObject") {
// We're leaving SVG.
return HTML_NAMESPACE;
} // By default, pass namespace below.
return parentNamespace;
}
/* globals MSApp */
/**
* Create a function which has 'unsafe' privileges (required by windows8 apps)
*/
var createMicrosoftUnsafeLocalFunction = function (func) {
if (typeof MSApp !== "undefined" && MSApp.execUnsafeLocalFunction) {
return function (arg0, arg1, arg2, arg3) {
MSApp.execUnsafeLocalFunction(function () {
return func(arg0, arg1, arg2, arg3);
});
};
} else {
return func;
}
};
var reusableSVGContainer;
/**
* Set the innerHTML property of a node
*
* @param {DOMElement} node
* @param {string} html
* @internal
*/
var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
if (node.namespaceURI === Namespaces.svg) {
if (!("innerHTML" in node)) {
// IE does not have innerHTML for SVG nodes, so instead we inject the
// new markup in a temp node and then move the child nodes across into
// the target node
reusableSVGContainer =
reusableSVGContainer || document.createElement("div");
reusableSVGContainer.innerHTML =
"<svg>" + html.valueOf().toString() + "</svg>";
var svgNode = reusableSVGContainer.firstChild;
while (node.firstChild) {
node.removeChild(node.firstChild);
}
while (svgNode.firstChild) {
node.appendChild(svgNode.firstChild);
}
return;
}
}
node.innerHTML = html;
});
/**
* HTML nodeType values that represent the type of the node
*/
var ELEMENT_NODE = 1;
var TEXT_NODE = 3;
var COMMENT_NODE = 8;
var DOCUMENT_NODE = 9;
var DOCUMENT_FRAGMENT_NODE = 11;
/**
* Set the textContent property of a node. For text updates, it's faster
* to set the `nodeValue` of the Text node directly instead of using
* `.textContent` which will remove the existing node and create a new one.
*
* @param {DOMElement} node
* @param {string} text
* @internal
*/
var setTextContent = function (node, text) {
if (text) {
var firstChild = node.firstChild;
if (
firstChild &&
firstChild === node.lastChild &&
firstChild.nodeType === TEXT_NODE
) {
firstChild.nodeValue = text;
return;
}
}
node.textContent = text;
};
// List derived from Gecko source code:
// https://github.com/mozilla/gecko-dev/blob/4e638efc71/layout/style/test/property_database.js
var shorthandToLonghand = {
animation: [
"animationDelay",
"animationDirection",
"animationDuration",
"animationFillMode",
"animationIterationCount",
"animationName",
"animationPlayState",
"animationTimingFunction",
],
background: [
"backgroundAttachment",
"backgroundClip",
"backgroundColor",
"backgroundImage",
"backgroundOrigin",
"backgroundPositionX",
"backgroundPositionY",
"backgroundRepeat",
"backgroundSize",
],
backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
border: [
"borderBottomColor",
"borderBottomStyle",
"borderBottomWidth",
"borderImageOutset",
"borderImageRepeat",
"borderImageSlice",
"borderImageSource",
"borderImageWidth",
"borderLeftColor",
"borderLeftStyle",
"borderLeftWidth",
"borderRightColor",
"borderRightStyle",
"borderRightWidth",
"borderTopColor",
"borderTopStyle",
"borderTopWidth",
],
borderBlockEnd: [
"borderBlockEndColor",
"borderBlockEndStyle",
"borderBlockEndWidth",
],
borderBlockStart: [
"borderBlockStartColor",
"borderBlockStartStyle",
"borderBlockStartWidth",
],
borderBottom: [
"borderBottomColor",
"borderBottomStyle",
"borderBottomWidth",
],
borderColor: [
"borderBottomColor",
"borderLeftColor",
"borderRightColor",
"borderTopColor",
],
borderImage: [
"borderImageOutset",
"borderImageRepeat",
"borderImageSlice",
"borderImageSource",
"borderImageWidth",
],
borderInlineEnd: [
"borderInlineEndColor",
"borderInlineEndStyle",
"borderInlineEndWidth",
],
borderInlineStart: [
"borderInlineStartColor",
"borderInlineStartStyle",
"borderInlineStartWidth",
],
borderLeft: ["borderLeftColor", "borderLeftStyle", "borderLeftWidth"],
borderRadius: [
"borderBottomLeftRadius",
"borderBottomRightRadius",
"borderTopLeftRadius",
"borderTopRightRadius",
],
borderRight: ["borderRightColor", "borderRightStyle", "borderRightWidth"],
borderStyle: [
"borderBottomStyle",
"borderLeftStyle",
"borderRightStyle",
"borderTopStyle",
],
borderTop: ["borderTopColor", "borderTopStyle", "borderTopWidth"],
borderWidth: [
"borderBottomWidth",
"borderLeftWidth",
"borderRightWidth",
"borderTopWidth",
],
columnRule: ["columnRuleColor", "columnRuleStyle", "columnRuleWidth"],
columns: ["columnCount", "columnWidth"],
flex: ["flexBasis", "flexGrow", "flexShrink"],
flexFlow: ["flexDirection", "flexWrap"],
font: [
"fontFamily",
"fontFeatureSettings",
"fontKerning",
"fontLanguageOverride",
"fontSize",
"fontSizeAdjust",
"fontStretch",
"fontStyle",
"fontVariant",
"fontVariantAlternates",
"fontVariantCaps",
"fontVariantEastAsian",
"fontVariantLigatures",
"fontVariantNumeric",
"fontVariantPosition",
"fontWeight",
"lineHeight",
],
fontVariant: [
"fontVariantAlternates",
"fontVariantCaps",
"fontVariantEastAsian",
"fontVariantLigatures",
"fontVariantNumeric",
"fontVariantPosition",
],
gap: ["columnGap", "rowGap"],
grid: [
"gridAutoColumns",
"gridAutoFlow",
"gridAutoRows",
"gridTemplateAreas",
"gridTemplateColumns",
"gridTemplateRows",
],
gridArea: [
"gridColumnEnd",
"gridColumnStart",
"gridRowEnd",
"gridRowStart",
],
gridColumn: ["gridColumnEnd", "gridColumnStart"],
gridColumnGap: ["columnGap"],
gridGap: ["columnGap", "rowGap"],
gridRow: ["gridRowEnd", "gridRowStart"],
gridRowGap: ["rowGap"],
gridTemplate: [
"gridTemplateAreas",
"gridTemplateColumns",
"gridTemplateRows",
],
listStyle: ["listStyleImage", "listStylePosition", "listStyleType"],
margin: ["marginBottom", "marginLeft", "marginRight", "marginTop"],
marker: ["markerEnd", "markerMid", "markerStart"],
mask: [
"maskClip",
"maskComposite",
"maskImage",
"maskMode",
"maskOrigin",
"maskPositionX",
"maskPositionY",
"maskRepeat",
"maskSize",
],
maskPosition: ["maskPositionX", "maskPositionY"],
outline: ["outlineColor", "outlineStyle", "outlineWidth"],
overflow: ["overflowX", "overflowY"],
padding: ["paddingBottom", "paddingLeft", "paddingRight", "paddingTop"],
placeContent: ["alignContent", "justifyContent"],
placeItems: ["alignItems", "justifyItems"],
placeSelf: ["alignSelf", "justifySelf"],
textDecoration: [
"textDecorationColor",
"textDecorationLine",
"textDecorationStyle",
],
textEmphasis: ["textEmphasisColor", "textEmphasisStyle"],
transition: [
"transitionDelay",
"transitionDuration",
"transitionProperty",
"transitionTimingFunction",
],
wordWrap: ["overflowWrap"],
};
/**
* CSS properties which accept numbers but are not in units of "px".
*/
var isUnitlessNumber = {
animationIterationCount: true,
borderImageOutset: true,
borderImageSlice: true,
borderImageWidth: true,
boxFlex: true,
boxFlexGroup: true,
boxOrdinalGroup: true,
columnCount: true,
columns: true,
flex: true,
flexGrow: true,
flexPositive: true,
flexShrink: true,
flexNegative: true,
flexOrder: true,
gridArea: true,
gridRow: true,
gridRowEnd: true,
gridRowSpan: true,
gridRowStart: true,
gridColumn: true,
gridColumnEnd: true,
gridColumnSpan: true,
gridColumnStart: true,
fontWeight: true,
lineClamp: true,
lineHeight: true,
opacity: true,
order: true,
orphans: true,
tabSize: true,
widows: true,
zIndex: true,
zoom: true,
// SVG-related properties
fillOpacity: true,
floodOpacity: true,
stopOpacity: true,
strokeDasharray: true,
strokeDashoffset: true,
strokeMiterlimit: true,
strokeOpacity: true,
strokeWidth: true,
};
/**
* @param {string} prefix vendor-specific prefix, eg: Webkit
* @param {string} key style name, eg: transitionDuration
* @return {string} style name prefixed with `prefix`, properly camelCased, eg:
* WebkitTransitionDuration
*/
function prefixKey(prefix, key) {
return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}
/**
* Support style names that may come passed in prefixed by adding permutations
* of vendor prefixes.
*/
var prefixes = ["Webkit", "ms", "Moz", "O"]; // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
// infinite loop, because it iterates over the newly added props too.
Object.keys(isUnitlessNumber).forEach(function (prop) {
prefixes.forEach(function (prefix) {
isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
});
});
/**
* Convert a value into the proper css writable value. The style name `name`
* should be logical (no hyphens), as specified
* in `CSSProperty.isUnitlessNumber`.
*
* @param {string} name CSS property name such as `topMargin`.
* @param {*} value CSS property value such as `10px`.
* @return {string} Normalized style value with dimensions applied.
*/
function dangerousStyleValue(name, value, isCustomProperty) {
// Note that we've removed escapeTextForBrowser() calls here since the
// whole string will be escaped when the attribute is injected into
// the markup. If you provide unsafe user data here they can inject
// arbitrary CSS which may be problematic (I couldn't repro this):
// https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
// http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
// This is not an XSS hole but instead a potential CSS injection issue
// which has lead to a greater discussion about how we're going to
// trust URLs moving forward. See #2115901
var isEmpty = value == null || typeof value === "boolean" || value === "";
if (isEmpty) {
return "";
}
if (
!isCustomProperty &&
typeof value === "number" &&
value !== 0 &&
!(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])
) {
return value + "px"; // Presumes implicit 'px' suffix for unitless numbers
}
return ("" + value).trim();
}
var uppercasePattern = /([A-Z])/g;
var msPattern = /^ms-/;
/**
* Hyphenates a camelcased CSS property name, for example:
*
* > hyphenateStyleName('backgroundColor')
* < "background-color"
* > hyphenateStyleName('MozTransition')
* < "-moz-transition"
* > hyphenateStyleName('msTransition')
* < "-ms-transition"
*
* As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
* is converted to `-ms-`.
*/
function hyphenateStyleName(name) {
return name
.replace(uppercasePattern, "-$1")
.toLowerCase()
.replace(msPattern, "-ms-");
}
var warnValidStyle = function () {};
{
// 'msTransform' is correct, but the other prefixes should be capitalized
var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
var msPattern$1 = /^-ms-/;
var hyphenPattern = /-(.)/g; // style values shouldn't contain a semicolon
var badStyleValueWithSemicolonPattern = /;\s*$/;
var warnedStyleNames = {};
var warnedStyleValues = {};
var warnedForNaNValue = false;
var warnedForInfinityValue = false;
var camelize = function (string) {
return string.replace(hyphenPattern, function (_, character) {
return character.toUpperCase();
});
};
var warnHyphenatedStyleName = function (name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
error(
"Unsupported style property %s. Did you mean %s?",
name, // As Andi Smith suggests
// (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
// is converted to lowercase `ms`.
camelize(name.replace(msPattern$1, "ms-")),
);
};
var warnBadVendoredStyleName = function (name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
error(
"Unsupported vendor-prefixed style property %s. Did you mean %s?",
name,
name.charAt(0).toUpperCase() + name.slice(1),
);
};
var warnStyleValueWithSemicolon = function (name, value) {
if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
return;
}
warnedStyleValues[value] = true;
error(
"Style property values shouldn't contain a semicolon. " +
'Try "%s: %s" instead.',
name,
value.replace(badStyleValueWithSemicolonPattern, ""),
);
};
var warnStyleValueIsNaN = function (name, value) {
if (warnedForNaNValue) {
return;
}
warnedForNaNValue = true;
error("`NaN` is an invalid value for the `%s` css style property.", name);
};
var warnStyleValueIsInfinity = function (name, value) {
if (warnedForInfinityValue) {
return;
}
warnedForInfinityValue = true;
error(
"`Infinity` is an invalid value for the `%s` css style property.",
name,
);
};
warnValidStyle = function (name, value) {
if (name.indexOf("-") > -1) {
warnHyphenatedStyleName(name);
} else if (badVendoredStyleNamePattern.test(name)) {
warnBadVendoredStyleName(name);
} else if (badStyleValueWithSemicolonPattern.test(value)) {
warnStyleValueWithSemicolon(name, value);
}
if (typeof value === "number") {
if (isNaN(value)) {
warnStyleValueIsNaN(name, value);
} else if (!isFinite(value)) {
warnStyleValueIsInfinity(name, value);
}
}
};
}
var warnValidStyle$1 = warnValidStyle;
/**
* Operations for dealing with CSS properties.
*/
/**
* This creates a string that is expected to be equivalent to the style
* attribute generated by server-side rendering. It by-passes warnings and
* security checks so it's not safe to use this value for anything other than
* comparison. It is only used in DEV for SSR validation.
*/
function createDangerousStringForStyles(styles) {
{
var serialized = "";
var delimiter = "";
for (var styleName in styles) {
if (!styles.hasOwnProperty(styleName)) {
continue;
}
var styleValue = styles[styleName];
if (styleValue != null) {
var isCustomProperty = styleName.indexOf("--") === 0;
serialized +=
delimiter +
(isCustomProperty ? styleName : hyphenateStyleName(styleName)) +
":";
serialized += dangerousStyleValue(
styleName,
styleValue,
isCustomProperty,
);
delimiter = ";";
}
}
return serialized || null;
}
}
/**
* Sets the value for multiple styles on a node. If a value is specified as
* '' (empty string), the corresponding style property will be unset.
*
* @param {DOMElement} node
* @param {object} styles
*/
function setValueForStyles(node, styles) {
var style = node.style;
for (var styleName in styles) {
if (!styles.hasOwnProperty(styleName)) {
continue;
}
var isCustomProperty = styleName.indexOf("--") === 0;
{
if (!isCustomProperty) {
warnValidStyle$1(styleName, styles[styleName]);
}
}
var styleValue = dangerousStyleValue(
styleName,
styles[styleName],
isCustomProperty,
);
if (styleName === "float") {
styleName = "cssFloat";
}
if (isCustomProperty) {
style.setProperty(styleName, styleValue);
} else {
style[styleName] = styleValue;
}
}
}
function isValueEmpty(value) {
return value == null || typeof value === "boolean" || value === "";
}
/**
* Given {color: 'red', overflow: 'hidden'} returns {
* color: 'color',
* overflowX: 'overflow',
* overflowY: 'overflow',
* }. This can be read as "the overflowY property was set by the overflow
* shorthand". That is, the values are the property that each was derived from.
*/
function expandShorthandMap(styles) {
var expanded = {};
for (var key in styles) {
var longhands = shorthandToLonghand[key] || [key];
for (var i = 0; i < longhands.length; i++) {
expanded[longhands[i]] = key;
}
}
return expanded;
}
/**
* When mixing shorthand and longhand property names, we warn during updates if
* we expect an incorrect result to occur. In particular, we warn for:
*
* Updating a shorthand property (longhand gets overwritten):
* {font: 'foo', fontVariant: 'bar'} -> {font: 'baz', fontVariant: 'bar'}
* becomes .style.font = 'baz'
* Removing a shorthand property (longhand gets lost too):
* {font: 'foo', fontVariant: 'bar'} -> {fontVariant: 'bar'}
* becomes .style.font = ''
* Removing a longhand property (should revert to shorthand; doesn't):
* {font: 'foo', fontVariant: 'bar'} -> {font: 'foo'}
* becomes .style.fontVariant = ''
*/
function validateShorthandPropertyCollisionInDev(styleUpdates, nextStyles) {
{
if (!nextStyles) {
return;
}
var expandedUpdates = expandShorthandMap(styleUpdates);
var expandedStyles = expandShorthandMap(nextStyles);
var warnedAbout = {};
for (var key in expandedUpdates) {
var originalKey = expandedUpdates[key];
var correctOriginalKey = expandedStyles[key];
if (correctOriginalKey && originalKey !== correctOriginalKey) {
var warningKey = originalKey + "," + correctOriginalKey;
if (warnedAbout[warningKey]) {
continue;
}
warnedAbout[warningKey] = true;
error(
"%s a style property during rerender (%s) when a " +
"conflicting property is set (%s) can lead to styling bugs. To " +
"avoid this, don't mix shorthand and non-shorthand properties " +
"for the same value; instead, replace the shorthand with " +
"separate values.",
isValueEmpty(styleUpdates[originalKey]) ? "Removing" : "Updating",
originalKey,
correctOriginalKey,
);
}
}
}
}
// For HTML, certain tags should omit their close tag. We keep a list for
// those special-case tags.
var omittedCloseTags = {
area: true,
base: true,
br: true,
col: true,
embed: true,
hr: true,
img: true,
input: true,
keygen: true,
link: true,
meta: true,
param: true,
source: true,
track: true,
wbr: true, // NOTE: menuitem's close tag should be omitted, but that causes problems.
};
// `omittedCloseTags` except that `menuitem` should still have its closing tag.
var voidElementTags = _assign(
{
menuitem: true,
},
omittedCloseTags,
);
var HTML = "__html";
function assertValidProps(tag, props) {
if (!props) {
return;
} // Note the use of `==` which checks for null or undefined.
if (voidElementTags[tag]) {
if (!(props.children == null && props.dangerouslySetInnerHTML == null)) {
{
throw Error(
tag +
" is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.",
);
}
}
}
if (props.dangerouslySetInnerHTML != null) {
if (!(props.children == null)) {
{
throw Error(
"Can only set one of `children` or `props.dangerouslySetInnerHTML`.",
);
}
}
if (
!(
typeof props.dangerouslySetInnerHTML === "object" &&
HTML in props.dangerouslySetInnerHTML
)
) {
{
throw Error(
"`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.",
);
}
}
}
{
if (
!props.suppressContentEditableWarning &&
props.contentEditable &&
props.children != null
) {
error(
"A component is `contentEditable` and contains `children` managed by " +
"React. It is now your responsibility to guarantee that none of " +
"those nodes are unexpectedly modified or duplicated. This is " +
"probably not intentional.",
);
}
}
if (!(props.style == null || typeof props.style === "object")) {
{
throw Error(
"The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.",
);
}
}
}
function isCustomComponent(tagName, props) {
if (tagName.indexOf("-") === -1) {
return typeof props.is === "string";
}
switch (tagName) {
// These are reserved SVG and MathML elements.
// We don't mind this list too much because we expect it to never grow.
// The alternative is to track the namespace in a few places which is convoluted.
// https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
case "annotation-xml":
case "color-profile":
case "font-face":
case "font-face-src":
case "font-face-uri":
case "font-face-format":
case "font-face-name":
case "missing-glyph":
return false;
default:
return true;
}
}
// When adding attributes to the HTML or SVG allowed attribute list, be sure to
// also add them to this module to ensure casing and incorrect name
// warnings.
var possibleStandardNames = {
// HTML
accept: "accept",
acceptcharset: "acceptCharset",
"accept-charset": "acceptCharset",
accesskey: "accessKey",
action: "action",
allowfullscreen: "allowFullScreen",
alt: "alt",
as: "as",
async: "async",
autocapitalize: "autoCapitalize",
autocomplete: "autoComplete",
autocorrect: "autoCorrect",
autofocus: "autoFocus",
autoplay: "autoPlay",
autosave: "autoSave",
capture: "capture",
cellpadding: "cellPadding",
cellspacing: "cellSpacing",
challenge: "challenge",
charset: "charSet",
checked: "checked",
children: "children",
cite: "cite",
class: "className",
classid: "classID",
classname: "className",
cols: "cols",
colspan: "colSpan",
content: "content",
contenteditable: "contentEditable",
contextmenu: "contextMenu",
controls: "controls",
controlslist: "controlsList",
coords: "coords",
crossorigin: "crossOrigin",
dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
data: "data",
datetime: "dateTime",
default: "default",
defaultchecked: "defaultChecked",
defaultvalue: "defaultValue",
defer: "defer",
dir: "dir",
disabled: "disabled",
disablepictureinpicture: "disablePictureInPicture",
disableremoteplayback: "disableRemotePlayback",
download: "download",
draggable: "draggable",
enctype: "encType",
enterkeyhint: "enterKeyHint",
for: "htmlFor",
form: "form",
formmethod: "formMethod",
formaction: "formAction",
formenctype: "formEncType",
formnovalidate: "formNoValidate",
formtarget: "formTarget",
frameborder: "frameBorder",
headers: "headers",
height: "height",
hidden: "hidden",
high: "high",
href: "href",
hreflang: "hrefLang",
htmlfor: "htmlFor",
httpequiv: "httpEquiv",
"http-equiv": "httpEquiv",
icon: "icon",
id: "id",
innerhtml: "innerHTML",
inputmode: "inputMode",
integrity: "integrity",
is: "is",
itemid: "itemID",
itemprop: "itemProp",
itemref: "itemRef",
itemscope: "itemScope",
itemtype: "itemType",
keyparams: "keyParams",
keytype: "keyType",
kind: "kind",
label: "label",
lang: "lang",
list: "list",
loop: "loop",
low: "low",
manifest: "manifest",
marginwidth: "marginWidth",
marginheight: "marginHeight",
max: "max",
maxlength: "maxLength",
media: "media",
mediagroup: "mediaGroup",
method: "method",
min: "min",
minlength: "minLength",
multiple: "multiple",
muted: "muted",
name: "name",
nomodule: "noModule",
nonce: "nonce",
novalidate: "noValidate",
open: "open",
optimum: "optimum",
pattern: "pattern",
placeholder: "placeholder",
playsinline: "playsInline",
poster: "poster",
preload: "preload",
profile: "profile",
radiogroup: "radioGroup",
readonly: "readOnly",
referrerpolicy: "referrerPolicy",
rel: "rel",
required: "required",
reversed: "reversed",
role: "role",
rows: "rows",
rowspan: "rowSpan",
sandbox: "sandbox",
scope: "scope",
scoped: "scoped",
scrolling: "scrolling",
seamless: "seamless",
selected: "selected",
shape: "shape",
size: "size",
sizes: "sizes",
span: "span",
spellcheck: "spellCheck",
src: "src",
srcdoc: "srcDoc",
srclang: "srcLang",
srcset: "srcSet",
start: "start",
step: "step",
style: "style",
summary: "summary",
tabindex: "tabIndex",
target: "target",
title: "title",
type: "type",
usemap: "useMap",
value: "value",
width: "width",
wmode: "wmode",
wrap: "wrap",
// SVG
about: "about",
accentheight: "accentHeight",
"accent-height": "accentHeight",
accumulate: "accumulate",
additive: "additive",
alignmentbaseline: "alignmentBaseline",
"alignment-baseline": "alignmentBaseline",
allowreorder: "allowReorder",
alphabetic: "alphabetic",
amplitude: "amplitude",
arabicform: "arabicForm",
"arabic-form": "arabicForm",
ascent: "ascent",
attributename: "attributeName",
attributetype: "attributeType",
autoreverse: "autoReverse",
azimuth: "azimuth",
basefrequency: "baseFrequency",
baselineshift: "baselineShift",
"baseline-shift": "baselineShift",
baseprofile: "baseProfile",
bbox: "bbox",
begin: "begin",
bias: "bias",
by: "by",
calcmode: "calcMode",
capheight: "capHeight",
"cap-height": "capHeight",
clip: "clip",
clippath: "clipPath",
"clip-path": "clipPath",
clippathunits: "clipPathUnits",
cliprule: "clipRule",
"clip-rule": "clipRule",
color: "color",
colorinterpolation: "colorInterpolation",
"color-interpolation": "colorInterpolation",
colorinterpolationfilters: "colorInterpolationFilters",
"color-interpolation-filters": "colorInterpolationFilters",
colorprofile: "colorProfile",
"color-profile": "colorProfile",
colorrendering: "colorRendering",
"color-rendering": "colorRendering",
contentscripttype: "contentScriptType",
contentstyletype: "contentStyleType",
cursor: "cursor",
cx: "cx",
cy: "cy",
d: "d",
datatype: "datatype",
decelerate: "decelerate",
descent: "descent",
diffuseconstant: "diffuseConstant",
direction: "direction",
display: "display",
divisor: "divisor",
dominantbaseline: "dominantBaseline",
"dominant-baseline": "dominantBaseline",
dur: "dur",
dx: "dx",
dy: "dy",
edgemode: "edgeMode",
elevation: "elevation",
enablebackground: "enableBackground",
"enable-background": "enableBackground",
end: "end",
exponent: "exponent",
externalresourcesrequired: "externalResourcesRequired",
fill: "fill",
fillopacity: "fillOpacity",
"fill-opacity": "fillOpacity",
fillrule: "fillRule",
"fill-rule": "fillRule",
filter: "filter",
filterres: "filterRes",
filterunits: "filterUnits",
floodopacity: "floodOpacity",
"flood-opacity": "floodOpacity",
floodcolor: "floodColor",
"flood-color": "floodColor",
focusable: "focusable",
fontfamily: "fontFamily",
"font-family": "fontFamily",
fontsize: "fontSize",
"font-size": "fontSize",
fontsizeadjust: "fontSizeAdjust",
"font-size-adjust": "fontSizeAdjust",
fontstretch: "fontStretch",
"font-stretch": "fontStretch",
fontstyle: "fontStyle",
"font-style": "fontStyle",
fontvariant: "fontVariant",
"font-variant": "fontVariant",
fontweight: "fontWeight",
"font-weight": "fontWeight",
format: "format",
from: "from",
fx: "fx",
fy: "fy",
g1: "g1",
g2: "g2",
glyphname: "glyphName",
"glyph-name": "glyphName",
glyphorientationhorizontal: "glyphOrientationHorizontal",
"glyph-orientation-horizontal": "glyphOrientationHorizontal",
glyphorientationvertical: "glyphOrientationVertical",
"glyph-orientation-vertical": "glyphOrientationVertical",
glyphref: "glyphRef",
gradienttransform: "gradientTransform",
gradientunits: "gradientUnits",
hanging: "hanging",
horizadvx: "horizAdvX",
"horiz-adv-x": "horizAdvX",
horizoriginx: "horizOriginX",
"horiz-origin-x": "horizOriginX",
ideographic: "ideographic",
imagerendering: "imageRendering",
"image-rendering": "imageRendering",
in2: "in2",
in: "in",
inlist: "inlist",
intercept: "intercept",
k1: "k1",
k2: "k2",
k3: "k3",
k4: "k4",
k: "k",
kernelmatrix: "kernelMatrix",
kernelunitlength: "kernelUnitLength",
kerning: "kerning",
keypoints: "keyPoints",
keysplines: "keySplines",
keytimes: "keyTimes",
lengthadjust: "lengthAdjust",
letterspacing: "letterSpacing",
"letter-spacing": "letterSpacing",
lightingcolor: "lightingColor",
"lighting-color": "lightingColor",
limitingconeangle: "limitingConeAngle",
local: "local",
markerend: "markerEnd",
"marker-end": "markerEnd",
markerheight: "markerHeight",
markermid: "markerMid",
"marker-mid": "markerMid",
markerstart: "markerStart",
"marker-start": "markerStart",
markerunits: "markerUnits",
markerwidth: "markerWidth",
mask: "mask",
maskcontentunits: "maskContentUnits",
maskunits: "maskUnits",
mathematical: "mathematical",
mode: "mode",
numoctaves: "numOctaves",
offset: "offset",
opacity: "opacity",
operator: "operator",
order: "order",
orient: "orient",
orientation: "orientation",
origin: "origin",
overflow: "overflow",
overlineposition: "overlinePosition",
"overline-position": "overlinePosition",
overlinethickness: "overlineThickness",
"overline-thickness": "overlineThickness",
paintorder: "paintOrder",
"paint-order": "paintOrder",
panose1: "panose1",
"panose-1": "panose1",
pathlength: "pathLength",
patterncontentunits: "patternContentUnits",
patterntransform: "patternTransform",
patternunits: "patternUnits",
pointerevents: "pointerEvents",
"pointer-events": "pointerEvents",
points: "points",
pointsatx: "pointsAtX",
pointsaty: "pointsAtY",
pointsatz: "pointsAtZ",
prefix: "prefix",
preservealpha: "preserveAlpha",
preserveaspectratio: "preserveAspectRatio",
primitiveunits: "primitiveUnits",
property: "property",
r: "r",
radius: "radius",
refx: "refX",
refy: "refY",
renderingintent: "renderingIntent",
"rendering-intent": "renderingIntent",
repeatcount: "repeatCount",
repeatdur: "repeatDur",
requiredextensions: "requiredExtensions",
requiredfeatures: "requiredFeatures",
resource: "resource",
restart: "restart",
result: "result",
results: "results",
rotate: "rotate",
rx: "rx",
ry: "ry",
scale: "scale",
security: "security",
seed: "seed",
shaperendering: "shapeRendering",
"shape-rendering": "shapeRendering",
slope: "slope",
spacing: "spacing",
specularconstant: "specularConstant",
specularexponent: "specularExponent",
speed: "speed",
spreadmethod: "spreadMethod",
startoffset: "startOffset",
stddeviation: "stdDeviation",
stemh: "stemh",
stemv: "stemv",
stitchtiles: "stitchTiles",
stopcolor: "stopColor",
"stop-color": "stopColor",
stopopacity: "stopOpacity",
"stop-opacity": "stopOpacity",
strikethroughposition: "strikethroughPosition",
"strikethrough-position": "strikethroughPosition",
strikethroughthickness: "strikethroughThickness",
"strikethrough-thickness": "strikethroughThickness",
string: "string",
stroke: "stroke",
strokedasharray: "strokeDasharray",
"stroke-dasharray": "strokeDasharray",
strokedashoffset: "strokeDashoffset",
"stroke-dashoffset": "strokeDashoffset",
strokelinecap: "strokeLinecap",
"stroke-linecap": "strokeLinecap",
strokelinejoin: "strokeLinejoin",
"stroke-linejoin": "strokeLinejoin",
strokemiterlimit: "strokeMiterlimit",
"stroke-miterlimit": "strokeMiterlimit",
strokewidth: "strokeWidth",
"stroke-width": "strokeWidth",
strokeopacity: "strokeOpacity",
"stroke-opacity": "strokeOpacity",
suppresscontenteditablewarning: "suppressContentEditableWarning",
suppresshydrationwarning: "suppressHydrationWarning",
surfacescale: "surfaceScale",
systemlanguage: "systemLanguage",
tablevalues: "tableValues",
targetx: "targetX",
targety: "targetY",
textanchor: "textAnchor",
"text-anchor": "textAnchor",
textdecoration: "textDecoration",
"text-decoration": "textDecoration",
textlength: "textLength",
textrendering: "textRendering",
"text-rendering": "textRendering",
to: "to",
transform: "transform",
typeof: "typeof",
u1: "u1",
u2: "u2",
underlineposition: "underlinePosition",
"underline-position": "underlinePosition",
underlinethickness: "underlineThickness",
"underline-thickness": "underlineThickness",
unicode: "unicode",
unicodebidi: "unicodeBidi",
"unicode-bidi": "unicodeBidi",
unicoderange: "unicodeRange",
"unicode-range": "unicodeRange",
unitsperem: "unitsPerEm",
"units-per-em": "unitsPerEm",
unselectable: "unselectable",
valphabetic: "vAlphabetic",
"v-alphabetic": "vAlphabetic",
values: "values",
vectoreffect: "vectorEffect",
"vector-effect": "vectorEffect",
version: "version",
vertadvy: "vertAdvY",
"vert-adv-y": "vertAdvY",
vertoriginx: "vertOriginX",
"vert-origin-x": "vertOriginX",
vertoriginy: "vertOriginY",
"vert-origin-y": "vertOriginY",
vhanging: "vHanging",
"v-hanging": "vHanging",
videographic: "vIdeographic",
"v-ideographic": "vIdeographic",
viewbox: "viewBox",
viewtarget: "viewTarget",
visibility: "visibility",
vmathematical: "vMathematical",
"v-mathematical": "vMathematical",
vocab: "vocab",
widths: "widths",
wordspacing: "wordSpacing",
"word-spacing": "wordSpacing",
writingmode: "writingMode",
"writing-mode": "writingMode",
x1: "x1",
x2: "x2",
x: "x",
xchannelselector: "xChannelSelector",
xheight: "xHeight",
"x-height": "xHeight",
xlinkactuate: "xlinkActuate",
"xlink:actuate": "xlinkActuate",
xlinkarcrole: "xlinkArcrole",
"xlink:arcrole": "xlinkArcrole",
xlinkhref: "xlinkHref",
"xlink:href": "xlinkHref",
xlinkrole: "xlinkRole",
"xlink:role": "xlinkRole",
xlinkshow: "xlinkShow",
"xlink:show": "xlinkShow",
xlinktitle: "xlinkTitle",
"xlink:title": "xlinkTitle",
xlinktype: "xlinkType",
"xlink:type": "xlinkType",
xmlbase: "xmlBase",
"xml:base": "xmlBase",
xmllang: "xmlLang",
"xml:lang": "xmlLang",
xmlns: "xmlns",
"xml:space": "xmlSpace",
xmlnsxlink: "xmlnsXlink",
"xmlns:xlink": "xmlnsXlink",
xmlspace: "xmlSpace",
y1: "y1",
y2: "y2",
y: "y",
ychannelselector: "yChannelSelector",
z: "z",
zoomandpan: "zoomAndPan",
};
var ariaProperties = {
"aria-current": 0,
// state
"aria-details": 0,
"aria-disabled": 0,
// state
"aria-hidden": 0,
// state
"aria-invalid": 0,
// state
"aria-keyshortcuts": 0,
"aria-label": 0,
"aria-roledescription": 0,
// Widget Attributes
"aria-autocomplete": 0,
"aria-checked": 0,
"aria-expanded": 0,
"aria-haspopup": 0,
"aria-level": 0,
"aria-modal": 0,
"aria-multiline": 0,
"aria-multiselectable": 0,
"aria-orientation": 0,
"aria-placeholder": 0,
"aria-pressed": 0,
"aria-readonly": 0,
"aria-required": 0,
"aria-selected": 0,
"aria-sort": 0,
"aria-valuemax": 0,
"aria-valuemin": 0,
"aria-valuenow": 0,
"aria-valuetext": 0,
// Live Region Attributes
"aria-atomic": 0,
"aria-busy": 0,
"aria-live": 0,
"aria-relevant": 0,
// Drag-and-Drop Attributes
"aria-dropeffect": 0,
"aria-grabbed": 0,
// Relationship Attributes
"aria-activedescendant": 0,
"aria-colcount": 0,
"aria-colindex": 0,
"aria-colspan": 0,
"aria-controls": 0,
"aria-describedby": 0,
"aria-errormessage": 0,
"aria-flowto": 0,
"aria-labelledby": 0,
"aria-owns": 0,
"aria-posinset": 0,
"aria-rowcount": 0,
"aria-rowindex": 0,
"aria-rowspan": 0,
"aria-setsize": 0,
};
var warnedProperties = {};
var rARIA = new RegExp("^(aria)-[" + ATTRIBUTE_NAME_CHAR + "]*$");
var rARIACamel = new RegExp("^(aria)[A-Z][" + ATTRIBUTE_NAME_CHAR + "]*$");
var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
function validateProperty(tagName, name) {
{
if (
hasOwnProperty$1.call(warnedProperties, name) &&
warnedProperties[name]
) {
return true;
}
if (rARIACamel.test(name)) {
var ariaName = "aria-" + name.slice(4).toLowerCase();
var correctName = ariaProperties.hasOwnProperty(ariaName)
? ariaName
: null; // If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if (correctName == null) {
error(
"Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.",
name,
);
warnedProperties[name] = true;
return true;
} // aria-* attributes should be lowercase; suggest the lowercase version.
if (name !== correctName) {
error(
"Invalid ARIA attribute `%s`. Did you mean `%s`?",
name,
correctName,
);
warnedProperties[name] = true;
return true;
}
}
if (rARIA.test(name)) {
var lowerCasedName = name.toLowerCase();
var standardName = ariaProperties.hasOwnProperty(lowerCasedName)
? lowerCasedName
: null; // If this is an aria-* attribute, but is not listed in the known DOM
// DOM properties, then it is an invalid aria-* attribute.
if (standardName == null) {
warnedProperties[name] = true;
return false;
} // aria-* attributes should be lowercase; suggest the lowercase version.
if (name !== standardName) {
error(
"Unknown ARIA attribute `%s`. Did you mean `%s`?",
name,
standardName,
);
warnedProperties[name] = true;
return true;
}
}
}
return true;
}
function warnInvalidARIAProps(type, props) {
{
var invalidProps = [];
for (var key in props) {
var isValid = validateProperty(type, key);
if (!isValid) {
invalidProps.push(key);
}
}
var unknownPropString = invalidProps
.map(function (prop) {
return "`" + prop + "`";
})
.join(", ");
if (invalidProps.length === 1) {
error(
"Invalid aria prop %s on <%s> tag. " +
"For details, see https://reactjs.org/link/invalid-aria-props",
unknownPropString,
type,
);
} else if (invalidProps.length > 1) {
error(
"Invalid aria props %s on <%s> tag. " +
"For details, see https://reactjs.org/link/invalid-aria-props",
unknownPropString,
type,
);
}
}
}
function validateProperties(type, props) {
if (isCustomComponent(type, props)) {
return;
}
warnInvalidARIAProps(type, props);
}
var didWarnValueNull = false;
function validateProperties$1(type, props) {
{
if (type !== "input" && type !== "textarea" && type !== "select") {
return;
}
if (props != null && props.value === null && !didWarnValueNull) {
didWarnValueNull = true;
if (type === "select" && props.multiple) {
error(
"`value` prop on `%s` should not be null. " +
"Consider using an empty array when `multiple` is set to `true` " +
"to clear the component or `undefined` for uncontrolled components.",
type,
);
} else {
error(
"`value` prop on `%s` should not be null. " +
"Consider using an empty string to clear the component or `undefined` " +
"for uncontrolled components.",
type,
);
}
}
}
}
var validateProperty$1 = function () {};
{
var warnedProperties$1 = {};
var _hasOwnProperty = Object.prototype.hasOwnProperty;
var EVENT_NAME_REGEX = /^on./;
var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;
var rARIA$1 = new RegExp("^(aria)-[" + ATTRIBUTE_NAME_CHAR + "]*$");
var rARIACamel$1 = new RegExp(
"^(aria)[A-Z][" + ATTRIBUTE_NAME_CHAR + "]*$",
);
validateProperty$1 = function (tagName, name, value, eventRegistry) {
if (
_hasOwnProperty.call(warnedProperties$1, name) &&
warnedProperties$1[name]
) {
return true;
}
var lowerCasedName = name.toLowerCase();
if (lowerCasedName === "onfocusin" || lowerCasedName === "onfocusout") {
error(
"React uses onFocus and onBlur instead of onFocusIn and onFocusOut. " +
"All React events are normalized to bubble, so onFocusIn and onFocusOut " +
"are not needed/supported by React.",
);
warnedProperties$1[name] = true;
return true;
} // We can't rely on the event system being injected on the server.
if (eventRegistry != null) {
var registrationNameDependencies =
eventRegistry.registrationNameDependencies,
possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
if (registrationNameDependencies.hasOwnProperty(name)) {
return true;
}
var registrationName = possibleRegistrationNames.hasOwnProperty(
lowerCasedName,
)
? possibleRegistrationNames[lowerCasedName]
: null;
if (registrationName != null) {
error(
"Invalid event handler property `%s`. Did you mean `%s`?",
name,
registrationName,
);
warnedProperties$1[name] = true;
return true;
}
if (EVENT_NAME_REGEX.test(name)) {
error(
"Unknown event handler property `%s`. It will be ignored.",
name,
);
warnedProperties$1[name] = true;
return true;
}
} else if (EVENT_NAME_REGEX.test(name)) {
// If no event plugins have been injected, we are in a server environment.
// So we can't tell if the event name is correct for sure, but we can filter
// out known bad ones like `onclick`. We can't suggest a specific replacement though.
if (INVALID_EVENT_NAME_REGEX.test(name)) {
error(
"Invalid event handler property `%s`. " +
"React events use the camelCase naming convention, for example `onClick`.",
name,
);
}
warnedProperties$1[name] = true;
return true;
} // Let the ARIA attribute hook validate ARIA attributes
if (rARIA$1.test(name) || rARIACamel$1.test(name)) {
return true;
}
if (lowerCasedName === "innerhtml") {
error(
"Directly setting property `innerHTML` is not permitted. " +
"For more information, lookup documentation on `dangerouslySetInnerHTML`.",
);
warnedProperties$1[name] = true;
return true;
}
if (lowerCasedName === "aria") {
error(
"The `aria` attribute is reserved for future use in React. " +
"Pass individual `aria-` attributes instead.",
);
warnedProperties$1[name] = true;
return true;
}
if (
lowerCasedName === "is" &&
value !== null &&
value !== undefined &&
typeof value !== "string"
) {
error(
"Received a `%s` for a string attribute `is`. If this is expected, cast " +
"the value to a string.",
typeof value,
);
warnedProperties$1[name] = true;
return true;
}
if (typeof value === "number" && isNaN(value)) {
error(
"Received NaN for the `%s` attribute. If this is expected, cast " +
"the value to a string.",
name,
);
warnedProperties$1[name] = true;
return true;
}
var propertyInfo = getPropertyInfo(name);
var isReserved = propertyInfo !== null && propertyInfo.type === RESERVED; // Known attributes should match the casing specified in the property config.
if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
var standardName = possibleStandardNames[lowerCasedName];
if (standardName !== name) {
error(
"Invalid DOM property `%s`. Did you mean `%s`?",
name,
standardName,
);
warnedProperties$1[name] = true;
return true;
}
} else if (!isReserved && name !== lowerCasedName) {
// Unknown attributes should have lowercase casing since that's how they
// will be cased anyway with server rendering.
error(
"React does not recognize the `%s` prop on a DOM element. If you " +
"intentionally want it to appear in the DOM as a custom " +
"attribute, spell it as lowercase `%s` instead. " +
"If you accidentally passed it from a parent component, remove " +
"it from the DOM element.",
name,
lowerCasedName,
);
warnedProperties$1[name] = true;
return true;
}
if (
typeof value === "boolean" &&
shouldRemoveAttributeWithWarning(name, value, propertyInfo, false)
) {
if (value) {
error(
"Received `%s` for a non-boolean attribute `%s`.\n\n" +
"If you want to write it to the DOM, pass a string instead: " +
'%s="%s" or %s={value.toString()}.',
value,
name,
name,
value,
name,
);
} else {
error(
"Received `%s` for a non-boolean attribute `%s`.\n\n" +
"If you want to write it to the DOM, pass a string instead: " +
'%s="%s" or %s={value.toString()}.\n\n' +
"If you used to conditionally omit it with %s={condition && value}, " +
"pass %s={condition ? value : undefined} instead.",
value,
name,
name,
value,
name,
name,
name,
);
}
warnedProperties$1[name] = true;
return true;
} // Now that we've validated casing, do not validate
// data types for reserved props
if (isReserved) {
return true;
} // Warn when a known attribute is a bad type
if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, false)) {
warnedProperties$1[name] = true;
return false;
} // Warn when passing the strings 'false' or 'true' into a boolean prop
if (
(value === "false" || value === "true") &&
propertyInfo !== null &&
propertyInfo.type === BOOLEAN
) {
error(
"Received the string `%s` for the boolean attribute `%s`. " +
"%s " +
"Did you mean %s={%s}?",
value,
name,
value === "false"
? "The browser will interpret it as a truthy value."
: 'Although this works, it will not work as expected if you pass the string "false".',
name,
value,
);
warnedProperties$1[name] = true;
return true;
}
return true;
};
}
var warnUnknownProperties = function (type, props, eventRegistry) {
{
var unknownProps = [];
for (var key in props) {
var isValid = validateProperty$1(type, key, props[key], eventRegistry);
if (!isValid) {
unknownProps.push(key);
}
}
var unknownPropString = unknownProps
.map(function (prop) {
return "`" + prop + "`";
})
.join(", ");
if (unknownProps.length === 1) {
error(
"Invalid value for prop %s on <%s> tag. Either remove it from the element, " +
"or pass a string or number value to keep it in the DOM. " +
"For details, see https://reactjs.org/link/attribute-behavior ",
unknownPropString,
type,
);
} else if (unknownProps.length > 1) {
error(
"Invalid values for props %s on <%s> tag. Either remove them from the element, " +
"or pass a string or number value to keep them in the DOM. " +
"For details, see https://reactjs.org/link/attribute-behavior ",
unknownPropString,
type,
);
}
}
};
function validateProperties$2(type, props, eventRegistry) {
if (isCustomComponent(type, props)) {
return;
}
warnUnknownProperties(type, props, eventRegistry);
}
var IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
var IS_NON_DELEGATED = 1 << 1;
var IS_CAPTURE_PHASE = 1 << 2;
var IS_REPLAYED = 1 << 4;
// set to LEGACY_FB_SUPPORT. LEGACY_FB_SUPPORT only gets set when
// we call willDeferLaterForLegacyFBSupport, thus not bailing out
// will result in endless cycles like an infinite loop.
// We also don't want to defer during event replaying.
var SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS =
IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;
/**
* Gets the target node from a native browser event by accounting for
* inconsistencies in browser DOM APIs.
*
* @param {object} nativeEvent Native browser event.
* @return {DOMEventTarget} Target node.
*/
function getEventTarget(nativeEvent) {
// Fallback to nativeEvent.srcElement for IE9
// https://github.com/facebook/react/issues/12506
var target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
if (target.correspondingUseElement) {
target = target.correspondingUseElement;
} // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
// @see http://www.quirksmode.org/js/events_properties.html
return target.nodeType === TEXT_NODE ? target.parentNode : target;
}
var restoreImpl = null;
var restoreTarget = null;
var restoreQueue = null;
function restoreStateOfTarget(target) {
// We perform this translation at the end of the event loop so that we
// always receive the correct fiber here
var internalInstance = getInstanceFromNode(target);
if (!internalInstance) {
// Unmounted
return;
}
if (!(typeof restoreImpl === "function")) {
{
throw Error(
"setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
if (stateNode) {
var _props = getFiberCurrentPropsFromNode(stateNode);
restoreImpl(internalInstance.stateNode, internalInstance.type, _props);
}
}
function setRestoreImplementation(impl) {
restoreImpl = impl;
}
function enqueueStateRestore(target) {
if (restoreTarget) {
if (restoreQueue) {
restoreQueue.push(target);
} else {
restoreQueue = [target];
}
} else {
restoreTarget = target;
}
}
function needsStateRestore() {
return restoreTarget !== null || restoreQueue !== null;
}
function restoreStateIfNeeded() {
if (!restoreTarget) {
return;
}
var target = restoreTarget;
var queuedTargets = restoreQueue;
restoreTarget = null;
restoreQueue = null;
restoreStateOfTarget(target);
if (queuedTargets) {
for (var i = 0; i < queuedTargets.length; i++) {
restoreStateOfTarget(queuedTargets[i]);
}
}
}
// the renderer. Such as when we're dispatching events or if third party
// libraries need to call batchedUpdates. Eventually, this API will go away when
// everything is batched by default. We'll then have a similar API to opt-out of
// scheduled work and instead do synchronous work.
// Defaults
var batchedUpdatesImpl = function (fn, bookkeeping) {
return fn(bookkeeping);
};
var discreteUpdatesImpl = function (fn, a, b, c, d) {
return fn(a, b, c, d);
};
var flushDiscreteUpdatesImpl = function () {};
var batchedEventUpdatesImpl = batchedUpdatesImpl;
var isInsideEventHandler = false;
var isBatchingEventUpdates = false;
function finishEventHandler() {
// Here we wait until all updates have propagated, which is important
// when using controlled components within layers:
// https://github.com/facebook/react/issues/1698
// Then we restore state of any controlled component.
var controlledComponentsHavePendingUpdates = needsStateRestore();
if (controlledComponentsHavePendingUpdates) {
// If a controlled event was fired, we may need to restore the state of
// the DOM node back to the controlled value. This is necessary when React
// bails out of the update without touching the DOM.
flushDiscreteUpdatesImpl();
restoreStateIfNeeded();
}
}
function batchedUpdates(fn, bookkeeping) {
if (isInsideEventHandler) {
// If we are currently inside another batch, we need to wait until it
// fully completes before restoring state.
return fn(bookkeeping);
}
isInsideEventHandler = true;
try {
return batchedUpdatesImpl(fn, bookkeeping);
} finally {
isInsideEventHandler = false;
finishEventHandler();
}
}
function batchedEventUpdates(fn, a, b) {
if (isBatchingEventUpdates) {
// If we are currently inside another batch, we need to wait until it
// fully completes before restoring state.
return fn(a, b);
}
isBatchingEventUpdates = true;
try {
return batchedEventUpdatesImpl(fn, a, b);
} finally {
isBatchingEventUpdates = false;
finishEventHandler();
}
}
function discreteUpdates(fn, a, b, c, d) {
var prevIsInsideEventHandler = isInsideEventHandler;
isInsideEventHandler = true;
try {
return discreteUpdatesImpl(fn, a, b, c, d);
} finally {
isInsideEventHandler = prevIsInsideEventHandler;
if (!isInsideEventHandler) {
finishEventHandler();
}
}
}
function flushDiscreteUpdatesIfNeeded(timeStamp) {
{
if (!isInsideEventHandler) {
flushDiscreteUpdatesImpl();
}
}
}
function setBatchingImplementation(
_batchedUpdatesImpl,
_discreteUpdatesImpl,
_flushDiscreteUpdatesImpl,
_batchedEventUpdatesImpl,
) {
batchedUpdatesImpl = _batchedUpdatesImpl;
discreteUpdatesImpl = _discreteUpdatesImpl;
flushDiscreteUpdatesImpl = _flushDiscreteUpdatesImpl;
batchedEventUpdatesImpl = _batchedEventUpdatesImpl;
}
function isInteractive(tag) {
return (
tag === "button" ||
tag === "input" ||
tag === "select" ||
tag === "textarea"
);
}
function shouldPreventMouseEvent(name, type, props) {
switch (name) {
case "onClick":
case "onClickCapture":
case "onDoubleClick":
case "onDoubleClickCapture":
case "onMouseDown":
case "onMouseDownCapture":
case "onMouseMove":
case "onMouseMoveCapture":
case "onMouseUp":
case "onMouseUpCapture":
case "onMouseEnter":
return !!(props.disabled && isInteractive(type));
default:
return false;
}
}
/**
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @return {?function} The stored callback.
*/
function getListener(inst, registrationName) {
var stateNode = inst.stateNode;
if (stateNode === null) {
// Work in progress (ex: onload events in incremental mode).
return null;
}
var props = getFiberCurrentPropsFromNode(stateNode);
if (props === null) {
// Work in progress.
return null;
}
var listener = props[registrationName];
if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
return null;
}
if (!(!listener || typeof listener === "function")) {
{
throw Error(
"Expected `" +
registrationName +
"` listener to be a function, instead got a value of `" +
typeof listener +
"` type.",
);
}
}
return listener;
}
var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
if (canUseDOM) {
try {
var options = {}; // $FlowFixMe: Ignore Flow complaining about needing a value
Object.defineProperty(options, "passive", {
get: function () {
passiveBrowserEventsSupported = true;
},
});
window.addEventListener("test", options, options);
window.removeEventListener("test", options, options);
} catch (e) {
passiveBrowserEventsSupported = false;
}
}
function invokeGuardedCallbackProd(name, func, context, a, b, c, d, e, f) {
var funcArgs = Array.prototype.slice.call(arguments, 3);
try {
func.apply(context, funcArgs);
} catch (error) {
this.onError(error);
}
}
var invokeGuardedCallbackImpl = invokeGuardedCallbackProd;
{
// In DEV mode, we swap out invokeGuardedCallback for a special version
// that plays more nicely with the browser's DevTools. The idea is to preserve
// "Pause on exceptions" behavior. Because React wraps all user-provided
// functions in invokeGuardedCallback, and the production version of
// invokeGuardedCallback uses a try-catch, all user exceptions are treated
// like caught exceptions, and the DevTools won't pause unless the developer
// takes the extra step of enabling pause on caught exceptions. This is
// unintuitive, though, because even though React has caught the error, from
// the developer's perspective, the error is uncaught.
//
// To preserve the expected "Pause on exceptions" behavior, we don't use a
// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake
// DOM node, and call the user-provided callback from inside an event handler
// for that fake event. If the callback throws, the error is "captured" using
// a global event handler. But because the error happens in a different
// event loop context, it does not interrupt the normal program flow.
// Effectively, this gives us try-catch behavior without actually using
// try-catch. Neat!
// Check that the browser supports the APIs we need to implement our special
// DEV version of invokeGuardedCallback
if (
typeof window !== "undefined" &&
typeof window.dispatchEvent === "function" &&
typeof document !== "undefined" &&
typeof document.createEvent === "function"
) {
var fakeNode = document.createElement("react");
invokeGuardedCallbackImpl = function invokeGuardedCallbackDev(
name,
func,
context,
a,
b,
c,
d,
e,
f,
) {
// If document doesn't exist we know for sure we will crash in this method
// when we call document.createEvent(). However this can cause confusing
// errors: https://github.com/facebookincubator/create-react-app/issues/3482
// So we preemptively throw with a better message instead.
if (!(typeof document !== "undefined")) {
{
throw Error(
"The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.",
);
}
}
var evt = document.createEvent("Event");
var didCall = false; // Keeps track of whether the user-provided callback threw an error. We
// set this to true at the beginning, then set it to false right after
// calling the function. If the function errors, `didError` will never be
// set to false. This strategy works even if the browser is flaky and
// fails to call our global error handler, because it doesn't rely on
// the error event at all.
var didError = true; // Keeps track of the value of window.event so that we can reset it
// during the callback to let user code access window.event in the
// browsers that support it.
var windowEvent = window.event; // Keeps track of the descriptor of window.event to restore it after event
// dispatching: https://github.com/facebook/react/issues/13688
var windowEventDescriptor = Object.getOwnPropertyDescriptor(
window,
"event",
);
function restoreAfterDispatch() {
// We immediately remove the callback from event listeners so that
// nested `invokeGuardedCallback` calls do not clash. Otherwise, a
// nested call would trigger the fake event handlers of any call higher
// in the stack.
fakeNode.removeEventListener(evtType, callCallback, false); // We check for window.hasOwnProperty('event') to prevent the
// window.event assignment in both IE <= 10 as they throw an error
// "Member not found" in strict mode, and in Firefox which does not
// support window.event.
if (
typeof window.event !== "undefined" &&
window.hasOwnProperty("event")
) {
window.event = windowEvent;
}
} // Create an event handler for our fake event. We will synchronously
// dispatch our fake event using `dispatchEvent`. Inside the handler, we
// call the user-provided callback.
var funcArgs = Array.prototype.slice.call(arguments, 3);
function callCallback() {
didCall = true;
restoreAfterDispatch();
func.apply(context, funcArgs);
didError = false;
} // Create a global error event handler. We use this to capture the value
// that was thrown. It's possible that this error handler will fire more
// than once; for example, if non-React code also calls `dispatchEvent`
// and a handler for that event throws. We should be resilient to most of
// those cases. Even if our error event handler fires more than once, the
// last error event is always used. If the callback actually does error,
// we know that the last error event is the correct one, because it's not
// possible for anything else to have happened in between our callback
// erroring and the code that follows the `dispatchEvent` call below. If
// the callback doesn't error, but the error event was fired, we know to
// ignore it because `didError` will be false, as described above.
var error; // Use this to track whether the error event is ever called.
var didSetError = false;
var isCrossOriginError = false;
function handleWindowError(event) {
error = event.error;
didSetError = true;
if (error === null && event.colno === 0 && event.lineno === 0) {
isCrossOriginError = true;
}
if (event.defaultPrevented) {
// Some other error handler has prevented default.
// Browsers silence the error report if this happens.
// We'll remember this to later decide whether to log it or not.
if (error != null && typeof error === "object") {
try {
error._suppressLogging = true;
} catch (inner) {
// Ignore.
}
}
}
} // Create a fake event type.
var evtType = "react-" + (name ? name : "invokeguardedcallback"); // Attach our event handlers
window.addEventListener("error", handleWindowError);
fakeNode.addEventListener(evtType, callCallback, false); // Synchronously dispatch our fake event. If the user-provided function
// errors, it will trigger our global error handler.
evt.initEvent(evtType, false, false);
fakeNode.dispatchEvent(evt);
if (windowEventDescriptor) {
Object.defineProperty(window, "event", windowEventDescriptor);
}
if (didCall && didError) {
if (!didSetError) {
// The callback errored, but the error event never fired.
error = new Error(
"An error was thrown inside one of your components, but React " +
"doesn't know what it was. This is likely due to browser " +
'flakiness. React does its best to preserve the "Pause on ' +
'exceptions" behavior of the DevTools, which requires some ' +
"DEV-mode only tricks. It's possible that these don't work in " +
"your browser. Try triggering the error in production mode, " +
"or switching to a modern browser. If you suspect that this is " +
"actually an issue with React, please file an issue.",
);
} else if (isCrossOriginError) {
error = new Error(
"A cross-origin error was thrown. React doesn't have access to " +
"the actual error object in development. " +
"See https://reactjs.org/link/crossorigin-error for more information.",
);
}
this.onError(error);
} // Remove our event listeners
window.removeEventListener("error", handleWindowError);
if (!didCall) {
// Something went really wrong, and our event was not dispatched.
// https://github.com/facebook/react/issues/16734
// https://github.com/facebook/react/issues/16585
// Fall back to the production implementation.
restoreAfterDispatch();
return invokeGuardedCallbackProd.apply(this, arguments);
}
};
}
}
var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
var hasError = false;
var caughtError = null; // Used by event system to capture/rethrow the first error.
var hasRethrowError = false;
var rethrowError = null;
var reporter = {
onError: function (error) {
hasError = true;
caughtError = error;
},
};
/**
* Call a function while guarding against errors that happens within it.
* Returns an error if it throws, otherwise null.
*
* In production, this is implemented using a try-catch. The reason we don't
* use a try-catch directly is so that we can swap out a different
* implementation in DEV mode.
*
* @param {String} name of the guard to use for logging or debugging
* @param {Function} func The function to invoke
* @param {*} context The context to use when calling the function
* @param {...*} args Arguments for function
*/
function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
hasError = false;
caughtError = null;
invokeGuardedCallbackImpl$1.apply(reporter, arguments);
}
/**
* Same as invokeGuardedCallback, but instead of returning an error, it stores
* it in a global so it can be rethrown by `rethrowCaughtError` later.
* TODO: See if caughtError and rethrowError can be unified.
*
* @param {String} name of the guard to use for logging or debugging
* @param {Function} func The function to invoke
* @param {*} context The context to use when calling the function
* @param {...*} args Arguments for function
*/
function invokeGuardedCallbackAndCatchFirstError(
name,
func,
context,
a,
b,
c,
d,
e,
f,
) {
invokeGuardedCallback.apply(this, arguments);
if (hasError) {
var error = clearCaughtError();
if (!hasRethrowError) {
hasRethrowError = true;
rethrowError = error;
}
}
}
/**
* During execution of guarded functions we will capture the first error which
* we will rethrow to be handled by the top level error handler.
*/
function rethrowCaughtError() {
if (hasRethrowError) {
var error = rethrowError;
hasRethrowError = false;
rethrowError = null;
throw error;
}
}
function hasCaughtError() {
return hasError;
}
function clearCaughtError() {
if (hasError) {
var error = caughtError;
hasError = false;
caughtError = null;
return error;
} else {
{
{
throw Error(
"clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
}
var ReactInternals$1 =
React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
var _ReactInternals$Sched = ReactInternals$1.Scheduler,
unstable_cancelCallback = _ReactInternals$Sched.unstable_cancelCallback,
unstable_now = _ReactInternals$Sched.unstable_now,
unstable_scheduleCallback = _ReactInternals$Sched.unstable_scheduleCallback,
unstable_shouldYield = _ReactInternals$Sched.unstable_shouldYield,
unstable_requestPaint = _ReactInternals$Sched.unstable_requestPaint,
unstable_getFirstCallbackNode =
_ReactInternals$Sched.unstable_getFirstCallbackNode,
unstable_runWithPriority = _ReactInternals$Sched.unstable_runWithPriority,
unstable_next = _ReactInternals$Sched.unstable_next,
unstable_continueExecution =
_ReactInternals$Sched.unstable_continueExecution,
unstable_pauseExecution = _ReactInternals$Sched.unstable_pauseExecution,
unstable_getCurrentPriorityLevel =
_ReactInternals$Sched.unstable_getCurrentPriorityLevel,
unstable_ImmediatePriority =
_ReactInternals$Sched.unstable_ImmediatePriority,
unstable_UserBlockingPriority =
_ReactInternals$Sched.unstable_UserBlockingPriority,
unstable_NormalPriority = _ReactInternals$Sched.unstable_NormalPriority,
unstable_LowPriority = _ReactInternals$Sched.unstable_LowPriority,
unstable_IdlePriority = _ReactInternals$Sched.unstable_IdlePriority,
unstable_forceFrameRate = _ReactInternals$Sched.unstable_forceFrameRate,
unstable_flushAllWithoutAsserting =
_ReactInternals$Sched.unstable_flushAllWithoutAsserting;
/**
* `ReactInstanceMap` maintains a mapping from a public facing stateful
* instance (key) and the internal representation (value). This allows public
* methods to accept the user facing instance as an argument and map them back
* to internal methods.
*
* Note that this module is currently shared and assumed to be stateless.
* If this becomes an actual Map, that will break.
*/
function get(key) {
return key._reactInternals;
}
function has(key) {
return key._reactInternals !== undefined;
}
function set(key, value) {
key._reactInternals = value;
}
// Don't change these two values. They're used by React Dev Tools.
var NoFlags =
/* */
0;
var PerformedWork =
/* */
1; // You can change the rest (and add more).
var Placement =
/* */
2;
var Update =
/* */
4;
var PlacementAndUpdate =
/* */
6;
var Deletion =
/* */
8;
var ContentReset =
/* */
16;
var Callback =
/* */
32;
var DidCapture =
/* */
64;
var Ref =
/* */
128;
var Snapshot =
/* */
256;
var Passive =
/* */
512; // TODO (effects) Remove this bit once the new reconciler is synced to the old.
var PassiveUnmountPendingDev =
/* */
8192;
var Hydrating =
/* */
1024;
var HydratingAndUpdate =
/* */
1028; // Passive & Update & Callback & Ref & Snapshot
var LifecycleEffectMask =
/* */
932; // Union of all host effects
var HostEffectMask =
/* */
2047; // These are not really side effects, but we still reuse this field.
var Incomplete =
/* */
2048;
var ShouldCapture =
/* */
4096;
var ForceUpdateForLegacySuspense =
/* */
16384; // Static tags describe aspects of a fiber that are not specific to a render,
var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
function getNearestMountedFiber(fiber) {
var node = fiber;
var nearestMounted = fiber;
if (!fiber.alternate) {
// If there is no alternate, this might be a new tree that isn't inserted
// yet. If it is, then it will have a pending insertion effect on it.
var nextNode = node;
do {
node = nextNode;
if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
// This is an insertion or in-progress hydration. The nearest possible
// mounted fiber is the parent but we need to continue to figure out
// if that one is still mounted.
nearestMounted = node.return;
}
nextNode = node.return;
} while (nextNode);
} else {
while (node.return) {
node = node.return;
}
}
if (node.tag === HostRoot) {
// TODO: Check if this was a nested HostRoot when used with
// renderContainerIntoSubtree.
return nearestMounted;
} // If we didn't hit the root, that means that we're in an disconnected tree
// that has been unmounted.
return null;
}
function getSuspenseInstanceFromFiber(fiber) {
if (fiber.tag === SuspenseComponent) {
var suspenseState = fiber.memoizedState;
if (suspenseState === null) {
var current = fiber.alternate;
if (current !== null) {
suspenseState = current.memoizedState;
}
}
if (suspenseState !== null) {
return suspenseState.dehydrated;
}
}
return null;
}
function getContainerFromFiber(fiber) {
return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;
}
function isFiberMounted(fiber) {
return getNearestMountedFiber(fiber) === fiber;
}
function isMounted(component) {
{
var owner = ReactCurrentOwner.current;
if (owner !== null && owner.tag === ClassComponent) {
var ownerFiber = owner;
var instance = ownerFiber.stateNode;
if (!instance._warnedAboutRefsInRender) {
error(
"%s is accessing isMounted inside its render() function. " +
"render() should be a pure function of props and state. It should " +
"never access something that requires stale data from the previous " +
"render, such as refs. Move this logic to componentDidMount and " +
"componentDidUpdate instead.",
getComponentName(ownerFiber.type) || "A component",
);
}
instance._warnedAboutRefsInRender = true;
}
}
var fiber = get(component);
if (!fiber) {
return false;
}
return getNearestMountedFiber(fiber) === fiber;
}
function assertIsMounted(fiber) {
if (!(getNearestMountedFiber(fiber) === fiber)) {
{
throw Error("Unable to find node on an unmounted component.");
}
}
}
function findCurrentFiberUsingSlowPath(fiber) {
var alternate = fiber.alternate;
if (!alternate) {
// If there is no alternate, then we only need to check if it is mounted.
var nearestMounted = getNearestMountedFiber(fiber);
if (!(nearestMounted !== null)) {
{
throw Error("Unable to find node on an unmounted component.");
}
}
if (nearestMounted !== fiber) {
return null;
}
return fiber;
} // If we have two possible branches, we'll walk backwards up to the root
// to see what path the root points to. On the way we may hit one of the
// special cases and we'll deal with them.
var a = fiber;
var b = alternate;
while (true) {
var parentA = a.return;
if (parentA === null) {
// We're at the root.
break;
}
var parentB = parentA.alternate;
if (parentB === null) {
// There is no alternate. This is an unusual case. Currently, it only
// happens when a Suspense component is hidden. An extra fragment fiber
// is inserted in between the Suspense fiber and its children. Skip
// over this extra fragment fiber and proceed to the next parent.
var nextParent = parentA.return;
if (nextParent !== null) {
a = b = nextParent;
continue;
} // If there's no parent, we're at the root.
break;
} // If both copies of the parent fiber point to the same child, we can
// assume that the child is current. This happens when we bailout on low
// priority: the bailed out fiber's child reuses the current child.
if (parentA.child === parentB.child) {
var child = parentA.child;
while (child) {
if (child === a) {
// We've determined that A is the current branch.
assertIsMounted(parentA);
return fiber;
}
if (child === b) {
// We've determined that B is the current branch.
assertIsMounted(parentA);
return alternate;
}
child = child.sibling;
} // We should never have an alternate for any mounting node. So the only
// way this could possibly happen is if this was unmounted, if at all.
{
{
throw Error("Unable to find node on an unmounted component.");
}
}
}
if (a.return !== b.return) {
// The return pointer of A and the return pointer of B point to different
// fibers. We assume that return pointers never criss-cross, so A must
// belong to the child set of A.return, and B must belong to the child
// set of B.return.
a = parentA;
b = parentB;
} else {
// The return pointers point to the same fiber. We'll have to use the
// default, slow path: scan the child sets of each parent alternate to see
// which child belongs to which set.
//
// Search parent A's child set
var didFindChild = false;
var _child = parentA.child;
while (_child) {
if (_child === a) {
didFindChild = true;
a = parentA;
b = parentB;
break;
}
if (_child === b) {
didFindChild = true;
b = parentA;
a = parentB;
break;
}
_child = _child.sibling;
}
if (!didFindChild) {
// Search parent B's child set
_child = parentB.child;
while (_child) {
if (_child === a) {
didFindChild = true;
a = parentB;
b = parentA;
break;
}
if (_child === b) {
didFindChild = true;
b = parentB;
a = parentA;
break;
}
_child = _child.sibling;
}
if (!didFindChild) {
{
throw Error(
"Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.",
);
}
}
}
}
if (!(a.alternate === b)) {
{
throw Error(
"Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
} // If the root is not a host container, we're in a disconnected tree. I.e.
// unmounted.
if (!(a.tag === HostRoot)) {
{
throw Error("Unable to find node on an unmounted component.");
}
}
if (a.stateNode.current === a) {
// We've determined that A is the current branch.
return fiber;
} // Otherwise B has to be current branch.
return alternate;
}
function findCurrentHostFiber(parent) {
var currentParent = findCurrentFiberUsingSlowPath(parent);
if (!currentParent) {
return null;
} // Next we'll drill down this component to find the first HostComponent/Text.
var node = currentParent;
while (true) {
if (node.tag === HostComponent || node.tag === HostText) {
return node;
} else if (node.child) {
node.child.return = node;
node = node.child;
continue;
}
if (node === currentParent) {
return null;
}
while (!node.sibling) {
if (!node.return || node.return === currentParent) {
return null;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
} // Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
return null;
}
function findCurrentHostFiberWithNoPortals(parent) {
var currentParent = findCurrentFiberUsingSlowPath(parent);
if (!currentParent) {
return null;
} // Next we'll drill down this component to find the first HostComponent/Text.
var node = currentParent;
while (true) {
if (
node.tag === HostComponent ||
node.tag === HostText ||
enableFundamentalAPI
) {
return node;
} else if (node.child && node.tag !== HostPortal) {
node.child.return = node;
node = node.child;
continue;
}
if (node === currentParent) {
return null;
}
while (!node.sibling) {
if (!node.return || node.return === currentParent) {
return null;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
} // Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
return null;
}
function doesFiberContain(parentFiber, childFiber) {
var node = childFiber;
var parentFiberAlternate = parentFiber.alternate;
while (node !== null) {
if (node === parentFiber || node === parentFiberAlternate) {
return true;
}
node = node.return;
}
return false;
}
var attemptUserBlockingHydration;
function setAttemptUserBlockingHydration(fn) {
attemptUserBlockingHydration = fn;
}
var attemptContinuousHydration;
function setAttemptContinuousHydration(fn) {
attemptContinuousHydration = fn;
}
var attemptHydrationAtCurrentPriority;
function setAttemptHydrationAtCurrentPriority(fn) {
attemptHydrationAtCurrentPriority = fn;
}
var attemptHydrationAtPriority;
function setAttemptHydrationAtPriority(fn) {
attemptHydrationAtPriority = fn;
} // TODO: Upgrade this definition once we're on a newer version of Flow that
var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
// if the last target was dehydrated.
var queuedFocus = null;
var queuedDrag = null;
var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
var queuedPointers = new Map();
var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
var queuedExplicitHydrationTargets = [];
function hasQueuedDiscreteEvents() {
return queuedDiscreteEvents.length > 0;
}
var discreteReplayableEvents = [
"mousedown",
"mouseup",
"touchcancel",
"touchend",
"touchstart",
"auxclick",
"dblclick",
"pointercancel",
"pointerdown",
"pointerup",
"dragend",
"dragstart",
"drop",
"compositionend",
"compositionstart",
"keydown",
"keypress",
"keyup",
"input",
"textInput", // Intentionally camelCase
"copy",
"cut",
"paste",
"click",
"change",
"contextmenu",
"reset",
"submit",
];
function isReplayableDiscreteEvent(eventType) {
return discreteReplayableEvents.indexOf(eventType) > -1;
}
function createQueuedReplayableEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
return {
blockedOn: blockedOn,
domEventName: domEventName,
eventSystemFlags: eventSystemFlags | IS_REPLAYED,
nativeEvent: nativeEvent,
targetContainers: [targetContainer],
};
}
function queueDiscreteEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
var queuedEvent = createQueuedReplayableEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
);
queuedDiscreteEvents.push(queuedEvent);
} // Resets the replaying for this type of continuous event to no event.
function clearIfContinuousEvent(domEventName, nativeEvent) {
switch (domEventName) {
case "focusin":
case "focusout":
queuedFocus = null;
break;
case "dragenter":
case "dragleave":
queuedDrag = null;
break;
case "mouseover":
case "mouseout":
queuedMouse = null;
break;
case "pointerover":
case "pointerout": {
var pointerId = nativeEvent.pointerId;
queuedPointers.delete(pointerId);
break;
}
case "gotpointercapture":
case "lostpointercapture": {
var _pointerId = nativeEvent.pointerId;
queuedPointerCaptures.delete(_pointerId);
break;
}
}
}
function accumulateOrCreateContinuousQueuedReplayableEvent(
existingQueuedEvent,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
if (
existingQueuedEvent === null ||
existingQueuedEvent.nativeEvent !== nativeEvent
) {
var queuedEvent = createQueuedReplayableEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
);
if (blockedOn !== null) {
var _fiber2 = getInstanceFromNode(blockedOn);
if (_fiber2 !== null) {
// Attempt to increase the priority of this target.
attemptContinuousHydration(_fiber2);
}
}
return queuedEvent;
} // If we have already queued this exact event, then it's because
// the different event systems have different DOM event listeners.
// We can accumulate the flags, and the targetContainers, and
// store a single event to be replayed.
existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
var targetContainers = existingQueuedEvent.targetContainers;
if (
targetContainer !== null &&
targetContainers.indexOf(targetContainer) === -1
) {
targetContainers.push(targetContainer);
}
return existingQueuedEvent;
}
function queueIfContinuousEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
// These set relatedTarget to null because the replayed event will be treated as if we
// moved from outside the window (no target) onto the target once it hydrates.
// Instead of mutating we could clone the event.
switch (domEventName) {
case "focusin": {
var focusEvent = nativeEvent;
queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
queuedFocus,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
focusEvent,
);
return true;
}
case "dragenter": {
var dragEvent = nativeEvent;
queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
queuedDrag,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
dragEvent,
);
return true;
}
case "mouseover": {
var mouseEvent = nativeEvent;
queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
queuedMouse,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
mouseEvent,
);
return true;
}
case "pointerover": {
var pointerEvent = nativeEvent;
var pointerId = pointerEvent.pointerId;
queuedPointers.set(
pointerId,
accumulateOrCreateContinuousQueuedReplayableEvent(
queuedPointers.get(pointerId) || null,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
pointerEvent,
),
);
return true;
}
case "gotpointercapture": {
var _pointerEvent = nativeEvent;
var _pointerId2 = _pointerEvent.pointerId;
queuedPointerCaptures.set(
_pointerId2,
accumulateOrCreateContinuousQueuedReplayableEvent(
queuedPointerCaptures.get(_pointerId2) || null,
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
_pointerEvent,
),
);
return true;
}
}
return false;
} // Check if this target is unblocked. Returns true if it's unblocked.
function attemptExplicitHydrationTarget(queuedTarget) {
// TODO: This function shares a lot of logic with attemptToDispatchEvent.
// Try to unify them. It's a bit tricky since it would require two return
// values.
var targetInst = getClosestInstanceFromNode(queuedTarget.target);
if (targetInst !== null) {
var nearestMounted = getNearestMountedFiber(targetInst);
if (nearestMounted !== null) {
var tag = nearestMounted.tag;
if (tag === SuspenseComponent) {
var instance = getSuspenseInstanceFromFiber(nearestMounted);
if (instance !== null) {
// We're blocked on hydrating this boundary.
// Increase its priority.
queuedTarget.blockedOn = instance;
attemptHydrationAtPriority(queuedTarget.lanePriority, function () {
unstable_runWithPriority(queuedTarget.priority, function () {
attemptHydrationAtCurrentPriority(nearestMounted);
});
});
return;
}
} else if (tag === HostRoot) {
var root = nearestMounted.stateNode;
if (root.hydrate) {
queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
// a root other than sync.
return;
}
}
}
}
queuedTarget.blockedOn = null;
}
function attemptReplayContinuousQueuedEvent(queuedEvent) {
if (queuedEvent.blockedOn !== null) {
return false;
}
var targetContainers = queuedEvent.targetContainers;
while (targetContainers.length > 0) {
var targetContainer = targetContainers[0];
var nextBlockedOn = attemptToDispatchEvent(
queuedEvent.domEventName,
queuedEvent.eventSystemFlags,
targetContainer,
queuedEvent.nativeEvent,
);
if (nextBlockedOn !== null) {
// We're still blocked. Try again later.
var _fiber3 = getInstanceFromNode(nextBlockedOn);
if (_fiber3 !== null) {
attemptContinuousHydration(_fiber3);
}
queuedEvent.blockedOn = nextBlockedOn;
return false;
} // This target container was successfully dispatched. Try the next.
targetContainers.shift();
}
return true;
}
function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
map.delete(key);
}
}
function replayUnblockedEvents() {
hasScheduledReplayAttempt = false; // First replay discrete events.
while (queuedDiscreteEvents.length > 0) {
var nextDiscreteEvent = queuedDiscreteEvents[0];
if (nextDiscreteEvent.blockedOn !== null) {
// We're still blocked.
// Increase the priority of this boundary to unblock
// the next discrete event.
var _fiber4 = getInstanceFromNode(nextDiscreteEvent.blockedOn);
if (_fiber4 !== null) {
attemptUserBlockingHydration(_fiber4);
}
break;
}
var targetContainers = nextDiscreteEvent.targetContainers;
while (targetContainers.length > 0) {
var targetContainer = targetContainers[0];
var nextBlockedOn = attemptToDispatchEvent(
nextDiscreteEvent.domEventName,
nextDiscreteEvent.eventSystemFlags,
targetContainer,
nextDiscreteEvent.nativeEvent,
);
if (nextBlockedOn !== null) {
// We're still blocked. Try again later.
nextDiscreteEvent.blockedOn = nextBlockedOn;
break;
} // This target container was successfully dispatched. Try the next.
targetContainers.shift();
}
if (nextDiscreteEvent.blockedOn === null) {
// We've successfully replayed the first event. Let's try the next one.
queuedDiscreteEvents.shift();
}
} // Next replay any continuous events.
if (
queuedFocus !== null &&
attemptReplayContinuousQueuedEvent(queuedFocus)
) {
queuedFocus = null;
}
if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
queuedDrag = null;
}
if (
queuedMouse !== null &&
attemptReplayContinuousQueuedEvent(queuedMouse)
) {
queuedMouse = null;
}
queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
}
function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
if (queuedEvent.blockedOn === unblocked) {
queuedEvent.blockedOn = null;
if (!hasScheduledReplayAttempt) {
hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
// now unblocked. This first might not actually be unblocked yet.
// We could check it early to avoid scheduling an unnecessary callback.
unstable_scheduleCallback(
unstable_NormalPriority,
replayUnblockedEvents,
);
}
}
}
function retryIfBlockedOn(unblocked) {
// Mark anything that was blocked on this as no longer blocked
// and eligible for a replay.
if (queuedDiscreteEvents.length > 0) {
scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
// worth it because we expect very few discrete events to queue up and once
// we are actually fully unblocked it will be fast to replay them.
for (var i = 1; i < queuedDiscreteEvents.length; i++) {
var queuedEvent = queuedDiscreteEvents[i];
if (queuedEvent.blockedOn === unblocked) {
queuedEvent.blockedOn = null;
}
}
}
if (queuedFocus !== null) {
scheduleCallbackIfUnblocked(queuedFocus, unblocked);
}
if (queuedDrag !== null) {
scheduleCallbackIfUnblocked(queuedDrag, unblocked);
}
if (queuedMouse !== null) {
scheduleCallbackIfUnblocked(queuedMouse, unblocked);
}
var unblock = function (queuedEvent) {
return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
};
queuedPointers.forEach(unblock);
queuedPointerCaptures.forEach(unblock);
for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
var queuedTarget = queuedExplicitHydrationTargets[_i];
if (queuedTarget.blockedOn === unblocked) {
queuedTarget.blockedOn = null;
}
}
while (queuedExplicitHydrationTargets.length > 0) {
var nextExplicitTarget = queuedExplicitHydrationTargets[0];
if (nextExplicitTarget.blockedOn !== null) {
// We're still blocked.
break;
} else {
attemptExplicitHydrationTarget(nextExplicitTarget);
if (nextExplicitTarget.blockedOn === null) {
// We're unblocked.
queuedExplicitHydrationTargets.shift();
}
}
}
}
var DiscreteEvent = 0;
var UserBlockingEvent = 1;
var ContinuousEvent = 2;
/**
* Generate a mapping of standard vendor prefixes using the defined style property and event name.
*
* @param {string} styleProp
* @param {string} eventName
* @returns {object}
*/
function makePrefixMap(styleProp, eventName) {
var prefixes = {};
prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
prefixes["Webkit" + styleProp] = "webkit" + eventName;
prefixes["Moz" + styleProp] = "moz" + eventName;
return prefixes;
}
/**
* A list of event names to a configurable list of vendor prefixes.
*/
var vendorPrefixes = {
animationend: makePrefixMap("Animation", "AnimationEnd"),
animationiteration: makePrefixMap("Animation", "AnimationIteration"),
animationstart: makePrefixMap("Animation", "AnimationStart"),
transitionend: makePrefixMap("Transition", "TransitionEnd"),
};
/**
* Event names that have already been detected and prefixed (if applicable).
*/
var prefixedEventNames = {};
/**
* Element to check for prefixes on.
*/
var style = {};
/**
* Bootstrap if a DOM exists.
*/
if (canUseDOM) {
style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
// the un-prefixed "animation" and "transition" properties are defined on the
// style object but the events that fire will still be prefixed, so we need
// to check if the un-prefixed events are usable, and if not remove them from the map.
if (!("AnimationEvent" in window)) {
delete vendorPrefixes.animationend.animation;
delete vendorPrefixes.animationiteration.animation;
delete vendorPrefixes.animationstart.animation;
} // Same as above
if (!("TransitionEvent" in window)) {
delete vendorPrefixes.transitionend.transition;
}
}
/**
* Attempts to determine the correct vendor prefixed event name.
*
* @param {string} eventName
* @returns {string}
*/
function getVendorPrefixedEventName(eventName) {
if (prefixedEventNames[eventName]) {
return prefixedEventNames[eventName];
} else if (!vendorPrefixes[eventName]) {
return eventName;
}
var prefixMap = vendorPrefixes[eventName];
for (var styleProp in prefixMap) {
if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
return (prefixedEventNames[eventName] = prefixMap[styleProp]);
}
}
return eventName;
}
var ANIMATION_END = getVendorPrefixedEventName("animationend");
var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
var ANIMATION_START = getVendorPrefixedEventName("animationstart");
var TRANSITION_END = getVendorPrefixedEventName("transitionend");
var topLevelEventsToReactNames = new Map();
var eventPriorities = new Map(); // We store most of the events in this module in pairs of two strings so we can re-use
// the code required to apply the same logic for event prioritization and that of the
// SimpleEventPlugin. This complicates things slightly, but the aim is to reduce code
// duplication (for which there would be quite a bit). For the events that are not needed
// for the SimpleEventPlugin (otherDiscreteEvents) we process them separately as an
// array of top level events.
// Lastly, we ignore prettier so we can keep the formatting sane.
// prettier-ignore
var discreteEventPairsForSimpleEventPlugin = ['cancel', 'cancel', 'click', 'click', 'close', 'close', 'contextmenu', 'contextMenu', 'copy', 'copy', 'cut', 'cut', 'auxclick', 'auxClick', 'dblclick', 'doubleClick', // Careful!
'dragend', 'dragEnd', 'dragstart', 'dragStart', 'drop', 'drop', 'focusin', 'focus', // Careful!
'focusout', 'blur', // Careful!
'input', 'input', 'invalid', 'invalid', 'keydown', 'keyDown', 'keypress', 'keyPress', 'keyup', 'keyUp', 'mousedown', 'mouseDown', 'mouseup', 'mouseUp', 'paste', 'paste', 'pause', 'pause', 'play', 'play', 'pointercancel', 'pointerCancel', 'pointerdown', 'pointerDown', 'pointerup', 'pointerUp', 'ratechange', 'rateChange', 'reset', 'reset', 'seeked', 'seeked', 'submit', 'submit', 'touchcancel', 'touchCancel', 'touchend', 'touchEnd', 'touchstart', 'touchStart', 'volumechange', 'volumeChange'];
var otherDiscreteEvents = [
"change",
"selectionchange",
"textInput",
"compositionstart",
"compositionend",
"compositionupdate",
];
var userBlockingPairsForSimpleEventPlugin = ['drag', 'drag', 'dragenter', 'dragEnter', 'dragexit', 'dragExit', 'dragleave', 'dragLeave', 'dragover', 'dragOver', 'mousemove', 'mouseMove', 'mouseout', 'mouseOut', 'mouseover', 'mouseOver', 'pointermove', 'pointerMove', 'pointerout', 'pointerOut', 'pointerover', 'pointerOver', 'scroll', 'scroll', 'toggle', 'toggle', 'touchmove', 'touchMove', 'wheel', 'wheel']; // prettier-ignore
var continuousPairsForSimpleEventPlugin = [
"abort",
"abort",
ANIMATION_END,
"animationEnd",
ANIMATION_ITERATION,
"animationIteration",
ANIMATION_START,
"animationStart",
"canplay",
"canPlay",
"canplaythrough",
"canPlayThrough",
"durationchange",
"durationChange",
"emptied",
"emptied",
"encrypted",
"encrypted",
"ended",
"ended",
"error",
"error",
"gotpointercapture",
"gotPointerCapture",
"load",
"load",
"loadeddata",
"loadedData",
"loadedmetadata",
"loadedMetadata",
"loadstart",
"loadStart",
"lostpointercapture",
"lostPointerCapture",
"playing",
"playing",
"progress",
"progress",
"seeking",
"seeking",
"stalled",
"stalled",
"suspend",
"suspend",
"timeupdate",
"timeUpdate",
TRANSITION_END,
"transitionEnd",
"waiting",
"waiting",
];
/**
* Turns
* ['abort', ...]
*
* into
*
* topLevelEventsToReactNames = new Map([
* ['abort', 'onAbort'],
* ]);
*
* and registers them.
*/
function registerSimplePluginEventsAndSetTheirPriorities(
eventTypes,
priority,
) {
// As the event types are in pairs of two, we need to iterate
// through in twos. The events are in pairs of two to save code
// and improve init perf of processing this array, as it will
// result in far fewer object allocations and property accesses
// if we only use three arrays to process all the categories of
// instead of tuples.
for (var i = 0; i < eventTypes.length; i += 2) {
var topEvent = eventTypes[i];
var event = eventTypes[i + 1];
var capitalizedEvent = event[0].toUpperCase() + event.slice(1);
var reactName = "on" + capitalizedEvent;
eventPriorities.set(topEvent, priority);
topLevelEventsToReactNames.set(topEvent, reactName);
registerTwoPhaseEvent(reactName, [topEvent]);
}
}
function setEventPriorities(eventTypes, priority) {
for (var i = 0; i < eventTypes.length; i++) {
eventPriorities.set(eventTypes[i], priority);
}
}
function getEventPriorityForPluginSystem(domEventName) {
var priority = eventPriorities.get(domEventName); // Default to a ContinuousEvent. Note: we might
// want to warn if we can't detect the priority
// for the event.
return priority === undefined ? ContinuousEvent : priority;
}
function registerSimpleEvents() {
registerSimplePluginEventsAndSetTheirPriorities(
discreteEventPairsForSimpleEventPlugin,
DiscreteEvent,
);
registerSimplePluginEventsAndSetTheirPriorities(
userBlockingPairsForSimpleEventPlugin,
UserBlockingEvent,
);
registerSimplePluginEventsAndSetTheirPriorities(
continuousPairsForSimpleEventPlugin,
ContinuousEvent,
);
setEventPriorities(otherDiscreteEvents, DiscreteEvent);
}
var ReactInternals$2 =
React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
var _ReactInternals$Sched$1 = ReactInternals$2.SchedulerTracing,
__interactionsRef = _ReactInternals$Sched$1.__interactionsRef,
__subscriberRef = _ReactInternals$Sched$1.__subscriberRef,
unstable_clear = _ReactInternals$Sched$1.unstable_clear,
unstable_getCurrent = _ReactInternals$Sched$1.unstable_getCurrent,
unstable_getThreadID = _ReactInternals$Sched$1.unstable_getThreadID,
unstable_subscribe = _ReactInternals$Sched$1.unstable_subscribe,
unstable_trace = _ReactInternals$Sched$1.unstable_trace,
unstable_unsubscribe = _ReactInternals$Sched$1.unstable_unsubscribe,
unstable_wrap = _ReactInternals$Sched$1.unstable_wrap;
var Scheduler_now = unstable_now;
{
// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if (!(__interactionsRef != null && __interactionsRef.current != null)) {
{
throw Error(
"It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling",
);
}
}
}
// ascending numbers so we can compare them like numbers. They start at 90 to
// avoid clashing with Scheduler's priorities.
var ImmediatePriority = 99;
var UserBlockingPriority = 98;
var NormalPriority = 97;
var LowPriority = 96;
var IdlePriority = 95; // NoPriority is the absence of priority. Also React-only.
var NoPriority = 90;
var initialTimeMs = Scheduler_now(); // If the initial timestamp is reasonably small, use Scheduler's `now` directly.
var SyncLanePriority = 15;
var SyncBatchedLanePriority = 14;
var InputDiscreteHydrationLanePriority = 13;
var InputDiscreteLanePriority = 12;
var InputContinuousHydrationLanePriority = 11;
var InputContinuousLanePriority = 10;
var DefaultHydrationLanePriority = 9;
var DefaultLanePriority = 8;
var TransitionHydrationPriority = 7;
var TransitionPriority = 6;
var RetryLanePriority = 5;
var SelectiveHydrationLanePriority = 4;
var IdleHydrationLanePriority = 3;
var IdleLanePriority = 2;
var OffscreenLanePriority = 1;
var NoLanePriority = 0;
var TotalLanes = 31;
var NoLanes =
/* */
0;
var NoLane =
/* */
0;
var SyncLane =
/* */
1;
var SyncBatchedLane =
/* */
2;
var InputDiscreteHydrationLane =
/* */
4;
var InputDiscreteLanes =
/* */
24;
var InputContinuousHydrationLane =
/* */
32;
var InputContinuousLanes =
/* */
192;
var DefaultHydrationLane =
/* */
256;
var DefaultLanes =
/* */
3584;
var TransitionHydrationLane =
/* */
4096;
var TransitionLanes =
/* */
4186112;
var RetryLanes =
/* */
62914560;
var SomeRetryLane =
/* */
33554432;
var SelectiveHydrationLane =
/* */
67108864;
var NonIdleLanes =
/* */
134217727;
var IdleHydrationLane =
/* */
134217728;
var IdleLanes =
/* */
805306368;
var OffscreenLane =
/* */
1073741824;
var NoTimestamp = -1;
function setCurrentUpdateLanePriority(newLanePriority) {} // "Registers" used to "return" multiple values
// Used by getHighestPriorityLanes and getNextLanes:
var return_highestLanePriority = DefaultLanePriority;
function getHighestPriorityLanes(lanes) {
if ((SyncLane & lanes) !== NoLanes) {
return_highestLanePriority = SyncLanePriority;
return SyncLane;
}
if ((SyncBatchedLane & lanes) !== NoLanes) {
return_highestLanePriority = SyncBatchedLanePriority;
return SyncBatchedLane;
}
if ((InputDiscreteHydrationLane & lanes) !== NoLanes) {
return_highestLanePriority = InputDiscreteHydrationLanePriority;
return InputDiscreteHydrationLane;
}
var inputDiscreteLanes = InputDiscreteLanes & lanes;
if (inputDiscreteLanes !== NoLanes) {
return_highestLanePriority = InputDiscreteLanePriority;
return inputDiscreteLanes;
}
if ((lanes & InputContinuousHydrationLane) !== NoLanes) {
return_highestLanePriority = InputContinuousHydrationLanePriority;
return InputContinuousHydrationLane;
}
var inputContinuousLanes = InputContinuousLanes & lanes;
if (inputContinuousLanes !== NoLanes) {
return_highestLanePriority = InputContinuousLanePriority;
return inputContinuousLanes;
}
if ((lanes & DefaultHydrationLane) !== NoLanes) {
return_highestLanePriority = DefaultHydrationLanePriority;
return DefaultHydrationLane;
}
var defaultLanes = DefaultLanes & lanes;
if (defaultLanes !== NoLanes) {
return_highestLanePriority = DefaultLanePriority;
return defaultLanes;
}
if ((lanes & TransitionHydrationLane) !== NoLanes) {
return_highestLanePriority = TransitionHydrationPriority;
return TransitionHydrationLane;
}
var transitionLanes = TransitionLanes & lanes;
if (transitionLanes !== NoLanes) {
return_highestLanePriority = TransitionPriority;
return transitionLanes;
}
var retryLanes = RetryLanes & lanes;
if (retryLanes !== NoLanes) {
return_highestLanePriority = RetryLanePriority;
return retryLanes;
}
if (lanes & SelectiveHydrationLane) {
return_highestLanePriority = SelectiveHydrationLanePriority;
return SelectiveHydrationLane;
}
if ((lanes & IdleHydrationLane) !== NoLanes) {
return_highestLanePriority = IdleHydrationLanePriority;
return IdleHydrationLane;
}
var idleLanes = IdleLanes & lanes;
if (idleLanes !== NoLanes) {
return_highestLanePriority = IdleLanePriority;
return idleLanes;
}
if ((OffscreenLane & lanes) !== NoLanes) {
return_highestLanePriority = OffscreenLanePriority;
return OffscreenLane;
}
{
error("Should have found matching lanes. This is a bug in React.");
} // This shouldn't be reachable, but as a fallback, return the entire bitmask.
return_highestLanePriority = DefaultLanePriority;
return lanes;
}
function schedulerPriorityToLanePriority(schedulerPriorityLevel) {
switch (schedulerPriorityLevel) {
case ImmediatePriority:
return SyncLanePriority;
case UserBlockingPriority:
return InputContinuousLanePriority;
case NormalPriority:
case LowPriority:
// TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
return DefaultLanePriority;
case IdlePriority:
return IdleLanePriority;
default:
return NoLanePriority;
}
}
function lanePriorityToSchedulerPriority(lanePriority) {
switch (lanePriority) {
case SyncLanePriority:
case SyncBatchedLanePriority:
return ImmediatePriority;
case InputDiscreteHydrationLanePriority:
case InputDiscreteLanePriority:
case InputContinuousHydrationLanePriority:
case InputContinuousLanePriority:
return UserBlockingPriority;
case DefaultHydrationLanePriority:
case DefaultLanePriority:
case TransitionHydrationPriority:
case TransitionPriority:
case SelectiveHydrationLanePriority:
case RetryLanePriority:
return NormalPriority;
case IdleHydrationLanePriority:
case IdleLanePriority:
case OffscreenLanePriority:
return IdlePriority;
case NoLanePriority:
return NoPriority;
default: {
{
throw Error(
"Invalid update priority: " +
lanePriority +
". This is a bug in React.",
);
}
}
}
}
function getNextLanes(root, wipLanes) {
// Early bailout if there's no pending work left.
var pendingLanes = root.pendingLanes;
if (pendingLanes === NoLanes) {
return_highestLanePriority = NoLanePriority;
return NoLanes;
}
var nextLanes = NoLanes;
var nextLanePriority = NoLanePriority;
var expiredLanes = root.expiredLanes;
var suspendedLanes = root.suspendedLanes;
var pingedLanes = root.pingedLanes; // Check if any work has expired.
if (expiredLanes !== NoLanes) {
nextLanes = expiredLanes;
nextLanePriority = return_highestLanePriority = SyncLanePriority;
} else {
// Do not work on any idle work until all the non-idle work has finished,
// even if the work is suspended.
var nonIdlePendingLanes = pendingLanes & NonIdleLanes;
if (nonIdlePendingLanes !== NoLanes) {
var nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
if (nonIdleUnblockedLanes !== NoLanes) {
nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);
nextLanePriority = return_highestLanePriority;
} else {
var nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
if (nonIdlePingedLanes !== NoLanes) {
nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);
nextLanePriority = return_highestLanePriority;
}
}
} else {
// The only remaining work is Idle.
var unblockedLanes = pendingLanes & ~suspendedLanes;
if (unblockedLanes !== NoLanes) {
nextLanes = getHighestPriorityLanes(unblockedLanes);
nextLanePriority = return_highestLanePriority;
} else {
if (pingedLanes !== NoLanes) {
nextLanes = getHighestPriorityLanes(pingedLanes);
nextLanePriority = return_highestLanePriority;
}
}
}
}
if (nextLanes === NoLanes) {
// This should only be reachable if we're suspended
// TODO: Consider warning in this path if a fallback timer is not scheduled.
return NoLanes;
} // If there are higher priority lanes, we'll include them even if they
// are suspended.
nextLanes = pendingLanes & getEqualOrHigherPriorityLanes(nextLanes); // If we're already in the middle of a render, switching lanes will interrupt
// it and we'll lose our progress. We should only do this if the new lanes are
// higher priority.
if (
wipLanes !== NoLanes &&
wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
// bother waiting until the root is complete.
(wipLanes & suspendedLanes) === NoLanes
) {
getHighestPriorityLanes(wipLanes);
var wipLanePriority = return_highestLanePriority;
if (nextLanePriority <= wipLanePriority) {
return wipLanes;
} else {
return_highestLanePriority = nextLanePriority;
}
} // Check for entangled lanes and add them to the batch.
//
// A lane is said to be entangled with another when it's not allowed to render
// in a batch that does not also include the other lane. Typically we do this
// when multiple updates have the same source, and we only want to respond to
// the most recent event from that source.
//
// Note that we apply entanglements *after* checking for partial work above.
// This means that if a lane is entangled during an interleaved event while
// it's already rendering, we won't interrupt it. This is intentional, since
// entanglement is usually "best effort": we'll try our best to render the
// lanes in the same batch, but it's not worth throwing out partially
// completed work in order to do it.
//
// For those exceptions where entanglement is semantically important, like
// useMutableSource, we should ensure that there is no partial work at the
// time we apply the entanglement.
var entangledLanes = root.entangledLanes;
if (entangledLanes !== NoLanes) {
var entanglements = root.entanglements;
var lanes = nextLanes & entangledLanes;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
nextLanes |= entanglements[index];
lanes &= ~lane;
}
}
return nextLanes;
}
function getMostRecentEventTime(root, lanes) {
var eventTimes = root.eventTimes;
var mostRecentEventTime = NoTimestamp;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
var eventTime = eventTimes[index];
if (eventTime > mostRecentEventTime) {
mostRecentEventTime = eventTime;
}
lanes &= ~lane;
}
return mostRecentEventTime;
}
function computeExpirationTime(lane, currentTime) {
// TODO: Expiration heuristic is constant per lane, so could use a map.
getHighestPriorityLanes(lane);
var priority = return_highestLanePriority;
if (priority >= InputContinuousLanePriority) {
// User interactions should expire slightly more quickly.
//
// NOTE: This is set to the corresponding constant as in Scheduler.js. When
// we made it larger, a product metric in www regressed, suggesting there's
// a user interaction that's being starved by a series of synchronous
// updates. If that theory is correct, the proper solution is to fix the
// starvation. However, this scenario supports the idea that expiration
// times are an important safeguard when starvation does happen.
//
// Also note that, in the case of user input specifically, this will soon no
// longer be an issue because we plan to make user input synchronous by
// default (until you enter `startTransition`, of course.)
//
// If weren't planning to make these updates synchronous soon anyway, I
// would probably make this number a configurable parameter.
return currentTime + 250;
} else if (priority >= TransitionPriority) {
return currentTime + 5000;
} else {
// Anything idle priority or lower should never expire.
return NoTimestamp;
}
}
function markStarvedLanesAsExpired(root, currentTime) {
// TODO: This gets called every time we yield. We can optimize by storing
// the earliest expiration time on the root. Then use that to quickly bail out
// of this function.
var pendingLanes = root.pendingLanes;
var suspendedLanes = root.suspendedLanes;
var pingedLanes = root.pingedLanes;
var expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their
// expiration time. If so, we'll assume the update is being starved and mark
// it as expired to force it to finish.
var lanes = pendingLanes;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
var expirationTime = expirationTimes[index];
if (expirationTime === NoTimestamp) {
// Found a pending lane with no expiration time. If it's not suspended, or
// if it's pinged, assume it's CPU-bound. Compute a new expiration time
// using the current time.
if (
(lane & suspendedLanes) === NoLanes ||
(lane & pingedLanes) !== NoLanes
) {
// Assumes timestamps are monotonically increasing.
expirationTimes[index] = computeExpirationTime(lane, currentTime);
}
} else if (expirationTime <= currentTime) {
// This lane expired
root.expiredLanes |= lane;
}
lanes &= ~lane;
}
} // This returns the highest priority pending lanes regardless of whether they
function getLanesToRetrySynchronouslyOnError(root) {
var everythingButOffscreen = root.pendingLanes & ~OffscreenLane;
if (everythingButOffscreen !== NoLanes) {
return everythingButOffscreen;
}
if (everythingButOffscreen & OffscreenLane) {
return OffscreenLane;
}
return NoLanes;
}
function returnNextLanesPriority() {
return return_highestLanePriority;
}
function includesNonIdleWork(lanes) {
return (lanes & NonIdleLanes) !== NoLanes;
}
function includesOnlyRetries(lanes) {
return (lanes & RetryLanes) === lanes;
}
function includesOnlyTransitions(lanes) {
return (lanes & TransitionLanes) === lanes;
} // To ensure consistency across multiple updates in the same event, this should
// be a pure function, so that it always returns the same lane for given inputs.
function findUpdateLane(lanePriority, wipLanes) {
switch (lanePriority) {
case NoLanePriority:
break;
case SyncLanePriority:
return SyncLane;
case SyncBatchedLanePriority:
return SyncBatchedLane;
case InputDiscreteLanePriority: {
var _lane = pickArbitraryLane(InputDiscreteLanes & ~wipLanes);
if (_lane === NoLane) {
// Shift to the next priority level
return findUpdateLane(InputContinuousLanePriority, wipLanes);
}
return _lane;
}
case InputContinuousLanePriority: {
var _lane2 = pickArbitraryLane(InputContinuousLanes & ~wipLanes);
if (_lane2 === NoLane) {
// Shift to the next priority level
return findUpdateLane(DefaultLanePriority, wipLanes);
}
return _lane2;
}
case DefaultLanePriority: {
var _lane3 = pickArbitraryLane(DefaultLanes & ~wipLanes);
if (_lane3 === NoLane) {
// If all the default lanes are already being worked on, look for a
// lane in the transition range.
_lane3 = pickArbitraryLane(TransitionLanes & ~wipLanes);
if (_lane3 === NoLane) {
// All the transition lanes are taken, too. This should be very
// rare, but as a last resort, pick a default lane. This will have
// the effect of interrupting the current work-in-progress render.
_lane3 = pickArbitraryLane(DefaultLanes);
}
}
return _lane3;
}
case TransitionPriority: // Should be handled by findTransitionLane instead
case RetryLanePriority:
// Should be handled by findRetryLane instead
break;
case IdleLanePriority:
var lane = pickArbitraryLane(IdleLanes & ~wipLanes);
if (lane === NoLane) {
lane = pickArbitraryLane(IdleLanes);
}
return lane;
}
{
{
throw Error(
"Invalid update priority: " +
lanePriority +
". This is a bug in React.",
);
}
}
} // To ensure consistency across multiple updates in the same event, this should
// be pure function, so that it always returns the same lane for given inputs.
function findTransitionLane(wipLanes, pendingLanes) {
// First look for lanes that are completely unclaimed, i.e. have no
// pending work.
var lane = pickArbitraryLane(TransitionLanes & ~pendingLanes);
if (lane === NoLane) {
// If all lanes have pending work, look for a lane that isn't currently
// being worked on.
lane = pickArbitraryLane(TransitionLanes & ~wipLanes);
if (lane === NoLane) {
// If everything is being worked on, pick any lane. This has the
// effect of interrupting the current work-in-progress.
lane = pickArbitraryLane(TransitionLanes);
}
}
return lane;
} // To ensure consistency across multiple updates in the same event, this should
// be pure function, so that it always returns the same lane for given inputs.
function findRetryLane(wipLanes) {
// This is a fork of `findUpdateLane` designed specifically for Suspense
// "retries" — a special update that attempts to flip a Suspense boundary
// from its placeholder state to its primary/resolved state.
var lane = pickArbitraryLane(RetryLanes & ~wipLanes);
if (lane === NoLane) {
lane = pickArbitraryLane(RetryLanes);
}
return lane;
}
function getHighestPriorityLane(lanes) {
return lanes & -lanes;
}
function getLowestPriorityLane(lanes) {
// This finds the most significant non-zero bit.
var index = 31 - clz32(lanes);
return index < 0 ? NoLanes : 1 << index;
}
function getEqualOrHigherPriorityLanes(lanes) {
return (getLowestPriorityLane(lanes) << 1) - 1;
}
function pickArbitraryLane(lanes) {
// This wrapper function gets inlined. Only exists so to communicate that it
// doesn't matter which bit is selected; you can pick any bit without
// affecting the algorithms where its used. Here I'm using
// getHighestPriorityLane because it requires the fewest operations.
return getHighestPriorityLane(lanes);
}
function pickArbitraryLaneIndex(lanes) {
return 31 - clz32(lanes);
}
function laneToIndex(lane) {
return pickArbitraryLaneIndex(lane);
}
function includesSomeLane(a, b) {
return (a & b) !== NoLanes;
}
function isSubsetOfLanes(set, subset) {
return (set & subset) === subset;
}
function mergeLanes(a, b) {
return a | b;
}
function removeLanes(set, subset) {
return set & ~subset;
} // Seems redundant, but it changes the type from a single lane (used for
// updates) to a group of lanes (used for flushing work).
function laneToLanes(lane) {
return lane;
}
function higherPriorityLane(a, b) {
// This works because the bit ranges decrease in priority as you go left.
return a !== NoLane && a < b ? a : b;
}
function createLaneMap(initial) {
// Intentionally pushing one by one.
// https://v8.dev/blog/elements-kinds#avoid-creating-holes
var laneMap = [];
for (var i = 0; i < TotalLanes; i++) {
laneMap.push(initial);
}
return laneMap;
}
function markRootUpdated(root, updateLane, eventTime) {
root.pendingLanes |= updateLane; // TODO: Theoretically, any update to any lane can unblock any other lane. But
// it's not practical to try every single possible combination. We need a
// heuristic to decide which lanes to attempt to render, and in which batches.
// For now, we use the same heuristic as in the old ExpirationTimes model:
// retry any lane at equal or lower priority, but don't try updates at higher
// priority without also including the lower priority updates. This works well
// when considering updates across different priority levels, but isn't
// sufficient for updates within the same priority, since we want to treat
// those updates as parallel.
// Unsuspend any update at equal or lower priority.
var higherPriorityLanes = updateLane - 1; // Turns 0b1000 into 0b0111
root.suspendedLanes &= higherPriorityLanes;
root.pingedLanes &= higherPriorityLanes;
var eventTimes = root.eventTimes;
var index = laneToIndex(updateLane); // We can always overwrite an existing timestamp because we prefer the most
// recent event, and we assume time is monotonically increasing.
eventTimes[index] = eventTime;
}
function markRootSuspended(root, suspendedLanes) {
root.suspendedLanes |= suspendedLanes;
root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.
var expirationTimes = root.expirationTimes;
var lanes = suspendedLanes;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
expirationTimes[index] = NoTimestamp;
lanes &= ~lane;
}
}
function markRootPinged(root, pingedLanes, eventTime) {
root.pingedLanes |= root.suspendedLanes & pingedLanes;
}
function markDiscreteUpdatesExpired(root) {
root.expiredLanes |= InputDiscreteLanes & root.pendingLanes;
}
function hasDiscreteLanes(lanes) {
return (lanes & InputDiscreteLanes) !== NoLanes;
}
function markRootMutableRead(root, updateLane) {
root.mutableReadLanes |= updateLane & root.pendingLanes;
}
function markRootFinished(root, remainingLanes) {
var noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
root.pendingLanes = remainingLanes; // Let's try everything again
root.suspendedLanes = 0;
root.pingedLanes = 0;
root.expiredLanes &= remainingLanes;
root.mutableReadLanes &= remainingLanes;
root.entangledLanes &= remainingLanes;
var entanglements = root.entanglements;
var eventTimes = root.eventTimes;
var expirationTimes = root.expirationTimes; // Clear the lanes that no longer have pending work
var lanes = noLongerPendingLanes;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
entanglements[index] = NoLanes;
eventTimes[index] = NoTimestamp;
expirationTimes[index] = NoTimestamp;
lanes &= ~lane;
}
}
function markRootEntangled(root, entangledLanes) {
root.entangledLanes |= entangledLanes;
var entanglements = root.entanglements;
var lanes = entangledLanes;
while (lanes > 0) {
var index = pickArbitraryLaneIndex(lanes);
var lane = 1 << index;
entanglements[index] |= entangledLanes;
lanes &= ~lane;
}
}
var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros. Only used on lanes, so assume input is an integer.
// Based on:
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
var log = Math.log;
var LN2 = Math.LN2;
function clz32Fallback(lanes) {
if (lanes === 0) {
return 32;
}
return (31 - ((log(lanes) / LN2) | 0)) | 0;
}
// Intentionally not named imports because Rollup would use dynamic dispatch for
var UserBlockingPriority$1 = unstable_UserBlockingPriority,
runWithPriority = unstable_runWithPriority; // TODO: can we stop exporting these?
var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
// We'd like to remove this but it's not clear if this is safe.
function setEnabled(enabled) {
_enabled = !!enabled;
}
function isEnabled() {
return _enabled;
}
function createEventListenerWrapperWithPriority(
targetContainer,
domEventName,
eventSystemFlags,
) {
var eventPriority = getEventPriorityForPluginSystem(domEventName);
var listenerWrapper;
switch (eventPriority) {
case DiscreteEvent:
listenerWrapper = dispatchDiscreteEvent;
break;
case UserBlockingEvent:
listenerWrapper = dispatchUserBlockingUpdate;
break;
case ContinuousEvent:
default:
listenerWrapper = dispatchEvent;
break;
}
return listenerWrapper.bind(
null,
domEventName,
eventSystemFlags,
targetContainer,
);
}
function dispatchDiscreteEvent(
domEventName,
eventSystemFlags,
container,
nativeEvent,
) {
{
flushDiscreteUpdatesIfNeeded(nativeEvent.timeStamp);
}
discreteUpdates(
dispatchEvent,
domEventName,
eventSystemFlags,
container,
nativeEvent,
);
}
function dispatchUserBlockingUpdate(
domEventName,
eventSystemFlags,
container,
nativeEvent,
) {
{
runWithPriority(
UserBlockingPriority$1,
dispatchEvent.bind(
null,
domEventName,
eventSystemFlags,
container,
nativeEvent,
),
);
}
}
function dispatchEvent(
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
if (!_enabled) {
return;
}
var allowReplay = true;
{
// TODO: replaying capture phase events is currently broken
// because we used to do it during top-level native bubble handlers
// but now we use different bubble and capture handlers.
// In eager mode, we attach capture listeners early, so we need
// to filter them out until we fix the logic to handle them correctly.
// This could've been outside the flag but I put it inside to reduce risk.
allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
}
if (
allowReplay &&
hasQueuedDiscreteEvents() &&
isReplayableDiscreteEvent(domEventName)
) {
// If we already have a queue of discrete events, and this is another discrete
// event, then we can't dispatch it regardless of its target, since they
// need to dispatch in order.
queueDiscreteEvent(
null, // Flags that we're not actually blocked on anything as far as we know.
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
);
return;
}
var blockedOn = attemptToDispatchEvent(
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
);
if (blockedOn === null) {
// We successfully dispatched this event.
if (allowReplay) {
clearIfContinuousEvent(domEventName, nativeEvent);
}
return;
}
if (allowReplay) {
if (isReplayableDiscreteEvent(domEventName)) {
// This this to be replayed later once the target is available.
queueDiscreteEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
);
return;
}
if (
queueIfContinuousEvent(
blockedOn,
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
)
) {
return;
} // We need to clear only if we didn't queue because
// queueing is accummulative.
clearIfContinuousEvent(domEventName, nativeEvent);
} // This is not replayable so we'll invoke it but without a target,
// in case the event system needs to trace it.
dispatchEventForPluginEventSystem(
domEventName,
eventSystemFlags,
nativeEvent,
null,
targetContainer,
);
} // Attempt dispatching an event. Returns a SuspenseInstance or Container if it's blocked.
function attemptToDispatchEvent(
domEventName,
eventSystemFlags,
targetContainer,
nativeEvent,
) {
// TODO: Warn if _enabled is false.
var nativeEventTarget = getEventTarget(nativeEvent);
var targetInst = getClosestInstanceFromNode(nativeEventTarget);
if (targetInst !== null) {
var nearestMounted = getNearestMountedFiber(targetInst);
if (nearestMounted === null) {
// This tree has been unmounted already. Dispatch without a target.
targetInst = null;
} else {
var tag = nearestMounted.tag;
if (tag === SuspenseComponent) {
var instance = getSuspenseInstanceFromFiber(nearestMounted);
if (instance !== null) {
// Queue the event to be replayed later. Abort dispatching since we
// don't want this event dispatched twice through the event system.
// TODO: If this is the first discrete event in the queue. Schedule an increased
// priority for this boundary.
return instance;
} // This shouldn't happen, something went wrong but to avoid blocking
// the whole system, dispatch the event without a target.
// TODO: Warn.
targetInst = null;
} else if (tag === HostRoot) {
var root = nearestMounted.stateNode;
if (root.hydrate) {
// If this happens during a replay something went wrong and it might block
// the whole system.
return getContainerFromFiber(nearestMounted);
}
targetInst = null;
} else if (nearestMounted !== targetInst) {
// If we get an event (ex: img onload) before committing that
// component's mount, ignore it for now (that is, treat it as if it was an
// event on a non-React tree). We might also consider queueing events and
// dispatching them after the mount.
targetInst = null;
}
}
}
dispatchEventForPluginEventSystem(
domEventName,
eventSystemFlags,
nativeEvent,
targetInst,
targetContainer,
); // We're not blocked on anything.
return null;
}
function addEventBubbleListener(target, eventType, listener) {
target.addEventListener(eventType, listener, false);
return listener;
}
function addEventCaptureListener(target, eventType, listener) {
target.addEventListener(eventType, listener, true);
return listener;
}
function addEventCaptureListenerWithPassiveFlag(
target,
eventType,
listener,
passive,
) {
target.addEventListener(eventType, listener, {
capture: true,
passive: passive,
});
return listener;
}
function addEventBubbleListenerWithPassiveFlag(
target,
eventType,
listener,
passive,
) {
target.addEventListener(eventType, listener, {
passive: passive,
});
return listener;
}
/**
* These variables store information about text content of a target node,
* allowing comparison of content before and after a given event.
*
* Identify the node where selection currently begins, then observe
* both its text content and its current position in the DOM. Since the
* browser may natively replace the target node during composition, we can
* use its position to find its replacement.
*
*
*/
var root = null;
var startText = null;
var fallbackText = null;
function initialize(nativeEventTarget) {
root = nativeEventTarget;
startText = getText();
return true;
}
function reset() {
root = null;
startText = null;
fallbackText = null;
}
function getData() {
if (fallbackText) {
return fallbackText;
}
var start;
var startValue = startText;
var startLength = startValue.length;
var end;
var endValue = getText();
var endLength = endValue.length;
for (start = 0; start < startLength; start++) {
if (startValue[start] !== endValue[start]) {
break;
}
}
var minEnd = startLength - start;
for (end = 1; end <= minEnd; end++) {
if (startValue[startLength - end] !== endValue[endLength - end]) {
break;
}
}
var sliceTail = end > 1 ? 1 - end : undefined;
fallbackText = endValue.slice(start, sliceTail);
return fallbackText;
}
function getText() {
if ("value" in root) {
return root.value;
}
return root.textContent;
}
/**
* `charCode` represents the actual "character code" and is safe to use with
* `String.fromCharCode`. As such, only keys that correspond to printable
* characters produce a valid `charCode`, the only exception to this is Enter.
* The Tab-key is considered non-printable and does not have a `charCode`,
* presumably because it does not produce a tab-character in browsers.
*
* @param {object} nativeEvent Native browser event.
* @return {number} Normalized `charCode` property.
*/
function getEventCharCode(nativeEvent) {
var charCode;
var keyCode = nativeEvent.keyCode;
if ("charCode" in nativeEvent) {
charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
if (charCode === 0 && keyCode === 13) {
charCode = 13;
}
} else {
// IE8 does not implement `charCode`, but `keyCode` has the correct value.
charCode = keyCode;
} // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
// report Enter as charCode 10 when ctrl is pressed.
if (charCode === 10) {
charCode = 13;
} // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
// Must not discard the (non-)printable Enter-key.
if (charCode >= 32 || charCode === 13) {
return charCode;
}
return 0;
}
function functionThatReturnsTrue() {
return true;
}
function functionThatReturnsFalse() {
return false;
} // This is intentionally a factory so that we have different returned constructors.
// If we had a single constructor, it would be megamorphic and engines would deopt.
function createSyntheticEvent(Interface) {
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*/
function SyntheticBaseEvent(
reactName,
reactEventType,
targetInst,
nativeEvent,
nativeEventTarget,
) {
this._reactName = reactName;
this._targetInst = targetInst;
this.type = reactEventType;
this.nativeEvent = nativeEvent;
this.target = nativeEventTarget;
this.currentTarget = null;
for (var _propName in Interface) {
if (!Interface.hasOwnProperty(_propName)) {
continue;
}
var normalize = Interface[_propName];
if (normalize) {
this[_propName] = normalize(nativeEvent);
} else {
this[_propName] = nativeEvent[_propName];
}
}
var defaultPrevented =
nativeEvent.defaultPrevented != null
? nativeEvent.defaultPrevented
: nativeEvent.returnValue === false;
if (defaultPrevented) {
this.isDefaultPrevented = functionThatReturnsTrue;
} else {
this.isDefaultPrevented = functionThatReturnsFalse;
}
this.isPropagationStopped = functionThatReturnsFalse;
return this;
}
_assign(SyntheticBaseEvent.prototype, {
preventDefault: function () {
this.defaultPrevented = true;
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.preventDefault) {
event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
} else if (typeof event.returnValue !== "unknown") {
event.returnValue = false;
}
this.isDefaultPrevented = functionThatReturnsTrue;
},
stopPropagation: function () {
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.stopPropagation) {
event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
} else if (typeof event.cancelBubble !== "unknown") {
// The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// IE specific).
event.cancelBubble = true;
}
this.isPropagationStopped = functionThatReturnsTrue;
},
/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/
persist: function () {
// Modern event system doesn't use pooling.
},
/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/
isPersistent: functionThatReturnsTrue,
});
return SyntheticBaseEvent;
}
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var EventInterface = {
eventPhase: 0,
bubbles: 0,
cancelable: 0,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: 0,
isTrusted: 0,
};
var SyntheticEvent = createSyntheticEvent(EventInterface);
var UIEventInterface = _assign({}, EventInterface, {
view: 0,
detail: 0,
});
var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
var lastMovementX;
var lastMovementY;
var lastMouseEvent;
function updateMouseMovementPolyfillState(event) {
if (event !== lastMouseEvent) {
if (lastMouseEvent && event.type === "mousemove") {
lastMovementX = event.screenX - lastMouseEvent.screenX;
lastMovementY = event.screenY - lastMouseEvent.screenY;
} else {
lastMovementX = 0;
lastMovementY = 0;
}
lastMouseEvent = event;
}
}
/**
* @interface MouseEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var MouseEventInterface = _assign({}, UIEventInterface, {
screenX: 0,
screenY: 0,
clientX: 0,
clientY: 0,
pageX: 0,
pageY: 0,
ctrlKey: 0,
shiftKey: 0,
altKey: 0,
metaKey: 0,
getModifierState: getEventModifierState,
button: 0,
buttons: 0,
relatedTarget: function (event) {
if (event.relatedTarget === undefined)
return event.fromElement === event.srcElement
? event.toElement
: event.fromElement;
return event.relatedTarget;
},
movementX: function (event) {
if ("movementX" in event) {
return event.movementX;
}
updateMouseMovementPolyfillState(event);
return lastMovementX;
},
movementY: function (event) {
if ("movementY" in event) {
return event.movementY;
} // Don't need to call updateMouseMovementPolyfillState() here
// because it's guaranteed to have already run when movementX
// was copied.
return lastMovementY;
},
});
var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
/**
* @interface DragEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var DragEventInterface = _assign({}, MouseEventInterface, {
dataTransfer: 0,
});
var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
/**
* @interface FocusEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var FocusEventInterface = _assign({}, UIEventInterface, {
relatedTarget: 0,
});
var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
/**
* @interface Event
* @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
* @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
*/
var AnimationEventInterface = _assign({}, EventInterface, {
animationName: 0,
elapsedTime: 0,
pseudoElement: 0,
});
var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
/**
* @interface Event
* @see http://www.w3.org/TR/clipboard-apis/
*/
var ClipboardEventInterface = _assign({}, EventInterface, {
clipboardData: function (event) {
return "clipboardData" in event
? event.clipboardData
: window.clipboardData;
},
});
var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
*/
var CompositionEventInterface = _assign({}, EventInterface, {
data: 0,
});
var SyntheticCompositionEvent = createSyntheticEvent(
CompositionEventInterface,
);
/**
* @interface Event
* @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
* /#events-inputevents
*/
// Happens to share the same list for now.
var SyntheticInputEvent = SyntheticCompositionEvent;
/**
* Normalization of deprecated HTML5 `key` values
* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
*/
var normalizeKey = {
Esc: "Escape",
Spacebar: " ",
Left: "ArrowLeft",
Up: "ArrowUp",
Right: "ArrowRight",
Down: "ArrowDown",
Del: "Delete",
Win: "OS",
Menu: "ContextMenu",
Apps: "ContextMenu",
Scroll: "ScrollLock",
MozPrintableKey: "Unidentified",
};
/**
* Translation from legacy `keyCode` to HTML5 `key`
* Only special keys supported, all others depend on keyboard layout or browser
* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
*/
var translateToKey = {
8: "Backspace",
9: "Tab",
12: "Clear",
13: "Enter",
16: "Shift",
17: "Control",
18: "Alt",
19: "Pause",
20: "CapsLock",
27: "Escape",
32: " ",
33: "PageUp",
34: "PageDown",
35: "End",
36: "Home",
37: "ArrowLeft",
38: "ArrowUp",
39: "ArrowRight",
40: "ArrowDown",
45: "Insert",
46: "Delete",
112: "F1",
113: "F2",
114: "F3",
115: "F4",
116: "F5",
117: "F6",
118: "F7",
119: "F8",
120: "F9",
121: "F10",
122: "F11",
123: "F12",
144: "NumLock",
145: "ScrollLock",
224: "Meta",
};
/**
* @param {object} nativeEvent Native browser event.
* @return {string} Normalized `key` property.
*/
function getEventKey(nativeEvent) {
if (nativeEvent.key) {
// Normalize inconsistent values reported by browsers due to
// implementations of a working draft specification.
// FireFox implements `key` but returns `MozPrintableKey` for all
// printable characters (normalized to `Unidentified`), ignore it.
var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
if (key !== "Unidentified") {
return key;
}
} // Browser does not implement `key`, polyfill as much of it as we can.
if (nativeEvent.type === "keypress") {
var charCode = getEventCharCode(nativeEvent); // The enter-key is technically both printable and non-printable and can
// thus be captured by `keypress`, no other non-printable key should.
return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
}
if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
// While user keyboard layout determines the actual meaning of each
// `keyCode` value, almost all function keys have a universal value.
return translateToKey[nativeEvent.keyCode] || "Unidentified";
}
return "";
}
/**
* Translation from modifier key to the associated property in the event.
* @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
*/
var modifierKeyToProp = {
Alt: "altKey",
Control: "ctrlKey",
Meta: "metaKey",
Shift: "shiftKey",
}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
// getModifierState. If getModifierState is not supported, we map it to a set of
// modifier keys exposed by the event. In this case, Lock-keys are not supported.
function modifierStateGetter(keyArg) {
var syntheticEvent = this;
var nativeEvent = syntheticEvent.nativeEvent;
if (nativeEvent.getModifierState) {
return nativeEvent.getModifierState(keyArg);
}
var keyProp = modifierKeyToProp[keyArg];
return keyProp ? !!nativeEvent[keyProp] : false;
}
function getEventModifierState(nativeEvent) {
return modifierStateGetter;
}
/**
* @interface KeyboardEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var KeyboardEventInterface = _assign({}, UIEventInterface, {
key: getEventKey,
code: 0,
location: 0,
ctrlKey: 0,
shiftKey: 0,
altKey: 0,
metaKey: 0,
repeat: 0,
locale: 0,
getModifierState: getEventModifierState,
// Legacy Interface
charCode: function (event) {
// `charCode` is the result of a KeyPress event and represents the value of
// the actual printable character.
// KeyPress is deprecated, but its replacement is not yet final and not
// implemented in any major browser. Only KeyPress has charCode.
if (event.type === "keypress") {
return getEventCharCode(event);
}
return 0;
},
keyCode: function (event) {
// `keyCode` is the result of a KeyDown/Up event and represents the value of
// physical keyboard key.
// The actual meaning of the value depends on the users' keyboard layout
// which cannot be detected. Assuming that it is a US keyboard layout
// provides a surprisingly accurate mapping for US and European users.
// Due to this, it is left to the user to implement at this time.
if (event.type === "keydown" || event.type === "keyup") {
return event.keyCode;
}
return 0;
},
which: function (event) {
// `which` is an alias for either `keyCode` or `charCode` depending on the
// type of the event.
if (event.type === "keypress") {
return getEventCharCode(event);
}
if (event.type === "keydown" || event.type === "keyup") {
return event.keyCode;
}
return 0;
},
});
var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
/**
* @interface PointerEvent
* @see http://www.w3.org/TR/pointerevents/
*/
var PointerEventInterface = _assign({}, MouseEventInterface, {
pointerId: 0,
width: 0,
height: 0,
pressure: 0,
tangentialPressure: 0,
tiltX: 0,
tiltY: 0,
twist: 0,
pointerType: 0,
isPrimary: 0,
});
var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
/**
* @interface TouchEvent
* @see http://www.w3.org/TR/touch-events/
*/
var TouchEventInterface = _assign({}, UIEventInterface, {
touches: 0,
targetTouches: 0,
changedTouches: 0,
altKey: 0,
metaKey: 0,
ctrlKey: 0,
shiftKey: 0,
getModifierState: getEventModifierState,
});
var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
/**
* @interface Event
* @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
* @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
*/
var TransitionEventInterface = _assign({}, EventInterface, {
propertyName: 0,
elapsedTime: 0,
pseudoElement: 0,
});
var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
/**
* @interface WheelEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var WheelEventInterface = _assign({}, MouseEventInterface, {
deltaX: function (event) {
return "deltaX" in event
? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
: "wheelDeltaX" in event
? -event.wheelDeltaX
: 0;
},
deltaY: function (event) {
return "deltaY" in event
? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
: "wheelDeltaY" in event
? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
: "wheelDelta" in event
? -event.wheelDelta
: 0;
},
deltaZ: 0,
// Browsers without "deltaMode" is reporting in raw wheel delta where one
// notch on the scroll is always +/- 120, roughly equivalent to pixels.
// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
deltaMode: 0,
});
var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
var START_KEYCODE = 229;
var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
var documentMode = null;
if (canUseDOM && "documentMode" in document) {
documentMode = document.documentMode;
} // Webkit offers a very useful `textInput` event that can be used to
// directly represent `beforeInput`. The IE `textinput` event is not as
// useful, so we don't use it.
var canUseTextInputEvent =
canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
// by the native compositionend event may be incorrect. Japanese ideographic
// spaces, for instance (\u3000) are not recorded correctly.
var useFallbackCompositionData =
canUseDOM &&
(!canUseCompositionEvent ||
(documentMode && documentMode > 8 && documentMode <= 11));
var SPACEBAR_CODE = 32;
var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
function registerEvents() {
registerTwoPhaseEvent("onBeforeInput", [
"compositionend",
"keypress",
"textInput",
"paste",
]);
registerTwoPhaseEvent("onCompositionEnd", [
"compositionend",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown",
]);
registerTwoPhaseEvent("onCompositionStart", [
"compositionstart",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown",
]);
registerTwoPhaseEvent("onCompositionUpdate", [
"compositionupdate",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown",
]);
} // Track whether we've ever handled a keypress on the space key.
var hasSpaceKeypress = false;
/**
* Return whether a native keypress event is assumed to be a command.
* This is required because Firefox fires `keypress` events for key commands
* (cut, copy, select-all, etc.) even though no character is inserted.
*/
function isKeypressCommand(nativeEvent) {
return (
(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
!(nativeEvent.ctrlKey && nativeEvent.altKey)
);
}
/**
* Translate native top level events into event types.
*/
function getCompositionEventType(domEventName) {
switch (domEventName) {
case "compositionstart":
return "onCompositionStart";
case "compositionend":
return "onCompositionEnd";
case "compositionupdate":
return "onCompositionUpdate";
}
}
/**
* Does our fallback best-guess model think this event signifies that
* composition has begun?
*/
function isFallbackCompositionStart(domEventName, nativeEvent) {
return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
}
/**
* Does our fallback mode think that this event is the end of composition?
*/
function isFallbackCompositionEnd(domEventName, nativeEvent) {
switch (domEventName) {
case "keyup":
// Command keys insert or clear IME input.
return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
case "keydown":
// Expect IME keyCode on each keydown. If we get any other
// code we must have exited earlier.
return nativeEvent.keyCode !== START_KEYCODE;
case "keypress":
case "mousedown":
case "focusout":
// Events are not possible without cancelling IME.
return true;
default:
return false;
}
}
/**
* Google Input Tools provides composition data via a CustomEvent,
* with the `data` property populated in the `detail` object. If this
* is available on the event object, use it. If not, this is a plain
* composition event and we have nothing special to extract.
*
* @param {object} nativeEvent
* @return {?string}
*/
function getDataFromCustomEvent(nativeEvent) {
var detail = nativeEvent.detail;
if (typeof detail === "object" && "data" in detail) {
return detail.data;
}
return null;
}
/**
* Check if a composition event was triggered by Korean IME.
* Our fallback mode does not work well with IE's Korean IME,
* so just use native composition events when Korean IME is used.
* Although CompositionEvent.locale property is deprecated,
* it is available in IE, where our fallback mode is enabled.
*
* @param {object} nativeEvent
* @return {boolean}
*/
function isUsingKoreanIME(nativeEvent) {
return nativeEvent.locale === "ko";
} // Track the current IME composition status, if any.
var isComposing = false;
/**
* @return {?object} A SyntheticCompositionEvent.
*/
function extractCompositionEvent(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
) {
var eventType;
var fallbackData;
if (canUseCompositionEvent) {
eventType = getCompositionEventType(domEventName);
} else if (!isComposing) {
if (isFallbackCompositionStart(domEventName, nativeEvent)) {
eventType = "onCompositionStart";
}
} else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
eventType = "onCompositionEnd";
}
if (!eventType) {
return null;
}
if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
// The current composition is stored statically and must not be
// overwritten while composition continues.
if (!isComposing && eventType === "onCompositionStart") {
isComposing = initialize(nativeEventTarget);
} else if (eventType === "onCompositionEnd") {
if (isComposing) {
fallbackData = getData();
}
}
}
var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
if (listeners.length > 0) {
var event = new SyntheticCompositionEvent(
eventType,
domEventName,
null,
nativeEvent,
nativeEventTarget,
);
dispatchQueue.push({
event: event,
listeners: listeners,
});
if (fallbackData) {
// Inject data generated from fallback path into the synthetic event.
// This matches the property of native CompositionEventInterface.
event.data = fallbackData;
} else {
var customData = getDataFromCustomEvent(nativeEvent);
if (customData !== null) {
event.data = customData;
}
}
}
}
function getNativeBeforeInputChars(domEventName, nativeEvent) {
switch (domEventName) {
case "compositionend":
return getDataFromCustomEvent(nativeEvent);
case "keypress":
/**
* If native `textInput` events are available, our goal is to make
* use of them. However, there is a special case: the spacebar key.
* In Webkit, preventing default on a spacebar `textInput` event
* cancels character insertion, but it *also* causes the browser
* to fall back to its default spacebar behavior of scrolling the
* page.
*
* Tracking at:
* https://code.google.com/p/chromium/issues/detail?id=355103
*
* To avoid this issue, use the keypress event as if no `textInput`
* event is available.
*/
var which = nativeEvent.which;
if (which !== SPACEBAR_CODE) {
return null;
}
hasSpaceKeypress = true;
return SPACEBAR_CHAR;
case "textInput":
// Record the characters to be added to the DOM.
var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
// it at the keypress level and bail immediately. Android Chrome
// doesn't give us keycodes, so we need to ignore it.
if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
return null;
}
return chars;
default:
// For other native event types, do nothing.
return null;
}
}
/**
* For browsers that do not provide the `textInput` event, extract the
* appropriate string to use for SyntheticInputEvent.
*/
function getFallbackBeforeInputChars(domEventName, nativeEvent) {
// If we are currently composing (IME) and using a fallback to do so,
// try to extract the composed characters from the fallback object.
// If composition event is available, we extract a string only at
// compositionevent, otherwise extract it at fallback events.
if (isComposing) {
if (
domEventName === "compositionend" ||
(!canUseCompositionEvent &&
isFallbackCompositionEnd(domEventName, nativeEvent))
) {
var chars = getData();
reset();
isComposing = false;
return chars;
}
return null;
}
switch (domEventName) {
case "paste":
// If a paste event occurs after a keypress, throw out the input
// chars. Paste events should not lead to BeforeInput events.
return null;
case "keypress":
/**
* As of v27, Firefox may fire keypress events even when no character
* will be inserted. A few possibilities:
*
* - `which` is `0`. Arrow keys, Esc key, etc.
*
* - `which` is the pressed key code, but no char is available.
* Ex: 'AltGr + d` in Polish. There is no modified character for
* this key combination and no character is inserted into the
* document, but FF fires the keypress for char code `100` anyway.
* No `input` event will occur.
*
* - `which` is the pressed key code, but a command combination is
* being used. Ex: `Cmd+C`. No character is inserted, and no
* `input` event will occur.
*/
if (!isKeypressCommand(nativeEvent)) {
// IE fires the `keypress` event when a user types an emoji via
// Touch keyboard of Windows. In such a case, the `char` property
// holds an emoji character like `\uD83D\uDE0A`. Because its length
// is 2, the property `which` does not represent an emoji correctly.
// In such a case, we directly return the `char` property instead of
// using `which`.
if (nativeEvent.char && nativeEvent.char.length > 1) {
return nativeEvent.char;
} else if (nativeEvent.which) {
return String.fromCharCode(nativeEvent.which);
}
}
return null;
case "compositionend":
return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
? null
: nativeEvent.data;
default:
return null;
}
}
/**
* Extract a SyntheticInputEvent for `beforeInput`, based on either native
* `textInput` or fallback behavior.
*
* @return {?object} A SyntheticInputEvent.
*/
function extractBeforeInputEvent(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
) {
var chars;
if (canUseTextInputEvent) {
chars = getNativeBeforeInputChars(domEventName, nativeEvent);
} else {
chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
} // If no characters are being inserted, no BeforeInput event should
// be fired.
if (!chars) {
return null;
}
var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
if (listeners.length > 0) {
var event = new SyntheticInputEvent(
"onBeforeInput",
"beforeinput",
null,
nativeEvent,
nativeEventTarget,
);
dispatchQueue.push({
event: event,
listeners: listeners,
});
event.data = chars;
}
}
/**
* Create an `onBeforeInput` event to match
* http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
*
* This event plugin is based on the native `textInput` event
* available in Chrome, Safari, Opera, and IE. This event fires after
* `onKeyPress` and `onCompositionEnd`, but before `onInput`.
*
* `beforeInput` is spec'd but not implemented in any browsers, and
* the `input` event does not provide any useful information about what has
* actually been added, contrary to the spec. Thus, `textInput` is the best
* available event to identify the characters that have actually been inserted
* into the target node.
*
* This plugin is also responsible for emitting `composition` events, thus
* allowing us to share composition fallback code for both `beforeInput` and
* `composition` event types.
*/
function extractEvents(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
extractCompositionEvent(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
);
extractBeforeInputEvent(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
);
}
/**
* @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
*/
var supportedInputTypes = {
color: true,
date: true,
datetime: true,
"datetime-local": true,
email: true,
month: true,
number: true,
password: true,
range: true,
search: true,
tel: true,
text: true,
time: true,
url: true,
week: true,
};
function isTextInputElement(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
if (nodeName === "input") {
return !!supportedInputTypes[elem.type];
}
if (nodeName === "textarea") {
return true;
}
return false;
}
/**
* Checks if an event is supported in the current execution environment.
*
* NOTE: This will not work correctly for non-generic events such as `change`,
* `reset`, `load`, `error`, and `select`.
*
* Borrows from Modernizr.
*
* @param {string} eventNameSuffix Event name, e.g. "click".
* @return {boolean} True if the event is supported.
* @internal
* @license Modernizr 3.0.0pre (Custom Build) | MIT
*/
function isEventSupported(eventNameSuffix) {
if (!canUseDOM) {
return false;
}
var eventName = "on" + eventNameSuffix;
var isSupported = eventName in document;
if (!isSupported) {
var element = document.createElement("div");
element.setAttribute(eventName, "return;");
isSupported = typeof element[eventName] === "function";
}
return isSupported;
}
function registerEvents$1() {
registerTwoPhaseEvent("onChange", [
"change",
"click",
"focusin",
"focusout",
"input",
"keydown",
"keyup",
"selectionchange",
]);
}
function createAndAccumulateChangeEvent(
dispatchQueue,
inst,
nativeEvent,
target,
) {
// Flag this event loop as needing state restore.
enqueueStateRestore(target);
var listeners = accumulateTwoPhaseListeners(inst, "onChange");
if (listeners.length > 0) {
var event = new SyntheticEvent(
"onChange",
"change",
null,
nativeEvent,
target,
);
dispatchQueue.push({
event: event,
listeners: listeners,
});
}
}
/**
* For IE shims
*/
var activeElement = null;
var activeElementInst = null;
/**
* SECTION: handle `change` event
*/
function shouldUseChangeEvent(elem) {
var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
return (
nodeName === "select" || (nodeName === "input" && elem.type === "file")
);
}
function manualDispatchChangeEvent(nativeEvent) {
var dispatchQueue = [];
createAndAccumulateChangeEvent(
dispatchQueue,
activeElementInst,
nativeEvent,
getEventTarget(nativeEvent),
); // If change and propertychange bubbled, we'd just bind to it like all the
// other events and have it go through ReactBrowserEventEmitter. Since it
// doesn't, we manually listen for the events and so we have to enqueue and
// process the abstract event manually.
//
// Batching is necessary here in order to ensure that all event handlers run
// before the next rerender (including event handlers attached to ancestor
// elements instead of directly on the input). Without this, controlled
// components don't work properly in conjunction with event bubbling because
// the component is rerendered and the value reverted before all the event
// handlers can run. See https://github.com/facebook/react/issues/708.
batchedUpdates(runEventInBatch, dispatchQueue);
}
function runEventInBatch(dispatchQueue) {
processDispatchQueue(dispatchQueue, 0);
}
function getInstIfValueChanged(targetInst) {
var targetNode = getNodeFromInstance(targetInst);
if (updateValueIfChanged(targetNode)) {
return targetInst;
}
}
function getTargetInstForChangeEvent(domEventName, targetInst) {
if (domEventName === "change") {
return targetInst;
}
}
/**
* SECTION: handle `input` event
*/
var isInputEventSupported = false;
if (canUseDOM) {
// IE9 claims to support the input event but fails to trigger it when
// deleting text, so we ignore its input events.
isInputEventSupported =
isEventSupported("input") &&
(!document.documentMode || document.documentMode > 9);
}
/**
* (For IE <=9) Starts tracking propertychange events on the passed-in element
* and override the value property so that we can distinguish user events from
* value changes in JS.
*/
function startWatchingForValueChange(target, targetInst) {
activeElement = target;
activeElementInst = targetInst;
activeElement.attachEvent("onpropertychange", handlePropertyChange);
}
/**
* (For IE <=9) Removes the event listeners from the currently-tracked element,
* if any exists.
*/
function stopWatchingForValueChange() {
if (!activeElement) {
return;
}
activeElement.detachEvent("onpropertychange", handlePropertyChange);
activeElement = null;
activeElementInst = null;
}
/**
* (For IE <=9) Handles a propertychange event, sending a `change` event if
* the value of the active element has changed.
*/
function handlePropertyChange(nativeEvent) {
if (nativeEvent.propertyName !== "value") {
return;
}
if (getInstIfValueChanged(activeElementInst)) {
manualDispatchChangeEvent(nativeEvent);
}
}
function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
if (domEventName === "focusin") {
// In IE9, propertychange fires for most input events but is buggy and
// doesn't fire when text is deleted, but conveniently, selectionchange
// appears to fire in all of the remaining cases so we catch those and
// forward the event if the value has changed
// In either case, we don't want to call the event handler if the value
// is changed from JS so we redefine a setter for `.value` that updates
// our activeElementValue variable, allowing us to ignore those changes
//
// stopWatching() should be a noop here but we call it just in case we
// missed a blur event somehow.
stopWatchingForValueChange();
startWatchingForValueChange(target, targetInst);
} else if (domEventName === "focusout") {
stopWatchingForValueChange();
}
} // For IE8 and IE9.
function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
if (
domEventName === "selectionchange" ||
domEventName === "keyup" ||
domEventName === "keydown"
) {
// On the selectionchange event, the target is just document which isn't
// helpful for us so just check activeElement instead.
//
// 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
// propertychange on the first input event after setting `value` from a
// script and fires only keydown, keypress, keyup. Catching keyup usually
// gets it and catching keydown lets us fire an event for the first
// keystroke if user does a key repeat (it'll be a little delayed: right
// before the second keystroke). Other input methods (e.g., paste) seem to
// fire selectionchange normally.
return getInstIfValueChanged(activeElementInst);
}
}
/**
* SECTION: handle `click` event
*/
function shouldUseClickEvent(elem) {
// Use the `click` event to detect changes to checkbox and radio inputs.
// This approach works across all browsers, whereas `change` does not fire
// until `blur` in IE8.
var nodeName = elem.nodeName;
return (
nodeName &&
nodeName.toLowerCase() === "input" &&
(elem.type === "checkbox" || elem.type === "radio")
);
}
function getTargetInstForClickEvent(domEventName, targetInst) {
if (domEventName === "click") {
return getInstIfValueChanged(targetInst);
}
}
function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
if (domEventName === "input" || domEventName === "change") {
return getInstIfValueChanged(targetInst);
}
}
function handleControlledInputBlur(node) {
var state = node._wrapperState;
if (!state || !state.controlled || node.type !== "number") {
return;
}
{
// If controlled, assign the value attribute to the current value on blur
setDefaultValue(node, "number", node.value);
}
}
/**
* This plugin creates an `onChange` event that normalizes change events
* across form elements. This event fires at a time when it's possible to
* change the element's value without seeing a flicker.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - select
*/
function extractEvents$1(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
var getTargetInstFunc, handleEventFunc;
if (shouldUseChangeEvent(targetNode)) {
getTargetInstFunc = getTargetInstForChangeEvent;
} else if (isTextInputElement(targetNode)) {
if (isInputEventSupported) {
getTargetInstFunc = getTargetInstForInputOrChangeEvent;
} else {
getTargetInstFunc = getTargetInstForInputEventPolyfill;
handleEventFunc = handleEventsForInputEventPolyfill;
}
} else if (shouldUseClickEvent(targetNode)) {
getTargetInstFunc = getTargetInstForClickEvent;
}
if (getTargetInstFunc) {
var inst = getTargetInstFunc(domEventName, targetInst);
if (inst) {
createAndAccumulateChangeEvent(
dispatchQueue,
inst,
nativeEvent,
nativeEventTarget,
);
return;
}
}
if (handleEventFunc) {
handleEventFunc(domEventName, targetNode, targetInst);
} // When blurring, set the value attribute for number inputs
if (domEventName === "focusout") {
handleControlledInputBlur(targetNode);
}
}
function registerEvents$2() {
registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
}
/**
* For almost every interaction we care about, there will be both a top-level
* `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
* we do not extract duplicate events. However, moving the mouse into the
* browser from outside will not fire a `mouseout` event. In this case, we use
* the `mouseover` top-level event.
*/
function extractEvents$2(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
var isOverEvent =
domEventName === "mouseover" || domEventName === "pointerover";
var isOutEvent =
domEventName === "mouseout" || domEventName === "pointerout";
if (isOverEvent && (eventSystemFlags & IS_REPLAYED) === 0) {
// If this is an over event with a target, we might have already dispatched
// the event in the out event of the other target. If this is replayed,
// then it's because we couldn't dispatch against this target previously
// so we have to do it now instead.
var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
if (related) {
// If the related node is managed by React, we can assume that we have
// already dispatched the corresponding events during its mouseout.
if (
getClosestInstanceFromNode(related) ||
isContainerMarkedAsRoot(related)
) {
return;
}
}
}
if (!isOutEvent && !isOverEvent) {
// Must not be a mouse or pointer in or out - ignoring.
return;
}
var win; // TODO: why is this nullable in the types but we read from it?
if (nativeEventTarget.window === nativeEventTarget) {
// `nativeEventTarget` is probably a window object.
win = nativeEventTarget;
} else {
// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
var doc = nativeEventTarget.ownerDocument;
if (doc) {
win = doc.defaultView || doc.parentWindow;
} else {
win = window;
}
}
var from;
var to;
if (isOutEvent) {
var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
from = targetInst;
to = _related ? getClosestInstanceFromNode(_related) : null;
if (to !== null) {
var nearestMounted = getNearestMountedFiber(to);
if (
to !== nearestMounted ||
(to.tag !== HostComponent && to.tag !== HostText)
) {
to = null;
}
}
} else {
// Moving to a node from outside the window.
from = null;
to = targetInst;
}
if (from === to) {
// Nothing pertains to our managed components.
return;
}
var SyntheticEventCtor = SyntheticMouseEvent;
var leaveEventType = "onMouseLeave";
var enterEventType = "onMouseEnter";
var eventTypePrefix = "mouse";
if (domEventName === "pointerout" || domEventName === "pointerover") {
SyntheticEventCtor = SyntheticPointerEvent;
leaveEventType = "onPointerLeave";
enterEventType = "onPointerEnter";
eventTypePrefix = "pointer";
}
var fromNode = from == null ? win : getNodeFromInstance(from);
var toNode = to == null ? win : getNodeFromInstance(to);
var leave = new SyntheticEventCtor(
leaveEventType,
eventTypePrefix + "leave",
from,
nativeEvent,
nativeEventTarget,
);
leave.target = fromNode;
leave.relatedTarget = toNode;
var enter = null; // We should only process this nativeEvent if we are processing
// the first ancestor. Next time, we will ignore the event.
var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
if (nativeTargetInst === targetInst) {
var enterEvent = new SyntheticEventCtor(
enterEventType,
eventTypePrefix + "enter",
to,
nativeEvent,
nativeEventTarget,
);
enterEvent.target = toNode;
enterEvent.relatedTarget = fromNode;
enter = enterEvent;
}
accumulateEnterLeaveTwoPhaseListeners(
dispatchQueue,
leave,
enter,
from,
to,
);
}
/**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/
function is(x, y) {
return (
(x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
);
}
var objectIs = typeof Object.is === "function" ? Object.is : is;
var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/
function shallowEqual(objA, objB) {
if (objectIs(objA, objB)) {
return true;
}
if (
typeof objA !== "object" ||
objA === null ||
typeof objB !== "object" ||
objB === null
) {
return false;
}
var keysA = Object.keys(objA);
var keysB = Object.keys(objB);
if (keysA.length !== keysB.length) {
return false;
} // Test for A's keys different from B.
for (var i = 0; i < keysA.length; i++) {
if (
!hasOwnProperty$2.call(objB, keysA[i]) ||
!objectIs(objA[keysA[i]], objB[keysA[i]])
) {
return false;
}
}
return true;
}
/**
* Given any node return the first leaf node without children.
*
* @param {DOMElement|DOMTextNode} node
* @return {DOMElement|DOMTextNode}
*/
function getLeafNode(node) {
while (node && node.firstChild) {
node = node.firstChild;
}
return node;
}
/**
* Get the next sibling within a container. This will walk up the
* DOM if a node's siblings have been exhausted.
*
* @param {DOMElement|DOMTextNode} node
* @return {?DOMElement|DOMTextNode}
*/
function getSiblingNode(node) {
while (node) {
if (node.nextSibling) {
return node.nextSibling;
}
node = node.parentNode;
}
}
/**
* Get object describing the nodes which contain characters at offset.
*
* @param {DOMElement|DOMTextNode} root
* @param {number} offset
* @return {?object}
*/
function getNodeForCharacterOffset(root, offset) {
var node = getLeafNode(root);
var nodeStart = 0;
var nodeEnd = 0;
while (node) {
if (node.nodeType === TEXT_NODE) {
nodeEnd = nodeStart + node.textContent.length;
if (nodeStart <= offset && nodeEnd >= offset) {
return {
node: node,
offset: offset - nodeStart,
};
}
nodeStart = nodeEnd;
}
node = getLeafNode(getSiblingNode(node));
}
}
/**
* @param {DOMElement} outerNode
* @return {?object}
*/
function getOffsets(outerNode) {
var ownerDocument = outerNode.ownerDocument;
var win = (ownerDocument && ownerDocument.defaultView) || window;
var selection = win.getSelection && win.getSelection();
if (!selection || selection.rangeCount === 0) {
return null;
}
var anchorNode = selection.anchorNode,
anchorOffset = selection.anchorOffset,
focusNode = selection.focusNode,
focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
// up/down buttons on an <input type="number">. Anonymous divs do not seem to
// expose properties, triggering a "Permission denied error" if any of its
// properties are accessed. The only seemingly possible way to avoid erroring
// is to access a property that typically works for non-anonymous divs and
// catch any error that may otherwise arise. See
// https://bugzilla.mozilla.org/show_bug.cgi?id=208427
try {
/* eslint-disable no-unused-expressions */
anchorNode.nodeType;
focusNode.nodeType;
/* eslint-enable no-unused-expressions */
} catch (e) {
return null;
}
return getModernOffsetsFromPoints(
outerNode,
anchorNode,
anchorOffset,
focusNode,
focusOffset,
);
}
/**
* Returns {start, end} where `start` is the character/codepoint index of
* (anchorNode, anchorOffset) within the textContent of `outerNode`, and
* `end` is the index of (focusNode, focusOffset).
*
* Returns null if you pass in garbage input but we should probably just crash.
*
* Exported only for testing.
*/
function getModernOffsetsFromPoints(
outerNode,
anchorNode,
anchorOffset,
focusNode,
focusOffset,
) {
var length = 0;
var start = -1;
var end = -1;
var indexWithinAnchor = 0;
var indexWithinFocus = 0;
var node = outerNode;
var parentNode = null;
outer: while (true) {
var next = null;
while (true) {
if (
node === anchorNode &&
(anchorOffset === 0 || node.nodeType === TEXT_NODE)
) {
start = length + anchorOffset;
}
if (
node === focusNode &&
(focusOffset === 0 || node.nodeType === TEXT_NODE)
) {
end = length + focusOffset;
}
if (node.nodeType === TEXT_NODE) {
length += node.nodeValue.length;
}
if ((next = node.firstChild) === null) {
break;
} // Moving from `node` to its first child `next`.
parentNode = node;
node = next;
}
while (true) {
if (node === outerNode) {
// If `outerNode` has children, this is always the second time visiting
// it. If it has no children, this is still the first loop, and the only
// valid selection is anchorNode and focusNode both equal to this node
// and both offsets 0, in which case we will have handled above.
break outer;
}
if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
start = length;
}
if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
end = length;
}
if ((next = node.nextSibling) !== null) {
break;
}
node = parentNode;
parentNode = node.parentNode;
} // Moving from `node` to its next sibling `next`.
node = next;
}
if (start === -1 || end === -1) {
// This should never happen. (Would happen if the anchor/focus nodes aren't
// actually inside the passed-in node.)
return null;
}
return {
start: start,
end: end,
};
}
/**
* In modern non-IE browsers, we can support both forward and backward
* selections.
*
* Note: IE10+ supports the Selection object, but it does not support
* the `extend` method, which means that even in modern IE, it's not possible
* to programmatically create a backward selection. Thus, for all IE
* versions, we use the old IE API to create our selections.
*
* @param {DOMElement|DOMTextNode} node
* @param {object} offsets
*/
function setOffsets(node, offsets) {
var doc = node.ownerDocument || document;
var win = (doc && doc.defaultView) || window; // Edge fails with "Object expected" in some scenarios.
// (For instance: TinyMCE editor used in a list component that supports pasting to add more,
// fails when pasting 100+ items)
if (!win.getSelection) {
return;
}
var selection = win.getSelection();
var length = node.textContent.length;
var start = Math.min(offsets.start, length);
var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
// Flip backward selections, so we can set with a single range.
if (!selection.extend && start > end) {
var temp = end;
end = start;
start = temp;
}
var startMarker = getNodeForCharacterOffset(node, start);
var endMarker = getNodeForCharacterOffset(node, end);
if (startMarker && endMarker) {
if (
selection.rangeCount === 1 &&
selection.anchorNode === startMarker.node &&
selection.anchorOffset === startMarker.offset &&
selection.focusNode === endMarker.node &&
selection.focusOffset === endMarker.offset
) {
return;
}
var range = doc.createRange();
range.setStart(startMarker.node, startMarker.offset);
selection.removeAllRanges();
if (start > end) {
selection.addRange(range);
selection.extend(endMarker.node, endMarker.offset);
} else {
range.setEnd(endMarker.node, endMarker.offset);
selection.addRange(range);
}
}
}
function isTextNode(node) {
return node && node.nodeType === TEXT_NODE;
}
function containsNode(outerNode, innerNode) {
if (!outerNode || !innerNode) {
return false;
} else if (outerNode === innerNode) {
return true;
} else if (isTextNode(outerNode)) {
return false;
} else if (isTextNode(innerNode)) {
return containsNode(outerNode, innerNode.parentNode);
} else if ("contains" in outerNode) {
return outerNode.contains(innerNode);
} else if (outerNode.compareDocumentPosition) {
return !!(outerNode.compareDocumentPosition(innerNode) & 16);
} else {
return false;
}
}
function isInDocument(node) {
return (
node &&
node.ownerDocument &&
containsNode(node.ownerDocument.documentElement, node)
);
}
function isSameOriginFrame(iframe) {
try {
// Accessing the contentDocument of a HTMLIframeElement can cause the browser
// to throw, e.g. if it has a cross-origin src attribute.
// Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
// iframe.contentDocument.defaultView;
// A safety way is to access one of the cross origin properties: Window or Location
// Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
// https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
return typeof iframe.contentWindow.location.href === "string";
} catch (err) {
return false;
}
}
function getActiveElementDeep() {
var win = window;
var element = getActiveElement();
while (element instanceof win.HTMLIFrameElement) {
if (isSameOriginFrame(element)) {
win = element.contentWindow;
} else {
return element;
}
element = getActiveElement(win.document);
}
return element;
}
/**
* @ReactInputSelection: React input selection module. Based on Selection.js,
* but modified to be suitable for react and has a couple of bug fixes (doesn't
* assume buttons have range selections allowed).
* Input selection module for React.
*/
/**
* @hasSelectionCapabilities: we get the element types that support selection
* from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
* and `selectionEnd` rows.
*/
function hasSelectionCapabilities(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
return (
nodeName &&
((nodeName === "input" &&
(elem.type === "text" ||
elem.type === "search" ||
elem.type === "tel" ||
elem.type === "url" ||
elem.type === "password")) ||
nodeName === "textarea" ||
elem.contentEditable === "true")
);
}
function getSelectionInformation() {
var focusedElem = getActiveElementDeep();
return {
focusedElem: focusedElem,
selectionRange: hasSelectionCapabilities(focusedElem)
? getSelection(focusedElem)
: null,
};
}
/**
* @restoreSelection: If any selection information was potentially lost,
* restore it. This is useful when performing operations that could remove dom
* nodes and place them back in, resulting in focus being lost.
*/
function restoreSelection(priorSelectionInformation) {
var curFocusedElem = getActiveElementDeep();
var priorFocusedElem = priorSelectionInformation.focusedElem;
var priorSelectionRange = priorSelectionInformation.selectionRange;
if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
if (
priorSelectionRange !== null &&
hasSelectionCapabilities(priorFocusedElem)
) {
setSelection(priorFocusedElem, priorSelectionRange);
} // Focusing a node can change the scroll position, which is undesirable
var ancestors = [];
var ancestor = priorFocusedElem;
while ((ancestor = ancestor.parentNode)) {
if (ancestor.nodeType === ELEMENT_NODE) {
ancestors.push({
element: ancestor,
left: ancestor.scrollLeft,
top: ancestor.scrollTop,
});
}
}
if (typeof priorFocusedElem.focus === "function") {
priorFocusedElem.focus();
}
for (var i = 0; i < ancestors.length; i++) {
var info = ancestors[i];
info.element.scrollLeft = info.left;
info.element.scrollTop = info.top;
}
}
}
/**
* @getSelection: Gets the selection bounds of a focused textarea, input or
* contentEditable node.
* -@input: Look up selection bounds of this input
* -@return {start: selectionStart, end: selectionEnd}
*/
function getSelection(input) {
var selection;
if ("selectionStart" in input) {
// Modern browser with input or textarea.
selection = {
start: input.selectionStart,
end: input.selectionEnd,
};
} else {
// Content editable or old IE textarea.
selection = getOffsets(input);
}
return (
selection || {
start: 0,
end: 0,
}
);
}
/**
* @setSelection: Sets the selection bounds of a textarea or input and focuses
* the input.
* -@input Set selection bounds of this input or textarea
* -@offsets Object of same form that is returned from get*
*/
function setSelection(input, offsets) {
var start = offsets.start;
var end = offsets.end;
if (end === undefined) {
end = start;
}
if ("selectionStart" in input) {
input.selectionStart = start;
input.selectionEnd = Math.min(end, input.value.length);
} else {
setOffsets(input, offsets);
}
}
var skipSelectionChangeEvent =
canUseDOM && "documentMode" in document && document.documentMode <= 11;
function registerEvents$3() {
registerTwoPhaseEvent("onSelect", [
"focusout",
"contextmenu",
"dragend",
"focusin",
"keydown",
"keyup",
"mousedown",
"mouseup",
"selectionchange",
]);
}
var activeElement$1 = null;
var activeElementInst$1 = null;
var lastSelection = null;
var mouseDown = false;
/**
* Get an object which is a unique representation of the current selection.
*
* The return value will not be consistent across nodes or browsers, but
* two identical selections on the same node will return identical objects.
*/
function getSelection$1(node) {
if ("selectionStart" in node && hasSelectionCapabilities(node)) {
return {
start: node.selectionStart,
end: node.selectionEnd,
};
} else {
var win =
(node.ownerDocument && node.ownerDocument.defaultView) || window;
var selection = win.getSelection();
return {
anchorNode: selection.anchorNode,
anchorOffset: selection.anchorOffset,
focusNode: selection.focusNode,
focusOffset: selection.focusOffset,
};
}
}
/**
* Get document associated with the event target.
*/
function getEventTargetDocument(eventTarget) {
return eventTarget.window === eventTarget
? eventTarget.document
: eventTarget.nodeType === DOCUMENT_NODE
? eventTarget
: eventTarget.ownerDocument;
}
/**
* Poll selection to see whether it's changed.
*
* @param {object} nativeEvent
* @param {object} nativeEventTarget
* @return {?SyntheticEvent}
*/
function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
// Ensure we have the right element, and that the user is not dragging a
// selection (this matches native `select` event behavior). In HTML5, select
// fires only on input and textarea thus if there's no focused element we
// won't dispatch.
var doc = getEventTargetDocument(nativeEventTarget);
if (
mouseDown ||
activeElement$1 == null ||
activeElement$1 !== getActiveElement(doc)
) {
return;
} // Only fire when selection has actually changed.
var currentSelection = getSelection$1(activeElement$1);
if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
lastSelection = currentSelection;
var listeners = accumulateTwoPhaseListeners(
activeElementInst$1,
"onSelect",
);
if (listeners.length > 0) {
var event = new SyntheticEvent(
"onSelect",
"select",
null,
nativeEvent,
nativeEventTarget,
);
dispatchQueue.push({
event: event,
listeners: listeners,
});
event.target = activeElement$1;
}
}
}
/**
* This plugin creates an `onSelect` event that normalizes select events
* across form elements.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - contentEditable
*
* This differs from native browser implementations in the following ways:
* - Fires on contentEditable fields as well as inputs.
* - Fires for collapsed selection.
* - Fires after user input.
*/
function extractEvents$3(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
switch (domEventName) {
// Track the input node that has focus.
case "focusin":
if (
isTextInputElement(targetNode) ||
targetNode.contentEditable === "true"
) {
activeElement$1 = targetNode;
activeElementInst$1 = targetInst;
lastSelection = null;
}
break;
case "focusout":
activeElement$1 = null;
activeElementInst$1 = null;
lastSelection = null;
break;
// Don't fire the event while the user is dragging. This matches the
// semantics of the native select event.
case "mousedown":
mouseDown = true;
break;
case "contextmenu":
case "mouseup":
case "dragend":
mouseDown = false;
constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
break;
// Chrome and IE fire non-standard event when selection is changed (and
// sometimes when it hasn't). IE's event fires out of order with respect
// to key and input events on deletion, so we discard it.
//
// Firefox doesn't support selectionchange, so check selection status
// after each key entry. The selection changes after keydown and before
// keyup, but we check on keydown as well in the case of holding down a
// key, when multiple keydown events are fired but only one keyup is.
// This is also our approach for IE handling, for the reason above.
case "selectionchange":
if (skipSelectionChangeEvent) {
break;
}
// falls through
case "keydown":
case "keyup":
constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
}
}
function extractEvents$4(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
var reactName = topLevelEventsToReactNames.get(domEventName);
if (reactName === undefined) {
return;
}
var SyntheticEventCtor = SyntheticEvent;
var reactEventType = domEventName;
switch (domEventName) {
case "keypress":
// Firefox creates a keypress event for function keys too. This removes
// the unwanted keypress events. Enter is however both printable and
// non-printable. One would expect Tab to be as well (but it isn't).
if (getEventCharCode(nativeEvent) === 0) {
return;
}
/* falls through */
case "keydown":
case "keyup":
SyntheticEventCtor = SyntheticKeyboardEvent;
break;
case "focusin":
reactEventType = "focus";
SyntheticEventCtor = SyntheticFocusEvent;
break;
case "focusout":
reactEventType = "blur";
SyntheticEventCtor = SyntheticFocusEvent;
break;
case "beforeblur":
case "afterblur":
SyntheticEventCtor = SyntheticFocusEvent;
break;
case "click":
// Firefox creates a click event on right mouse clicks. This removes the
// unwanted click events.
if (nativeEvent.button === 2) {
return;
}
/* falls through */
case "auxclick":
case "dblclick":
case "mousedown":
case "mousemove":
case "mouseup": // TODO: Disabled elements should not respond to mouse events
/* falls through */
case "mouseout":
case "mouseover":
case "contextmenu":
SyntheticEventCtor = SyntheticMouseEvent;
break;
case "drag":
case "dragend":
case "dragenter":
case "dragexit":
case "dragleave":
case "dragover":
case "dragstart":
case "drop":
SyntheticEventCtor = SyntheticDragEvent;
break;
case "touchcancel":
case "touchend":
case "touchmove":
case "touchstart":
SyntheticEventCtor = SyntheticTouchEvent;
break;
case ANIMATION_END:
case ANIMATION_ITERATION:
case ANIMATION_START:
SyntheticEventCtor = SyntheticAnimationEvent;
break;
case TRANSITION_END:
SyntheticEventCtor = SyntheticTransitionEvent;
break;
case "scroll":
SyntheticEventCtor = SyntheticUIEvent;
break;
case "wheel":
SyntheticEventCtor = SyntheticWheelEvent;
break;
case "copy":
case "cut":
case "paste":
SyntheticEventCtor = SyntheticClipboardEvent;
break;
case "gotpointercapture":
case "lostpointercapture":
case "pointercancel":
case "pointerdown":
case "pointermove":
case "pointerout":
case "pointerover":
case "pointerup":
SyntheticEventCtor = SyntheticPointerEvent;
break;
}
var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
{
// Some events don't bubble in the browser.
// In the past, React has always bubbled them, but this can be surprising.
// We're going to try aligning closer to the browser behavior by not bubbling
// them in React either. We'll start by not bubbling onScroll, and then expand.
var accumulateTargetOnly =
!inCapturePhase && // TODO: ideally, we'd eventually add all events from
// nonDelegatedEvents list in DOMPluginEventSystem.
// Then we can remove this special list.
// This is a breaking change that can wait until React 18.
domEventName === "scroll";
var _listeners = accumulateSinglePhaseListeners(
targetInst,
reactName,
nativeEvent.type,
inCapturePhase,
accumulateTargetOnly,
);
if (_listeners.length > 0) {
// Intentionally create event lazily.
var _event = new SyntheticEventCtor(
reactName,
reactEventType,
null,
nativeEvent,
nativeEventTarget,
);
dispatchQueue.push({
event: _event,
listeners: _listeners,
});
}
}
}
// TODO: remove top-level side effect.
registerSimpleEvents();
registerEvents$2();
registerEvents$1();
registerEvents$3();
registerEvents();
function extractEvents$5(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
targetContainer,
) {
// TODO: we should remove the concept of a "SimpleEventPlugin".
// This is the basic functionality of the event system. All
// the other plugins are essentially polyfills. So the plugin
// should probably be inlined somewhere and have its logic
// be core the to event system. This would potentially allow
// us to ship builds of React without the polyfilled plugins below.
extractEvents$4(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
);
var shouldProcessPolyfillPlugins =
(eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
// event's native "bubble" phase, which means that we're
// not in the capture phase. That's because we emulate
// the capture phase here still. This is a trade-off,
// because in an ideal world we would not emulate and use
// the phases properly, like we do with the SimpleEvent
// plugin. However, the plugins below either expect
// emulation (EnterLeave) or use state localized to that
// plugin (BeforeInput, Change, Select). The state in
// these modules complicates things, as you'll essentially
// get the case where the capture phase event might change
// state, only for the following bubble event to come in
// later and not trigger anything as the state now
// invalidates the heuristics of the event plugin. We
// could alter all these plugins to work in such ways, but
// that might cause other unknown side-effects that we
// can't forsee right now.
if (shouldProcessPolyfillPlugins) {
extractEvents$2(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
);
extractEvents$1(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
);
extractEvents$3(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
);
extractEvents(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
);
}
} // List of events that need to be individually attached to media elements.
var mediaEventTypes = [
"abort",
"canplay",
"canplaythrough",
"durationchange",
"emptied",
"encrypted",
"ended",
"error",
"loadeddata",
"loadedmetadata",
"loadstart",
"pause",
"play",
"playing",
"progress",
"ratechange",
"seeked",
"seeking",
"stalled",
"suspend",
"timeupdate",
"volumechange",
"waiting",
]; // We should not delegate these events to the container, but rather
// set them on the actual target element itself. This is primarily
// because these events do not consistently bubble in the DOM.
var nonDelegatedEvents = new Set(
["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
mediaEventTypes,
),
);
function executeDispatch(event, listener, currentTarget) {
var type = event.type || "unknown-event";
event.currentTarget = currentTarget;
invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
event.currentTarget = null;
}
function processDispatchQueueItemsInOrder(
event,
dispatchListeners,
inCapturePhase,
) {
var previousInstance;
if (inCapturePhase) {
for (var i = dispatchListeners.length - 1; i >= 0; i--) {
var _dispatchListeners$i = dispatchListeners[i],
instance = _dispatchListeners$i.instance,
currentTarget = _dispatchListeners$i.currentTarget,
listener = _dispatchListeners$i.listener;
if (instance !== previousInstance && event.isPropagationStopped()) {
return;
}
executeDispatch(event, listener, currentTarget);
previousInstance = instance;
}
} else {
for (var _i = 0; _i < dispatchListeners.length; _i++) {
var _dispatchListeners$_i = dispatchListeners[_i],
_instance = _dispatchListeners$_i.instance,
_currentTarget = _dispatchListeners$_i.currentTarget,
_listener = _dispatchListeners$_i.listener;
if (_instance !== previousInstance && event.isPropagationStopped()) {
return;
}
executeDispatch(event, _listener, _currentTarget);
previousInstance = _instance;
}
}
}
function processDispatchQueue(dispatchQueue, eventSystemFlags) {
var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
for (var i = 0; i < dispatchQueue.length; i++) {
var _dispatchQueue$i = dispatchQueue[i],
event = _dispatchQueue$i.event,
listeners = _dispatchQueue$i.listeners;
processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); // event system doesn't use pooling.
} // This would be a good time to rethrow if any of the event handlers threw.
rethrowCaughtError();
}
function dispatchEventsForPlugins(
domEventName,
eventSystemFlags,
nativeEvent,
targetInst,
targetContainer,
) {
var nativeEventTarget = getEventTarget(nativeEvent);
var dispatchQueue = [];
extractEvents$5(
dispatchQueue,
domEventName,
targetInst,
nativeEvent,
nativeEventTarget,
eventSystemFlags,
);
processDispatchQueue(dispatchQueue, eventSystemFlags);
}
function listenToNonDelegatedEvent(domEventName, targetElement) {
var isCapturePhaseListener = false;
var listenerSet = getEventListenerSet(targetElement);
var listenerSetKey = getListenerSetKey(
domEventName,
isCapturePhaseListener,
);
if (!listenerSet.has(listenerSetKey)) {
addTrappedEventListener(
targetElement,
domEventName,
IS_NON_DELEGATED,
isCapturePhaseListener,
);
listenerSet.add(listenerSetKey);
}
}
var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
function listenToAllSupportedEvents(rootContainerElement) {
{
if (rootContainerElement[listeningMarker]) {
// Performance optimization: don't iterate through events
// for the same portal container or root node more than once.
// TODO: once we remove the flag, we may be able to also
// remove some of the bookkeeping maps used for laziness.
return;
}
rootContainerElement[listeningMarker] = true;
allNativeEvents.forEach(function (domEventName) {
if (!nonDelegatedEvents.has(domEventName)) {
listenToNativeEvent(domEventName, false, rootContainerElement, null);
}
listenToNativeEvent(domEventName, true, rootContainerElement, null);
});
}
}
function listenToNativeEvent(
domEventName,
isCapturePhaseListener,
rootContainerElement,
targetElement,
) {
var eventSystemFlags =
arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
var target = rootContainerElement; // selectionchange needs to be attached to the document
// otherwise it won't capture incoming events that are only
// triggered on the document directly.
if (
domEventName === "selectionchange" &&
rootContainerElement.nodeType !== DOCUMENT_NODE
) {
target = rootContainerElement.ownerDocument;
} // If the event can be delegated (or is capture phase), we can
// register it to the root container. Otherwise, we should
// register the event to the target element and mark it as
// a non-delegated event.
if (
targetElement !== null &&
!isCapturePhaseListener &&
nonDelegatedEvents.has(domEventName)
) {
// For all non-delegated events, apart from scroll, we attach
// their event listeners to the respective elements that their
// events fire on. That means we can skip this step, as event
// listener has already been added previously. However, we
// special case the scroll event because the reality is that any
// element can scroll.
// TODO: ideally, we'd eventually apply the same logic to all
// events from the nonDelegatedEvents list. Then we can remove
// this special case and use the same logic for all events.
if (domEventName !== "scroll") {
return;
}
eventSystemFlags |= IS_NON_DELEGATED;
target = targetElement;
}
var listenerSet = getEventListenerSet(target);
var listenerSetKey = getListenerSetKey(
domEventName,
isCapturePhaseListener,
); // If the listener entry is empty or we should upgrade, then
// we need to trap an event listener onto the target.
if (!listenerSet.has(listenerSetKey)) {
if (isCapturePhaseListener) {
eventSystemFlags |= IS_CAPTURE_PHASE;
}
addTrappedEventListener(
target,
domEventName,
eventSystemFlags,
isCapturePhaseListener,
);
listenerSet.add(listenerSetKey);
}
}
function addTrappedEventListener(
targetContainer,
domEventName,
eventSystemFlags,
isCapturePhaseListener,
isDeferredListenerForLegacyFBSupport,
) {
var listener = createEventListenerWrapperWithPriority(
targetContainer,
domEventName,
eventSystemFlags,
); // If passive option is not supported, then the event will be
// active and not passive.
var isPassiveListener = undefined;
if (passiveBrowserEventsSupported) {
// Browsers introduced an intervention, making these events
// passive by default on document. React doesn't bind them
// to document anymore, but changing this now would undo
// the performance wins from the change. So we emulate
// the existing behavior manually on the roots now.
// https://github.com/facebook/react/issues/19651
if (
domEventName === "touchstart" ||
domEventName === "touchmove" ||
domEventName === "wheel"
) {
isPassiveListener = true;
}
}
targetContainer = targetContainer;
var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
if (isCapturePhaseListener) {
if (isPassiveListener !== undefined) {
unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
targetContainer,
domEventName,
listener,
isPassiveListener,
);
} else {
unsubscribeListener = addEventCaptureListener(
targetContainer,
domEventName,
listener,
);
}
} else {
if (isPassiveListener !== undefined) {
unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
targetContainer,
domEventName,
listener,
isPassiveListener,
);
} else {
unsubscribeListener = addEventBubbleListener(
targetContainer,
domEventName,
listener,
);
}
}
}
function isMatchingRootContainer(grandContainer, targetContainer) {
return (
grandContainer === targetContainer ||
(grandContainer.nodeType === COMMENT_NODE &&
grandContainer.parentNode === targetContainer)
);
}
function dispatchEventForPluginEventSystem(
domEventName,
eventSystemFlags,
nativeEvent,
targetInst,
targetContainer,
) {
var ancestorInst = targetInst;
if (
(eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
(eventSystemFlags & IS_NON_DELEGATED) === 0
) {
var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
if (targetInst !== null) {
// The below logic attempts to work out if we need to change
// the target fiber to a different ancestor. We had similar logic
// in the legacy event system, except the big difference between
// systems is that the modern event system now has an event listener
// attached to each React Root and React Portal Root. Together,
// the DOM nodes representing these roots are the "rootContainer".
// To figure out which ancestor instance we should use, we traverse
// up the fiber tree from the target instance and attempt to find
// root boundaries that match that of our current "rootContainer".
// If we find that "rootContainer", we find the parent fiber
// sub-tree for that root and make that our ancestor instance.
var node = targetInst;
mainLoop: while (true) {
if (node === null) {
return;
}
var nodeTag = node.tag;
if (nodeTag === HostRoot || nodeTag === HostPortal) {
var container = node.stateNode.containerInfo;
if (isMatchingRootContainer(container, targetContainerNode)) {
break;
}
if (nodeTag === HostPortal) {
// The target is a portal, but it's not the rootContainer we're looking for.
// Normally portals handle their own events all the way down to the root.
// So we should be able to stop now. However, we don't know if this portal
// was part of *our* root.
var grandNode = node.return;
while (grandNode !== null) {
var grandTag = grandNode.tag;
if (grandTag === HostRoot || grandTag === HostPortal) {
var grandContainer = grandNode.stateNode.containerInfo;
if (
isMatchingRootContainer(grandContainer, targetContainerNode)
) {
// This is the rootContainer we're looking for and we found it as
// a parent of the Portal. That means we can ignore it because the
// Portal will bubble through to us.
return;
}
}
grandNode = grandNode.return;
}
} // Now we need to find it's corresponding host fiber in the other
// tree. To do this we can use getClosestInstanceFromNode, but we
// need to validate that the fiber is a host instance, otherwise
// we need to traverse up through the DOM till we find the correct
// node that is from the other tree.
while (container !== null) {
var parentNode = getClosestInstanceFromNode(container);
if (parentNode === null) {
return;
}
var parentTag = parentNode.tag;
if (parentTag === HostComponent || parentTag === HostText) {
node = ancestorInst = parentNode;
continue mainLoop;
}
container = container.parentNode;
}
}
node = node.return;
}
}
}
batchedEventUpdates(function () {
return dispatchEventsForPlugins(
domEventName,
eventSystemFlags,
nativeEvent,
ancestorInst,
);
});
}
function createDispatchListener(instance, listener, currentTarget) {
return {
instance: instance,
listener: listener,
currentTarget: currentTarget,
};
}
function accumulateSinglePhaseListeners(
targetFiber,
reactName,
nativeEventType,
inCapturePhase,
accumulateTargetOnly,
) {
var captureName = reactName !== null ? reactName + "Capture" : null;
var reactEventName = inCapturePhase ? captureName : reactName;
var listeners = [];
var instance = targetFiber;
var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
while (instance !== null) {
var _instance2 = instance,
stateNode = _instance2.stateNode,
tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
if (tag === HostComponent && stateNode !== null) {
lastHostComponent = stateNode; // createEventHandle listeners
if (reactEventName !== null) {
var listener = getListener(instance, reactEventName);
if (listener != null) {
listeners.push(
createDispatchListener(instance, listener, lastHostComponent),
);
}
}
} // If we are only accumulating events for the target, then we don't
// continue to propagate through the React fiber tree to find other
// listeners.
if (accumulateTargetOnly) {
break;
}
instance = instance.return;
}
return listeners;
} // We should only use this function for:
// - BeforeInputEventPlugin
// - ChangeEventPlugin
// - SelectEventPlugin
// This is because we only process these plugins
// in the bubble phase, so we need to accumulate two
// phase event listeners (via emulation).
function accumulateTwoPhaseListeners(targetFiber, reactName) {
var captureName = reactName + "Capture";
var listeners = [];
var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
while (instance !== null) {
var _instance3 = instance,
stateNode = _instance3.stateNode,
tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
if (tag === HostComponent && stateNode !== null) {
var currentTarget = stateNode;
var captureListener = getListener(instance, captureName);
if (captureListener != null) {
listeners.unshift(
createDispatchListener(instance, captureListener, currentTarget),
);
}
var bubbleListener = getListener(instance, reactName);
if (bubbleListener != null) {
listeners.push(
createDispatchListener(instance, bubbleListener, currentTarget),
);
}
}
instance = instance.return;
}
return listeners;
}
function getParent(inst) {
if (inst === null) {
return null;
}
do {
inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
// That is depending on if we want nested subtrees (layers) to bubble
// events to their parent. We could also go through parentNode on the
// host node but that wouldn't work for React Native and doesn't let us
// do the portal feature.
} while (inst && inst.tag !== HostComponent);
if (inst) {
return inst;
}
return null;
}
/**
* Return the lowest common ancestor of A and B, or null if they are in
* different trees.
*/
function getLowestCommonAncestor(instA, instB) {
var nodeA = instA;
var nodeB = instB;
var depthA = 0;
for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
depthA++;
}
var depthB = 0;
for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
depthB++;
} // If A is deeper, crawl up.
while (depthA - depthB > 0) {
nodeA = getParent(nodeA);
depthA--;
} // If B is deeper, crawl up.
while (depthB - depthA > 0) {
nodeB = getParent(nodeB);
depthB--;
} // Walk in lockstep until we find a match.
var depth = depthA;
while (depth--) {
if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
return nodeA;
}
nodeA = getParent(nodeA);
nodeB = getParent(nodeB);
}
return null;
}
function accumulateEnterLeaveListenersForEvent(
dispatchQueue,
event,
target,
common,
inCapturePhase,
) {
var registrationName = event._reactName;
var listeners = [];
var instance = target;
while (instance !== null) {
if (instance === common) {
break;
}
var _instance4 = instance,
alternate = _instance4.alternate,
stateNode = _instance4.stateNode,
tag = _instance4.tag;
if (alternate !== null && alternate === common) {
break;
}
if (tag === HostComponent && stateNode !== null) {
var currentTarget = stateNode;
if (inCapturePhase) {
var captureListener = getListener(instance, registrationName);
if (captureListener != null) {
listeners.unshift(
createDispatchListener(instance, captureListener, currentTarget),
);
}
} else if (!inCapturePhase) {
var bubbleListener = getListener(instance, registrationName);
if (bubbleListener != null) {
listeners.push(
createDispatchListener(instance, bubbleListener, currentTarget),
);
}
}
}
instance = instance.return;
}
if (listeners.length !== 0) {
dispatchQueue.push({
event: event,
listeners: listeners,
});
}
} // We should only use this function for:
// - EnterLeaveEventPlugin
// This is because we only process this plugin
// in the bubble phase, so we need to accumulate two
// phase event listeners.
function accumulateEnterLeaveTwoPhaseListeners(
dispatchQueue,
leaveEvent,
enterEvent,
from,
to,
) {
var common = from && to ? getLowestCommonAncestor(from, to) : null;
if (from !== null) {
accumulateEnterLeaveListenersForEvent(
dispatchQueue,
leaveEvent,
from,
common,
false,
);
}
if (to !== null && enterEvent !== null) {
accumulateEnterLeaveListenersForEvent(
dispatchQueue,
enterEvent,
to,
common,
true,
);
}
}
function getListenerSetKey(domEventName, capture) {
return domEventName + "__" + (capture ? "capture" : "bubble");
}
var didWarnInvalidHydration = false;
var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
var SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning";
var AUTOFOCUS = "autoFocus";
var CHILDREN = "children";
var STYLE = "style";
var HTML$1 = "__html";
var HTML_NAMESPACE$1 = Namespaces.html;
var warnedUnknownTags;
var suppressHydrationWarning;
var validatePropertiesInDevelopment;
var warnForTextDifference;
var warnForPropDifference;
var warnForExtraAttributes;
var warnForInvalidEventListener;
var canDiffStyleForHydrationWarning;
var normalizeMarkupForTextOrAttribute;
var normalizeHTML;
{
warnedUnknownTags = {
// There are working polyfills for <dialog>. Let people use it.
dialog: true,
// Electron ships a custom <webview> tag to display external web content in
// an isolated frame and process.
// This tag is not present in non Electron environments such as JSDom which
// is often used for testing purposes.
// @see https://electronjs.org/docs/api/webview-tag
webview: true,
};
validatePropertiesInDevelopment = function (type, props) {
validateProperties(type, props);
validateProperties$1(type, props);
validateProperties$2(type, props, {
registrationNameDependencies: registrationNameDependencies,
possibleRegistrationNames: possibleRegistrationNames,
});
}; // IE 11 parses & normalizes the style attribute as opposed to other
// browsers. It adds spaces and sorts the properties in some
// non-alphabetical order. Handling that would require sorting CSS
// properties in the client & server versions or applying
// `expectedStyle` to a temporary DOM node to read its `style` attribute
// normalized. Since it only affects IE, we're skipping style warnings
// in that browser completely in favor of doing all that work.
// See https://github.com/facebook/react/issues/11807
canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode; // HTML parsing normalizes CR and CRLF to LF.
// It also can turn \u0000 into \uFFFD inside attributes.
// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
// If we have a mismatch, it might be caused by that.
// We will still patch up in this case but not fire the warning.
var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
normalizeMarkupForTextOrAttribute = function (markup) {
var markupString = typeof markup === "string" ? markup : "" + markup;
return markupString
.replace(NORMALIZE_NEWLINES_REGEX, "\n")
.replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
};
warnForTextDifference = function (serverText, clientText) {
if (didWarnInvalidHydration) {
return;
}
var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
if (normalizedServerText === normalizedClientText) {
return;
}
didWarnInvalidHydration = true;
error(
'Text content did not match. Server: "%s" Client: "%s"',
normalizedServerText,
normalizedClientText,
);
};
warnForPropDifference = function (propName, serverValue, clientValue) {
if (didWarnInvalidHydration) {
return;
}
var normalizedClientValue =
normalizeMarkupForTextOrAttribute(clientValue);
var normalizedServerValue =
normalizeMarkupForTextOrAttribute(serverValue);
if (normalizedServerValue === normalizedClientValue) {
return;
}
didWarnInvalidHydration = true;
error(
"Prop `%s` did not match. Server: %s Client: %s",
propName,
JSON.stringify(normalizedServerValue),
JSON.stringify(normalizedClientValue),
);
};
warnForExtraAttributes = function (attributeNames) {
if (didWarnInvalidHydration) {
return;
}
didWarnInvalidHydration = true;
var names = [];
attributeNames.forEach(function (name) {
names.push(name);
});
error("Extra attributes from the server: %s", names);
};
warnForInvalidEventListener = function (registrationName, listener) {
if (listener === false) {
error(
"Expected `%s` listener to be a function, instead got `false`.\n\n" +
"If you used to conditionally omit it with %s={condition && value}, " +
"pass %s={condition ? value : undefined} instead.",
registrationName,
registrationName,
registrationName,
);
} else {
error(
"Expected `%s` listener to be a function, instead got a value of `%s` type.",
registrationName,
typeof listener,
);
}
}; // Parse the HTML and read it back to normalize the HTML string so that it
// can be used for comparison.
normalizeHTML = function (parent, html) {
// We could have created a separate document here to avoid
// re-initializing custom elements if they exist. But this breaks
// how <noscript> is being handled. So we use the same document.
// See the discussion in https://github.com/facebook/react/pull/11157.
var testElement =
parent.namespaceURI === HTML_NAMESPACE$1
? parent.ownerDocument.createElement(parent.tagName)
: parent.ownerDocument.createElementNS(
parent.namespaceURI,
parent.tagName,
);
testElement.innerHTML = html;
return testElement.innerHTML;
};
}
function getOwnerDocumentFromRootContainer(rootContainerElement) {
return rootContainerElement.nodeType === DOCUMENT_NODE
? rootContainerElement
: rootContainerElement.ownerDocument;
}
function noop() {}
function trapClickOnNonInteractiveElement(node) {
// Mobile Safari does not fire properly bubble click events on
// non-interactive elements, which means delegated click listeners do not
// fire. The workaround for this bug involves attaching an empty click
// listener on the target node.
// https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
// Just set it using the onclick property so that we don't have to manage any
// bookkeeping for it. Not sure if we need to clear it when the listener is
// removed.
// TODO: Only do this for the relevant Safaris maybe?
node.onclick = noop;
}
function setInitialDOMProperties(
tag,
domElement,
rootContainerElement,
nextProps,
isCustomComponentTag,
) {
for (var propKey in nextProps) {
if (!nextProps.hasOwnProperty(propKey)) {
continue;
}
var nextProp = nextProps[propKey];
if (propKey === STYLE) {
{
if (nextProp) {
// Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp);
}
} // Relies on `updateStylesByID` not mutating `styleUpdates`.
setValueForStyles(domElement, nextProp);
} else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var nextHtml = nextProp ? nextProp[HTML$1] : undefined;
if (nextHtml != null) {
setInnerHTML(domElement, nextHtml);
}
} else if (propKey === CHILDREN) {
if (typeof nextProp === "string") {
// Avoid setting initial textContent when the text is empty. In IE11 setting
// textContent on a <textarea> will cause the placeholder to not
// show within the <textarea> until it has been focused and blurred again.
// https://github.com/facebook/react/issues/6731#issuecomment-254874553
var canSetTextContent = tag !== "textarea" || nextProp !== "";
if (canSetTextContent) {
setTextContent(domElement, nextProp);
}
} else if (typeof nextProp === "number") {
setTextContent(domElement, "" + nextProp);
}
} else if (
propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
propKey === SUPPRESS_HYDRATION_WARNING
);
else if (propKey === AUTOFOCUS);
else if (registrationNameDependencies.hasOwnProperty(propKey)) {
if (nextProp != null) {
if (typeof nextProp !== "function") {
warnForInvalidEventListener(propKey, nextProp);
}
if (propKey === "onScroll") {
listenToNonDelegatedEvent("scroll", domElement);
}
}
} else if (nextProp != null) {
setValueForProperty(
domElement,
propKey,
nextProp,
isCustomComponentTag,
);
}
}
}
function updateDOMProperties(
domElement,
updatePayload,
wasCustomComponentTag,
isCustomComponentTag,
) {
// TODO: Handle wasCustomComponentTag
for (var i = 0; i < updatePayload.length; i += 2) {
var propKey = updatePayload[i];
var propValue = updatePayload[i + 1];
if (propKey === STYLE) {
setValueForStyles(domElement, propValue);
} else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
setInnerHTML(domElement, propValue);
} else if (propKey === CHILDREN) {
setTextContent(domElement, propValue);
} else {
setValueForProperty(
domElement,
propKey,
propValue,
isCustomComponentTag,
);
}
}
}
function createElement(type, props, rootContainerElement, parentNamespace) {
var isCustomComponentTag; // We create tags in the namespace of their parent container, except HTML
// tags get no namespace.
var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerElement);
var domElement;
var namespaceURI = parentNamespace;
if (namespaceURI === HTML_NAMESPACE$1) {
namespaceURI = getIntrinsicNamespace(type);
}
if (namespaceURI === HTML_NAMESPACE$1) {
{
isCustomComponentTag = isCustomComponent(type, props); // Should this check be gated by parent namespace? Not sure we want to
// allow <SVG> or <mATH>.
if (!isCustomComponentTag && type !== type.toLowerCase()) {
error(
"<%s /> is using incorrect casing. " +
"Use PascalCase for React components, " +
"or lowercase for HTML elements.",
type,
);
}
}
if (type === "script") {
// Create the script via .innerHTML so its "parser-inserted" flag is
// set to true and it does not execute
var div = ownerDocument.createElement("div");
div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
// This is guaranteed to yield a script element.
var firstChild = div.firstChild;
domElement = div.removeChild(firstChild);
} else if (typeof props.is === "string") {
// $FlowIssue `createElement` should be updated for Web Components
domElement = ownerDocument.createElement(type, {
is: props.is,
});
} else {
// Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
// See discussion in https://github.com/facebook/react/pull/6896
// and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
domElement = ownerDocument.createElement(type); // Normally attributes are assigned in `setInitialDOMProperties`, however the `multiple` and `size`
// attributes on `select`s needs to be added before `option`s are inserted.
// This prevents:
// - a bug where the `select` does not scroll to the correct option because singular
// `select` elements automatically pick the first item #13222
// - a bug where the `select` set the first item as selected despite the `size` attribute #14239
// See https://github.com/facebook/react/issues/13222
// and https://github.com/facebook/react/issues/14239
if (type === "select") {
var node = domElement;
if (props.multiple) {
node.multiple = true;
} else if (props.size) {
// Setting a size greater than 1 causes a select to behave like `multiple=true`, where
// it is possible that no option is selected.
//
// This is only necessary when a select in "single selection mode".
node.size = props.size;
}
}
}
} else {
domElement = ownerDocument.createElementNS(namespaceURI, type);
}
{
if (namespaceURI === HTML_NAMESPACE$1) {
if (
!isCustomComponentTag &&
Object.prototype.toString.call(domElement) ===
"[object HTMLUnknownElement]" &&
!Object.prototype.hasOwnProperty.call(warnedUnknownTags, type)
) {
warnedUnknownTags[type] = true;
error(
"The tag <%s> is unrecognized in this browser. " +
"If you meant to render a React component, start its name with " +
"an uppercase letter.",
type,
);
}
}
}
return domElement;
}
function createTextNode(text, rootContainerElement) {
return getOwnerDocumentFromRootContainer(
rootContainerElement,
).createTextNode(text);
}
function setInitialProperties(
domElement,
tag,
rawProps,
rootContainerElement,
) {
var isCustomComponentTag = isCustomComponent(tag, rawProps);
{
validatePropertiesInDevelopment(tag, rawProps);
} // TODO: Make sure that we check isMounted before firing any of these events.
var props;
switch (tag) {
case "dialog":
listenToNonDelegatedEvent("cancel", domElement);
listenToNonDelegatedEvent("close", domElement);
props = rawProps;
break;
case "iframe":
case "object":
case "embed":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent("load", domElement);
props = rawProps;
break;
case "video":
case "audio":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for (var i = 0; i < mediaEventTypes.length; i++) {
listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
}
props = rawProps;
break;
case "source":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent("error", domElement);
props = rawProps;
break;
case "img":
case "image":
case "link":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent("error", domElement);
listenToNonDelegatedEvent("load", domElement);
props = rawProps;
break;
case "details":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent("toggle", domElement);
props = rawProps;
break;
case "input":
initWrapperState(domElement, rawProps);
props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "option":
validateProps(domElement, rawProps);
props = getHostProps$1(domElement, rawProps);
break;
case "select":
initWrapperState$1(domElement, rawProps);
props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "textarea":
initWrapperState$2(domElement, rawProps);
props = getHostProps$3(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
default:
props = rawProps;
}
assertValidProps(tag, props);
setInitialDOMProperties(
tag,
domElement,
rootContainerElement,
props,
isCustomComponentTag,
);
switch (tag) {
case "input":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);
postMountWrapper(domElement, rawProps, false);
break;
case "textarea":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);
postMountWrapper$3(domElement);
break;
case "option":
postMountWrapper$1(domElement, rawProps);
break;
case "select":
postMountWrapper$2(domElement, rawProps);
break;
default:
if (typeof props.onClick === "function") {
// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
break;
}
} // Calculate the diff between the two objects.
function diffProperties(
domElement,
tag,
lastRawProps,
nextRawProps,
rootContainerElement,
) {
{
validatePropertiesInDevelopment(tag, nextRawProps);
}
var updatePayload = null;
var lastProps;
var nextProps;
switch (tag) {
case "input":
lastProps = getHostProps(domElement, lastRawProps);
nextProps = getHostProps(domElement, nextRawProps);
updatePayload = [];
break;
case "option":
lastProps = getHostProps$1(domElement, lastRawProps);
nextProps = getHostProps$1(domElement, nextRawProps);
updatePayload = [];
break;
case "select":
lastProps = getHostProps$2(domElement, lastRawProps);
nextProps = getHostProps$2(domElement, nextRawProps);
updatePayload = [];
break;
case "textarea":
lastProps = getHostProps$3(domElement, lastRawProps);
nextProps = getHostProps$3(domElement, nextRawProps);
updatePayload = [];
break;
default:
lastProps = lastRawProps;
nextProps = nextRawProps;
if (
typeof lastProps.onClick !== "function" &&
typeof nextProps.onClick === "function"
) {
// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
break;
}
assertValidProps(tag, nextProps);
var propKey;
var styleName;
var styleUpdates = null;
for (propKey in lastProps) {
if (
nextProps.hasOwnProperty(propKey) ||
!lastProps.hasOwnProperty(propKey) ||
lastProps[propKey] == null
) {
continue;
}
if (propKey === STYLE) {
var lastStyle = lastProps[propKey];
for (styleName in lastStyle) {
if (lastStyle.hasOwnProperty(styleName)) {
if (!styleUpdates) {
styleUpdates = {};
}
styleUpdates[styleName] = "";
}
}
} else if (
propKey === DANGEROUSLY_SET_INNER_HTML ||
propKey === CHILDREN
);
else if (
propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
propKey === SUPPRESS_HYDRATION_WARNING
);
else if (propKey === AUTOFOCUS);
else if (registrationNameDependencies.hasOwnProperty(propKey)) {
// This is a special case. If any listener updates we need to ensure
// that the "current" fiber pointer gets updated so we need a commit
// to update this element.
if (!updatePayload) {
updatePayload = [];
}
} else {
// For all other deleted properties we add it to the queue. We use
// the allowed property list in the commit phase instead.
(updatePayload = updatePayload || []).push(propKey, null);
}
}
for (propKey in nextProps) {
var nextProp = nextProps[propKey];
var lastProp = lastProps != null ? lastProps[propKey] : undefined;
if (
!nextProps.hasOwnProperty(propKey) ||
nextProp === lastProp ||
(nextProp == null && lastProp == null)
) {
continue;
}
if (propKey === STYLE) {
{
if (nextProp) {
// Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp);
}
}
if (lastProp) {
// Unset styles on `lastProp` but not on `nextProp`.
for (styleName in lastProp) {
if (
lastProp.hasOwnProperty(styleName) &&
(!nextProp || !nextProp.hasOwnProperty(styleName))
) {
if (!styleUpdates) {
styleUpdates = {};
}
styleUpdates[styleName] = "";
}
} // Update styles that changed since `lastProp`.
for (styleName in nextProp) {
if (
nextProp.hasOwnProperty(styleName) &&
lastProp[styleName] !== nextProp[styleName]
) {
if (!styleUpdates) {
styleUpdates = {};
}
styleUpdates[styleName] = nextProp[styleName];
}
}
} else {
// Relies on `updateStylesByID` not mutating `styleUpdates`.
if (!styleUpdates) {
if (!updatePayload) {
updatePayload = [];
}
updatePayload.push(propKey, styleUpdates);
}
styleUpdates = nextProp;
}
} else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var nextHtml = nextProp ? nextProp[HTML$1] : undefined;
var lastHtml = lastProp ? lastProp[HTML$1] : undefined;
if (nextHtml != null) {
if (lastHtml !== nextHtml) {
(updatePayload = updatePayload || []).push(propKey, nextHtml);
}
}
} else if (propKey === CHILDREN) {
if (typeof nextProp === "string" || typeof nextProp === "number") {
(updatePayload = updatePayload || []).push(propKey, "" + nextProp);
}
} else if (
propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
propKey === SUPPRESS_HYDRATION_WARNING
);
else if (registrationNameDependencies.hasOwnProperty(propKey)) {
if (nextProp != null) {
// We eagerly listen to this even though we haven't committed yet.
if (typeof nextProp !== "function") {
warnForInvalidEventListener(propKey, nextProp);
}
if (propKey === "onScroll") {
listenToNonDelegatedEvent("scroll", domElement);
}
}
if (!updatePayload && lastProp !== nextProp) {
// This is a special case. If any listener updates we need to ensure
// that the "current" props pointer gets updated so we need a commit
// to update this element.
updatePayload = [];
}
} else if (
typeof nextProp === "object" &&
nextProp !== null &&
nextProp.$$typeof === REACT_OPAQUE_ID_TYPE
) {
// If we encounter useOpaqueReference's opaque object, this means we are hydrating.
// In this case, call the opaque object's toString function which generates a new client
// ID so client and server IDs match and throws to rerender.
nextProp.toString();
} else {
// For any other property we always add it to the queue and then we
// filter it out using the allowed property list during the commit.
(updatePayload = updatePayload || []).push(propKey, nextProp);
}
}
if (styleUpdates) {
{
validateShorthandPropertyCollisionInDev(styleUpdates, nextProps[STYLE]);
}
(updatePayload = updatePayload || []).push(STYLE, styleUpdates);
}
return updatePayload;
} // Apply the diff.
function updateProperties(
domElement,
updatePayload,
tag,
lastRawProps,
nextRawProps,
) {
// Update checked *before* name.
// In the middle of an update, it is possible to have multiple checked.
// When a checked radio tries to change name, browser makes another radio's checked false.
if (
tag === "input" &&
nextRawProps.type === "radio" &&
nextRawProps.name != null
) {
updateChecked(domElement, nextRawProps);
}
var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);
var isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.
updateDOMProperties(
domElement,
updatePayload,
wasCustomComponentTag,
isCustomComponentTag,
); // TODO: Ensure that an update gets scheduled if any of the special props
// changed.
switch (tag) {
case "input":
// Update the wrapper around inputs *after* updating props. This has to
// happen after `updateDOMProperties`. Otherwise HTML5 input validations
// raise warnings and prevent the new value from being assigned.
updateWrapper(domElement, nextRawProps);
break;
case "textarea":
updateWrapper$1(domElement, nextRawProps);
break;
case "select":
// <select> value update needs to occur after <option> children
// reconciliation
postUpdateWrapper(domElement, nextRawProps);
break;
}
}
function getPossibleStandardName(propName) {
{
var lowerCasedName = propName.toLowerCase();
if (!possibleStandardNames.hasOwnProperty(lowerCasedName)) {
return null;
}
return possibleStandardNames[lowerCasedName] || null;
}
}
function diffHydratedProperties(
domElement,
tag,
rawProps,
parentNamespace,
rootContainerElement,
) {
var isCustomComponentTag;
var extraAttributeNames;
{
suppressHydrationWarning = rawProps[SUPPRESS_HYDRATION_WARNING] === true;
isCustomComponentTag = isCustomComponent(tag, rawProps);
validatePropertiesInDevelopment(tag, rawProps);
} // TODO: Make sure that we check isMounted before firing any of these events.
switch (tag) {
case "dialog":
listenToNonDelegatedEvent("cancel", domElement);
listenToNonDelegatedEvent("close", domElement);
break;
case "iframe":
case "object":
case "embed":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent("load", domElement);
break;
case "video":
case "audio":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for (var i = 0; i < mediaEventTypes.length; i++) {
listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
}
break;
case "source":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent("error", domElement);
break;
case "img":
case "image":
case "link":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent("error", domElement);
listenToNonDelegatedEvent("load", domElement);
break;
case "details":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent("toggle", domElement);
break;
case "input":
initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "option":
validateProps(domElement, rawProps);
break;
case "select":
initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "textarea":
initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
// listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
}
assertValidProps(tag, rawProps);
{
extraAttributeNames = new Set();
var attributes = domElement.attributes;
for (var _i = 0; _i < attributes.length; _i++) {
var name = attributes[_i].name.toLowerCase();
switch (name) {
// Built-in SSR attribute is allowed
case "data-reactroot":
break;
// Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
case "value":
break;
case "checked":
break;
case "selected":
break;
default:
// Intentionally use the original name.
// See discussion in https://github.com/facebook/react/pull/10676.
extraAttributeNames.add(attributes[_i].name);
}
}
}
var updatePayload = null;
for (var propKey in rawProps) {
if (!rawProps.hasOwnProperty(propKey)) {
continue;
}
var nextProp = rawProps[propKey];
if (propKey === CHILDREN) {
// For text content children we compare against textContent. This
// might match additional HTML that is hidden when we read it using
// textContent. E.g. "foo" will match "f<span>oo</span>" but that still
// satisfies our requirement. Our requirement is not to produce perfect
// HTML and attributes. Ideally we should preserve structure but it's
// ok not to if the visible content is still enough to indicate what
// even listeners these nodes might be wired up to.
// TODO: Warn if there is more than a single textNode as a child.
// TODO: Should we use domElement.firstChild.nodeValue to compare?
if (typeof nextProp === "string") {
if (domElement.textContent !== nextProp) {
if (!suppressHydrationWarning) {
warnForTextDifference(domElement.textContent, nextProp);
}
updatePayload = [CHILDREN, nextProp];
}
} else if (typeof nextProp === "number") {
if (domElement.textContent !== "" + nextProp) {
if (!suppressHydrationWarning) {
warnForTextDifference(domElement.textContent, nextProp);
}
updatePayload = [CHILDREN, "" + nextProp];
}
}
} else if (registrationNameDependencies.hasOwnProperty(propKey)) {
if (nextProp != null) {
if (typeof nextProp !== "function") {
warnForInvalidEventListener(propKey, nextProp);
}
if (propKey === "onScroll") {
listenToNonDelegatedEvent("scroll", domElement);
}
}
} else if (
// Convince Flow we've calculated it (it's DEV-only in this method.)
typeof isCustomComponentTag === "boolean"
) {
// Validate that the properties correspond to their expected values.
var serverValue = void 0;
var propertyInfo = getPropertyInfo(propKey);
if (suppressHydrationWarning);
else if (
propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
propKey === SUPPRESS_HYDRATION_WARNING || // Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
propKey === "value" ||
propKey === "checked" ||
propKey === "selected"
);
else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var serverHTML = domElement.innerHTML;
var nextHtml = nextProp ? nextProp[HTML$1] : undefined;
if (nextHtml != null) {
var expectedHTML = normalizeHTML(domElement, nextHtml);
if (expectedHTML !== serverHTML) {
warnForPropDifference(propKey, serverHTML, expectedHTML);
}
}
} else if (propKey === STYLE) {
// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey);
if (canDiffStyleForHydrationWarning) {
var expectedStyle = createDangerousStringForStyles(nextProp);
serverValue = domElement.getAttribute("style");
if (expectedStyle !== serverValue) {
warnForPropDifference(propKey, serverValue, expectedStyle);
}
}
} else if (isCustomComponentTag) {
// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase());
serverValue = getValueForAttribute(domElement, propKey, nextProp);
if (nextProp !== serverValue) {
warnForPropDifference(propKey, serverValue, nextProp);
}
} else if (
!shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) &&
!shouldRemoveAttribute(
propKey,
nextProp,
propertyInfo,
isCustomComponentTag,
)
) {
var isMismatchDueToBadCasing = false;
if (propertyInfo !== null) {
// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propertyInfo.attributeName);
serverValue = getValueForProperty(
domElement,
propKey,
nextProp,
propertyInfo,
);
} else {
var ownNamespace = parentNamespace;
if (ownNamespace === HTML_NAMESPACE$1) {
ownNamespace = getIntrinsicNamespace(tag);
}
if (ownNamespace === HTML_NAMESPACE$1) {
// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase());
} else {
var standardName = getPossibleStandardName(propKey);
if (standardName !== null && standardName !== propKey) {
// If an SVG prop is supplied with bad casing, it will
// be successfully parsed from HTML, but will produce a mismatch
// (and would be incorrectly rendered on the client).
// However, we already warn about bad casing elsewhere.
// So we'll skip the misleading extra mismatch warning in this case.
isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(standardName);
} // $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey);
}
serverValue = getValueForAttribute(domElement, propKey, nextProp);
}
if (nextProp !== serverValue && !isMismatchDueToBadCasing) {
warnForPropDifference(propKey, serverValue, nextProp);
}
}
}
}
{
// $FlowFixMe - Should be inferred as not undefined.
if (extraAttributeNames.size > 0 && !suppressHydrationWarning) {
// $FlowFixMe - Should be inferred as not undefined.
warnForExtraAttributes(extraAttributeNames);
}
}
switch (tag) {
case "input":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);
postMountWrapper(domElement, rawProps, true);
break;
case "textarea":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement);
postMountWrapper$3(domElement);
break;
case "select":
case "option":
// For input and textarea we current always set the value property at
// post mount to force it to diverge from attributes. However, for
// option and select we don't quite do the same thing and select
// is not resilient to the DOM state changing so we don't do that here.
// TODO: Consider not doing this for input and textarea.
break;
default:
if (typeof rawProps.onClick === "function") {
// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
break;
}
return updatePayload;
}
function diffHydratedText(textNode, text) {
var isDifferent = textNode.nodeValue !== text;
return isDifferent;
}
function warnForUnmatchedText(textNode, text) {
{
warnForTextDifference(textNode.nodeValue, text);
}
}
function warnForDeletedHydratableElement(parentNode, child) {
{
if (didWarnInvalidHydration) {
return;
}
didWarnInvalidHydration = true;
error(
"Did not expect server HTML to contain a <%s> in <%s>.",
child.nodeName.toLowerCase(),
parentNode.nodeName.toLowerCase(),
);
}
}
function warnForDeletedHydratableText(parentNode, child) {
{
if (didWarnInvalidHydration) {
return;
}
didWarnInvalidHydration = true;
error(
'Did not expect server HTML to contain the text node "%s" in <%s>.',
child.nodeValue,
parentNode.nodeName.toLowerCase(),
);
}
}
function warnForInsertedHydratedElement(parentNode, tag, props) {
{
if (didWarnInvalidHydration) {
return;
}
didWarnInvalidHydration = true;
error(
"Expected server HTML to contain a matching <%s> in <%s>.",
tag,
parentNode.nodeName.toLowerCase(),
);
}
}
function warnForInsertedHydratedText(parentNode, text) {
{
if (text === "") {
// We expect to insert empty text nodes since they're not represented in
// the HTML.
// TODO: Remove this special case if we can just avoid inserting empty
// text nodes.
return;
}
if (didWarnInvalidHydration) {
return;
}
didWarnInvalidHydration = true;
error(
'Expected server HTML to contain a matching text node for "%s" in <%s>.',
text,
parentNode.nodeName.toLowerCase(),
);
}
}
function restoreControlledState$3(domElement, tag, props) {
switch (tag) {
case "input":
restoreControlledState(domElement, props);
return;
case "textarea":
restoreControlledState$2(domElement, props);
return;
case "select":
restoreControlledState$1(domElement, props);
return;
}
}
var validateDOMNesting = function () {};
var updatedAncestorInfo = function () {};
{
// This validation code was written based on the HTML5 parsing spec:
// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
//
// Note: this does not catch all invalid nesting, nor does it try to (as it's
// not clear what practical benefit doing so provides); instead, we warn only
// for cases where the parser will give a parse tree differing from what React
// intended. For example, <b><div></div></b> is invalid but we don't warn
// because it still parses correctly; we do warn for other cases like nested
// <p> tags where the beginning of the second element implicitly closes the
// first, causing a confusing mess.
// https://html.spec.whatwg.org/multipage/syntax.html#special
var specialTags = [
"address",
"applet",
"area",
"article",
"aside",
"base",
"basefont",
"bgsound",
"blockquote",
"body",
"br",
"button",
"caption",
"center",
"col",
"colgroup",
"dd",
"details",
"dir",
"div",
"dl",
"dt",
"embed",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"frame",
"frameset",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"head",
"header",
"hgroup",
"hr",
"html",
"iframe",
"img",
"input",
"isindex",
"li",
"link",
"listing",
"main",
"marquee",
"menu",
"menuitem",
"meta",
"nav",
"noembed",
"noframes",
"noscript",
"object",
"ol",
"p",
"param",
"plaintext",
"pre",
"script",
"section",
"select",
"source",
"style",
"summary",
"table",
"tbody",
"td",
"template",
"textarea",
"tfoot",
"th",
"thead",
"title",
"tr",
"track",
"ul",
"wbr",
"xmp",
]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
var inScopeTags = [
"applet",
"caption",
"html",
"table",
"td",
"th",
"marquee",
"object",
"template", // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
// TODO: Distinguish by namespace here -- for <title>, including it here
// errs on the side of fewer warnings
"foreignObject",
"desc",
"title",
]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
var buttonScopeTags = inScopeTags.concat(["button"]); // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
var impliedEndTags = [
"dd",
"dt",
"li",
"option",
"optgroup",
"p",
"rp",
"rt",
];
var emptyAncestorInfo = {
current: null,
formTag: null,
aTagInScope: null,
buttonTagInScope: null,
nobrTagInScope: null,
pTagInButtonScope: null,
listItemTagAutoclosing: null,
dlItemTagAutoclosing: null,
};
updatedAncestorInfo = function (oldInfo, tag) {
var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);
var info = {
tag: tag,
};
if (inScopeTags.indexOf(tag) !== -1) {
ancestorInfo.aTagInScope = null;
ancestorInfo.buttonTagInScope = null;
ancestorInfo.nobrTagInScope = null;
}
if (buttonScopeTags.indexOf(tag) !== -1) {
ancestorInfo.pTagInButtonScope = null;
} // See rules for 'li', 'dd', 'dt' start tags in
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
if (
specialTags.indexOf(tag) !== -1 &&
tag !== "address" &&
tag !== "div" &&
tag !== "p"
) {
ancestorInfo.listItemTagAutoclosing = null;
ancestorInfo.dlItemTagAutoclosing = null;
}
ancestorInfo.current = info;
if (tag === "form") {
ancestorInfo.formTag = info;
}
if (tag === "a") {
ancestorInfo.aTagInScope = info;
}
if (tag === "button") {
ancestorInfo.buttonTagInScope = info;
}
if (tag === "nobr") {
ancestorInfo.nobrTagInScope = info;
}
if (tag === "p") {
ancestorInfo.pTagInButtonScope = info;
}
if (tag === "li") {
ancestorInfo.listItemTagAutoclosing = info;
}
if (tag === "dd" || tag === "dt") {
ancestorInfo.dlItemTagAutoclosing = info;
}
return ancestorInfo;
};
/**
* Returns whether
*/
var isTagValidWithParent = function (tag, parentTag) {
// First, let's check if we're in an unusual parsing mode...
switch (parentTag) {
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
case "select":
return tag === "option" || tag === "optgroup" || tag === "#text";
case "optgroup":
return tag === "option" || tag === "#text";
// Strictly speaking, seeing an <option> doesn't mean we're in a <select>
// but
case "option":
return tag === "#text";
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
// No special behavior since these rules fall back to "in body" mode for
// all except special table nodes which cause bad parsing behavior anyway.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
case "tr":
return (
tag === "th" ||
tag === "td" ||
tag === "style" ||
tag === "script" ||
tag === "template"
);
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
case "tbody":
case "thead":
case "tfoot":
return (
tag === "tr" ||
tag === "style" ||
tag === "script" ||
tag === "template"
);
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
case "colgroup":
return tag === "col" || tag === "template";
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
case "table":
return (
tag === "caption" ||
tag === "colgroup" ||
tag === "tbody" ||
tag === "tfoot" ||
tag === "thead" ||
tag === "style" ||
tag === "script" ||
tag === "template"
);
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
case "head":
return (
tag === "base" ||
tag === "basefont" ||
tag === "bgsound" ||
tag === "link" ||
tag === "meta" ||
tag === "title" ||
tag === "noscript" ||
tag === "noframes" ||
tag === "style" ||
tag === "script" ||
tag === "template"
);
// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
case "html":
return tag === "head" || tag === "body" || tag === "frameset";
case "frameset":
return tag === "frame";
case "#document":
return tag === "html";
} // Probably in the "in body" parsing mode, so we outlaw only tag combos
// where the parsing rules cause implicit opens or closes to be added.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
switch (tag) {
case "h1":
case "h2":
case "h3":
case "h4":
case "h5":
case "h6":
return (
parentTag !== "h1" &&
parentTag !== "h2" &&
parentTag !== "h3" &&
parentTag !== "h4" &&
parentTag !== "h5" &&
parentTag !== "h6"
);
case "rp":
case "rt":
return impliedEndTags.indexOf(parentTag) === -1;
case "body":
case "caption":
case "col":
case "colgroup":
case "frameset":
case "frame":
case "head":
case "html":
case "tbody":
case "td":
case "tfoot":
case "th":
case "thead":
case "tr":
// These tags are only valid with a few parents that have special child
// parsing rules -- if we're down here, then none of those matched and
// so we allow it only if we don't know what the parent is, as all other
// cases are invalid.
return parentTag == null;
}
return true;
};
/**
* Returns whether
*/
var findInvalidAncestorForTag = function (tag, ancestorInfo) {
switch (tag) {
case "address":
case "article":
case "aside":
case "blockquote":
case "center":
case "details":
case "dialog":
case "dir":
case "div":
case "dl":
case "fieldset":
case "figcaption":
case "figure":
case "footer":
case "header":
case "hgroup":
case "main":
case "menu":
case "nav":
case "ol":
case "p":
case "section":
case "summary":
case "ul":
case "pre":
case "listing":
case "table":
case "hr":
case "xmp":
case "h1":
case "h2":
case "h3":
case "h4":
case "h5":
case "h6":
return ancestorInfo.pTagInButtonScope;
case "form":
return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
case "li":
return ancestorInfo.listItemTagAutoclosing;
case "dd":
case "dt":
return ancestorInfo.dlItemTagAutoclosing;
case "button":
return ancestorInfo.buttonTagInScope;
case "a":
// Spec says something about storing a list of markers, but it sounds
// equivalent to this check.
return ancestorInfo.aTagInScope;
case "nobr":
return ancestorInfo.nobrTagInScope;
}
return null;
};
var didWarn$1 = {};
validateDOMNesting = function (childTag, childText, ancestorInfo) {
ancestorInfo = ancestorInfo || emptyAncestorInfo;
var parentInfo = ancestorInfo.current;
var parentTag = parentInfo && parentInfo.tag;
if (childText != null) {
if (childTag != null) {
error(
"validateDOMNesting: when childText is passed, childTag should be null",
);
}
childTag = "#text";
}
var invalidParent = isTagValidWithParent(childTag, parentTag)
? null
: parentInfo;
var invalidAncestor = invalidParent
? null
: findInvalidAncestorForTag(childTag, ancestorInfo);
var invalidParentOrAncestor = invalidParent || invalidAncestor;
if (!invalidParentOrAncestor) {
return;
}
var ancestorTag = invalidParentOrAncestor.tag;
var warnKey = !!invalidParent + "|" + childTag + "|" + ancestorTag;
if (didWarn$1[warnKey]) {
return;
}
didWarn$1[warnKey] = true;
var tagDisplayName = childTag;
var whitespaceInfo = "";
if (childTag === "#text") {
if (/\S/.test(childText)) {
tagDisplayName = "Text nodes";
} else {
tagDisplayName = "Whitespace text nodes";
whitespaceInfo =
" Make sure you don't have any extra whitespace between tags on " +
"each line of your source code.";
}
} else {
tagDisplayName = "<" + childTag + ">";
}
if (invalidParent) {
var info = "";
if (ancestorTag === "table" && childTag === "tr") {
info +=
" Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by " +
"the browser.";
}
error(
"validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s",
tagDisplayName,
ancestorTag,
whitespaceInfo,
info,
);
} else {
error(
"validateDOMNesting(...): %s cannot appear as a descendant of " +
"<%s>.",
tagDisplayName,
ancestorTag,
);
}
};
}
var SUPPRESS_HYDRATION_WARNING$1;
{
SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
}
var SUSPENSE_START_DATA = "$";
var SUSPENSE_END_DATA = "/$";
var SUSPENSE_PENDING_START_DATA = "$?";
var SUSPENSE_FALLBACK_START_DATA = "$!";
var STYLE$1 = "style";
var eventsEnabled = null;
var selectionInformation = null;
function shouldAutoFocusHostComponent(type, props) {
switch (type) {
case "button":
case "input":
case "select":
case "textarea":
return !!props.autoFocus;
}
return false;
}
function getRootHostContext(rootContainerInstance) {
var type;
var namespace;
var nodeType = rootContainerInstance.nodeType;
switch (nodeType) {
case DOCUMENT_NODE:
case DOCUMENT_FRAGMENT_NODE: {
type = nodeType === DOCUMENT_NODE ? "#document" : "#fragment";
var root = rootContainerInstance.documentElement;
namespace = root ? root.namespaceURI : getChildNamespace(null, "");
break;
}
default: {
var container =
nodeType === COMMENT_NODE
? rootContainerInstance.parentNode
: rootContainerInstance;
var ownNamespace = container.namespaceURI || null;
type = container.tagName;
namespace = getChildNamespace(ownNamespace, type);
break;
}
}
{
var validatedTag = type.toLowerCase();
var ancestorInfo = updatedAncestorInfo(null, validatedTag);
return {
namespace: namespace,
ancestorInfo: ancestorInfo,
};
}
}
function getChildHostContext(parentHostContext, type, rootContainerInstance) {
{
var parentHostContextDev = parentHostContext;
var namespace = getChildNamespace(parentHostContextDev.namespace, type);
var ancestorInfo = updatedAncestorInfo(
parentHostContextDev.ancestorInfo,
type,
);
return {
namespace: namespace,
ancestorInfo: ancestorInfo,
};
}
}
function getPublicInstance(instance) {
return instance;
}
function prepareForCommit(containerInfo) {
eventsEnabled = isEnabled();
selectionInformation = getSelectionInformation();
var activeInstance = null;
setEnabled(false);
return activeInstance;
}
function resetAfterCommit(containerInfo) {
restoreSelection(selectionInformation);
setEnabled(eventsEnabled);
eventsEnabled = null;
selectionInformation = null;
}
function createInstance(
type,
props,
rootContainerInstance,
hostContext,
internalInstanceHandle,
) {
var parentNamespace;
{
// TODO: take namespace into account when validating.
var hostContextDev = hostContext;
validateDOMNesting(type, null, hostContextDev.ancestorInfo);
if (
typeof props.children === "string" ||
typeof props.children === "number"
) {
var string = "" + props.children;
var ownAncestorInfo = updatedAncestorInfo(
hostContextDev.ancestorInfo,
type,
);
validateDOMNesting(null, string, ownAncestorInfo);
}
parentNamespace = hostContextDev.namespace;
}
var domElement = createElement(
type,
props,
rootContainerInstance,
parentNamespace,
);
precacheFiberNode(internalInstanceHandle, domElement);
updateFiberProps(domElement, props);
return domElement;
}
function appendInitialChild(parentInstance, child) {
parentInstance.appendChild(child);
}
function finalizeInitialChildren(
domElement,
type,
props,
rootContainerInstance,
hostContext,
) {
setInitialProperties(domElement, type, props, rootContainerInstance);
return shouldAutoFocusHostComponent(type, props);
}
function prepareUpdate(
domElement,
type,
oldProps,
newProps,
rootContainerInstance,
hostContext,
) {
{
var hostContextDev = hostContext;
if (
typeof newProps.children !== typeof oldProps.children &&
(typeof newProps.children === "string" ||
typeof newProps.children === "number")
) {
var string = "" + newProps.children;
var ownAncestorInfo = updatedAncestorInfo(
hostContextDev.ancestorInfo,
type,
);
validateDOMNesting(null, string, ownAncestorInfo);
}
}
return diffProperties(domElement, type, oldProps, newProps);
}
function shouldSetTextContent(type, props) {
return (
type === "textarea" ||
type === "option" ||
type === "noscript" ||
typeof props.children === "string" ||
typeof props.children === "number" ||
(typeof props.dangerouslySetInnerHTML === "object" &&
props.dangerouslySetInnerHTML !== null &&
props.dangerouslySetInnerHTML.__html != null)
);
}
function createTextInstance(
text,
rootContainerInstance,
hostContext,
internalInstanceHandle,
) {
{
var hostContextDev = hostContext;
validateDOMNesting(null, text, hostContextDev.ancestorInfo);
}
var textNode = createTextNode(text, rootContainerInstance);
precacheFiberNode(internalInstanceHandle, textNode);
return textNode;
}
// if a component just imports ReactDOM (e.g. for findDOMNode).
// Some environments might not have setTimeout or clearTimeout.
var scheduleTimeout =
typeof setTimeout === "function" ? setTimeout : undefined;
var cancelTimeout =
typeof clearTimeout === "function" ? clearTimeout : undefined;
var noTimeout = -1; // -------------------
function commitMount(domElement, type, newProps, internalInstanceHandle) {
// Despite the naming that might imply otherwise, this method only
// fires if there is an `Update` effect scheduled during mounting.
// This happens if `finalizeInitialChildren` returns `true` (which it
// does to implement the `autoFocus` attribute on the client). But
// there are also other cases when this might happen (such as patching
// up text content during hydration mismatch). So we'll check this again.
if (shouldAutoFocusHostComponent(type, newProps)) {
domElement.focus();
}
}
function commitUpdate(
domElement,
updatePayload,
type,
oldProps,
newProps,
internalInstanceHandle,
) {
// Update the props handle so that we know which props are the ones with
// with current event handlers.
updateFiberProps(domElement, newProps); // Apply the diff to the DOM node.
updateProperties(domElement, updatePayload, type, oldProps, newProps);
}
function resetTextContent(domElement) {
setTextContent(domElement, "");
}
function commitTextUpdate(textInstance, oldText, newText) {
textInstance.nodeValue = newText;
}
function appendChild(parentInstance, child) {
parentInstance.appendChild(child);
}
function appendChildToContainer(container, child) {
var parentNode;
if (container.nodeType === COMMENT_NODE) {
parentNode = container.parentNode;
parentNode.insertBefore(child, container);
} else {
parentNode = container;
parentNode.appendChild(child);
} // This container might be used for a portal.
// If something inside a portal is clicked, that click should bubble
// through the React tree. However, on Mobile Safari the click would
// never bubble through the *DOM* tree unless an ancestor with onclick
// event exists. So we wouldn't see it and dispatch it.
// This is why we ensure that non React root containers have inline onclick
// defined.
// https://github.com/facebook/react/issues/11918
var reactRootContainer = container._reactRootContainer;
if (
(reactRootContainer === null || reactRootContainer === undefined) &&
parentNode.onclick === null
) {
// TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(parentNode);
}
}
function insertBefore(parentInstance, child, beforeChild) {
parentInstance.insertBefore(child, beforeChild);
}
function insertInContainerBefore(container, child, beforeChild) {
if (container.nodeType === COMMENT_NODE) {
container.parentNode.insertBefore(child, beforeChild);
} else {
container.insertBefore(child, beforeChild);
}
}
function removeChild(parentInstance, child) {
parentInstance.removeChild(child);
}
function removeChildFromContainer(container, child) {
if (container.nodeType === COMMENT_NODE) {
container.parentNode.removeChild(child);
} else {
container.removeChild(child);
}
}
function hideInstance(instance) {
// TODO: Does this work for all element types? What about MathML? Should we
// pass host context to this method?
instance = instance;
var style = instance.style;
if (typeof style.setProperty === "function") {
style.setProperty("display", "none", "important");
} else {
style.display = "none";
}
}
function hideTextInstance(textInstance) {
textInstance.nodeValue = "";
}
function unhideInstance(instance, props) {
instance = instance;
var styleProp = props[STYLE$1];
var display =
styleProp !== undefined &&
styleProp !== null &&
styleProp.hasOwnProperty("display")
? styleProp.display
: null;
instance.style.display = dangerousStyleValue("display", display);
}
function unhideTextInstance(textInstance, text) {
textInstance.nodeValue = text;
}
function clearContainer(container) {
if (container.nodeType === ELEMENT_NODE) {
container.textContent = "";
} else if (container.nodeType === DOCUMENT_NODE) {
var body = container.body;
if (body != null) {
body.textContent = "";
}
}
} // -------------------
function canHydrateInstance(instance, type, props) {
if (
instance.nodeType !== ELEMENT_NODE ||
type.toLowerCase() !== instance.nodeName.toLowerCase()
) {
return null;
} // This has now been refined to an element node.
return instance;
}
function canHydrateTextInstance(instance, text) {
if (text === "" || instance.nodeType !== TEXT_NODE) {
// Empty strings are not parsed by HTML so there won't be a correct match here.
return null;
} // This has now been refined to a text node.
return instance;
}
function isSuspenseInstancePending(instance) {
return instance.data === SUSPENSE_PENDING_START_DATA;
}
function isSuspenseInstanceFallback(instance) {
return instance.data === SUSPENSE_FALLBACK_START_DATA;
}
function getNextHydratable(node) {
// Skip non-hydratable nodes.
for (; node != null; node = node.nextSibling) {
var nodeType = node.nodeType;
if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
break;
}
}
return node;
}
function getNextHydratableSibling(instance) {
return getNextHydratable(instance.nextSibling);
}
function getFirstHydratableChild(parentInstance) {
return getNextHydratable(parentInstance.firstChild);
}
function hydrateInstance(
instance,
type,
props,
rootContainerInstance,
hostContext,
internalInstanceHandle,
) {
precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
// get attached.
updateFiberProps(instance, props);
var parentNamespace;
{
var hostContextDev = hostContext;
parentNamespace = hostContextDev.namespace;
}
return diffHydratedProperties(instance, type, props, parentNamespace);
}
function hydrateTextInstance(textInstance, text, internalInstanceHandle) {
precacheFiberNode(internalInstanceHandle, textInstance);
return diffHydratedText(textInstance, text);
}
function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
var node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
// There might be nested nodes so we need to keep track of how
// deep we are and only break out when we're back on top.
var depth = 0;
while (node) {
if (node.nodeType === COMMENT_NODE) {
var data = node.data;
if (data === SUSPENSE_END_DATA) {
if (depth === 0) {
return getNextHydratableSibling(node);
} else {
depth--;
}
} else if (
data === SUSPENSE_START_DATA ||
data === SUSPENSE_FALLBACK_START_DATA ||
data === SUSPENSE_PENDING_START_DATA
) {
depth++;
}
}
node = node.nextSibling;
} // TODO: Warn, we didn't find the end comment boundary.
return null;
} // Returns the SuspenseInstance if this node is a direct child of a
// SuspenseInstance. I.e. if its previous sibling is a Comment with
// SUSPENSE_x_START_DATA. Otherwise, null.
function getParentSuspenseInstance(targetInstance) {
var node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
// There might be nested nodes so we need to keep track of how
// deep we are and only break out when we're back on top.
var depth = 0;
while (node) {
if (node.nodeType === COMMENT_NODE) {
var data = node.data;
if (
data === SUSPENSE_START_DATA ||
data === SUSPENSE_FALLBACK_START_DATA ||
data === SUSPENSE_PENDING_START_DATA
) {
if (depth === 0) {
return node;
} else {
depth--;
}
} else if (data === SUSPENSE_END_DATA) {
depth++;
}
}
node = node.previousSibling;
}
return null;
}
function commitHydratedContainer(container) {
// Retry if any event replaying was blocked on this.
retryIfBlockedOn(container);
}
function commitHydratedSuspenseInstance(suspenseInstance) {
// Retry if any event replaying was blocked on this.
retryIfBlockedOn(suspenseInstance);
}
function didNotMatchHydratedContainerTextInstance(
parentContainer,
textInstance,
text,
) {
{
warnForUnmatchedText(textInstance, text);
}
}
function didNotMatchHydratedTextInstance(
parentType,
parentProps,
parentInstance,
textInstance,
text,
) {
if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
warnForUnmatchedText(textInstance, text);
}
}
function didNotHydrateContainerInstance(parentContainer, instance) {
{
if (instance.nodeType === ELEMENT_NODE) {
warnForDeletedHydratableElement(parentContainer, instance);
} else if (instance.nodeType === COMMENT_NODE);
else {
warnForDeletedHydratableText(parentContainer, instance);
}
}
}
function didNotHydrateInstance(
parentType,
parentProps,
parentInstance,
instance,
) {
if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
if (instance.nodeType === ELEMENT_NODE) {
warnForDeletedHydratableElement(parentInstance, instance);
} else if (instance.nodeType === COMMENT_NODE);
else {
warnForDeletedHydratableText(parentInstance, instance);
}
}
}
function didNotFindHydratableContainerInstance(parentContainer, type, props) {
{
warnForInsertedHydratedElement(parentContainer, type);
}
}
function didNotFindHydratableContainerTextInstance(parentContainer, text) {
{
warnForInsertedHydratedText(parentContainer, text);
}
}
function didNotFindHydratableInstance(
parentType,
parentProps,
parentInstance,
type,
props,
) {
if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
warnForInsertedHydratedElement(parentInstance, type);
}
}
function didNotFindHydratableTextInstance(
parentType,
parentProps,
parentInstance,
text,
) {
if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
warnForInsertedHydratedText(parentInstance, text);
}
}
function didNotFindHydratableSuspenseInstance(
parentType,
parentProps,
parentInstance,
) {
if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true);
}
var clientId = 0;
function makeClientIdInDEV(warnOnAccessInDEV) {
var id = "r:" + (clientId++).toString(36);
return {
toString: function () {
warnOnAccessInDEV();
return id;
},
valueOf: function () {
warnOnAccessInDEV();
return id;
},
};
}
function isOpaqueHydratingObject(value) {
return (
value !== null &&
typeof value === "object" &&
value.$$typeof === REACT_OPAQUE_ID_TYPE
);
}
function makeOpaqueHydratingObject(attemptToReadValue) {
return {
$$typeof: REACT_OPAQUE_ID_TYPE,
toString: attemptToReadValue,
valueOf: attemptToReadValue,
};
}
function preparePortalMount(portalInstance) {
{
listenToAllSupportedEvents(portalInstance);
}
}
var randomKey = Math.random().toString(36).slice(2);
var internalInstanceKey = "__reactFiber$" + randomKey;
var internalPropsKey = "__reactProps$" + randomKey;
var internalContainerInstanceKey = "__reactContainer$" + randomKey;
var internalEventHandlersKey = "__reactEvents$" + randomKey;
function precacheFiberNode(hostInst, node) {
node[internalInstanceKey] = hostInst;
}
function markContainerAsRoot(hostRoot, node) {
node[internalContainerInstanceKey] = hostRoot;
}
function unmarkContainerAsRoot(node) {
node[internalContainerInstanceKey] = null;
}
function isContainerMarkedAsRoot(node) {
return !!node[internalContainerInstanceKey];
} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.
// If the target node is part of a hydrated or not yet rendered subtree, then
// this may also return a SuspenseComponent or HostRoot to indicate that.
// Conceptually the HostRoot fiber is a child of the Container node. So if you
// pass the Container node as the targetNode, you will not actually get the
// HostRoot back. To get to the HostRoot, you need to pass a child of it.
// The same thing applies to Suspense boundaries.
function getClosestInstanceFromNode(targetNode) {
var targetInst = targetNode[internalInstanceKey];
if (targetInst) {
// Don't return HostRoot or SuspenseComponent here.
return targetInst;
} // If the direct event target isn't a React owned DOM node, we need to look
// to see if one of its parents is a React owned DOM node.
var parentNode = targetNode.parentNode;
while (parentNode) {
// We'll check if this is a container root that could include
// React nodes in the future. We need to check this first because
// if we're a child of a dehydrated container, we need to first
// find that inner container before moving on to finding the parent
// instance. Note that we don't check this field on the targetNode
// itself because the fibers are conceptually between the container
// node and the first child. It isn't surrounding the container node.
// If it's not a container, we check if it's an instance.
targetInst =
parentNode[internalContainerInstanceKey] ||
parentNode[internalInstanceKey];
if (targetInst) {
// Since this wasn't the direct target of the event, we might have
// stepped past dehydrated DOM nodes to get here. However they could
// also have been non-React nodes. We need to answer which one.
// If we the instance doesn't have any children, then there can't be
// a nested suspense boundary within it. So we can use this as a fast
// bailout. Most of the time, when people add non-React children to
// the tree, it is using a ref to a child-less DOM node.
// Normally we'd only need to check one of the fibers because if it
// has ever gone from having children to deleting them or vice versa
// it would have deleted the dehydrated boundary nested inside already.
// However, since the HostRoot starts out with an alternate it might
// have one on the alternate so we need to check in case this was a
// root.
var alternate = targetInst.alternate;
if (
targetInst.child !== null ||
(alternate !== null && alternate.child !== null)
) {
// Next we need to figure out if the node that skipped past is
// nested within a dehydrated boundary and if so, which one.
var suspenseInstance = getParentSuspenseInstance(targetNode);
while (suspenseInstance !== null) {
// We found a suspense instance. That means that we haven't
// hydrated it yet. Even though we leave the comments in the
// DOM after hydrating, and there are boundaries in the DOM
// that could already be hydrated, we wouldn't have found them
// through this pass since if the target is hydrated it would
// have had an internalInstanceKey on it.
// Let's get the fiber associated with the SuspenseComponent
// as the deepest instance.
var targetSuspenseInst = suspenseInstance[internalInstanceKey];
if (targetSuspenseInst) {
return targetSuspenseInst;
} // If we don't find a Fiber on the comment, it might be because
// we haven't gotten to hydrate it yet. There might still be a
// parent boundary that hasn't above this one so we need to find
// the outer most that is known.
suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
// host component also hasn't hydrated yet. We can return it
// below since it will bail out on the isMounted check later.
}
}
return targetInst;
}
targetNode = parentNode;
parentNode = targetNode.parentNode;
}
return null;
}
/**
* Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
* instance, or null if the node was not rendered by this React.
*/
function getInstanceFromNode(node) {
var inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
if (inst) {
if (
inst.tag === HostComponent ||
inst.tag === HostText ||
inst.tag === SuspenseComponent ||
inst.tag === HostRoot
) {
return inst;
} else {
return null;
}
}
return null;
}
/**
* Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
* DOM node.
*/
function getNodeFromInstance(inst) {
if (inst.tag === HostComponent || inst.tag === HostText) {
// In Fiber this, is just the state node right now. We assume it will be
// a host component or host text.
return inst.stateNode;
} // Without this first invariant, passing a non-DOM-component triggers the next
// invariant for a missing parent, which is super confusing.
{
{
throw Error("getNodeFromInstance: Invalid argument.");
}
}
}
function getFiberCurrentPropsFromNode(node) {
return node[internalPropsKey] || null;
}
function updateFiberProps(node, props) {
node[internalPropsKey] = props;
}
function getEventListenerSet(node) {
var elementListenerSet = node[internalEventHandlersKey];
if (elementListenerSet === undefined) {
elementListenerSet = node[internalEventHandlersKey] = new Set();
}
return elementListenerSet;
}
var loggedTypeFailures = {};
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(
element.type,
element._source,
owner ? owner.type : null,
);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
}
}
function checkPropTypes(typeSpecs, values, location, componentName, element) {
{
// $FlowFixMe This is okay but Flow doesn't know it.
var has = Function.call.bind(Object.prototype.hasOwnProperty);
for (var typeSpecName in typeSpecs) {
if (has(typeSpecs, typeSpecName)) {
var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if (typeof typeSpecs[typeSpecName] !== "function") {
var err = Error(
(componentName || "React class") +
": " +
location +
" type `" +
typeSpecName +
"` is invalid; " +
"it must be a function, usually from the `prop-types` package, but received `" +
typeof typeSpecs[typeSpecName] +
"`." +
"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.",
);
err.name = "Invariant Violation";
throw err;
}
error$1 = typeSpecs[typeSpecName](
values,
typeSpecName,
componentName,
location,
null,
"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED",
);
} catch (ex) {
error$1 = ex;
}
if (error$1 && !(error$1 instanceof Error)) {
setCurrentlyValidatingElement(element);
error(
"%s: type specification of %s" +
" `%s` is invalid; the type checker " +
"function must return `null` or an `Error` but returned a %s. " +
"You may have forgotten to pass an argument to the type checker " +
"creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
"shape all require an argument).",
componentName || "React class",
location,
typeSpecName,
typeof error$1,
);
setCurrentlyValidatingElement(null);
}
if (
error$1 instanceof Error &&
!(error$1.message in loggedTypeFailures)
) {
// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message] = true;
setCurrentlyValidatingElement(element);
error("Failed %s type: %s", location, error$1.message);
setCurrentlyValidatingElement(null);
}
}
}
}
}
var valueStack = [];
var fiberStack;
{
fiberStack = [];
}
var index = -1;
function createCursor(defaultValue) {
return {
current: defaultValue,
};
}
function pop(cursor, fiber) {
if (index < 0) {
{
error("Unexpected pop.");
}
return;
}
{
if (fiber !== fiberStack[index]) {
error("Unexpected Fiber popped.");
}
}
cursor.current = valueStack[index];
valueStack[index] = null;
{
fiberStack[index] = null;
}
index--;
}
function push(cursor, value, fiber) {
index++;
valueStack[index] = cursor.current;
{
fiberStack[index] = fiber;
}
cursor.current = value;
}
var warnedAboutMissingGetChildContext;
{
warnedAboutMissingGetChildContext = {};
}
var emptyContextObject = {};
{
Object.freeze(emptyContextObject);
} // A cursor to the current merged context object on the stack.
var contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
var didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.
// We use this to get access to the parent context after we have already
// pushed the next context provider, and now need to merge their contexts.
var previousContext = emptyContextObject;
function getUnmaskedContext(
workInProgress,
Component,
didPushOwnContextIfProvider,
) {
{
if (didPushOwnContextIfProvider && isContextProvider(Component)) {
// If the fiber is a context provider itself, when we read its context
// we may have already pushed its own child context on the stack. A context
// provider should not "see" its own child context. Therefore we read the
// previous (parent) context instead for a context provider.
return previousContext;
}
return contextStackCursor.current;
}
}
function cacheContext(workInProgress, unmaskedContext, maskedContext) {
{
var instance = workInProgress.stateNode;
instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
}
}
function getMaskedContext(workInProgress, unmaskedContext) {
{
var type = workInProgress.type;
var contextTypes = type.contextTypes;
if (!contextTypes) {
return emptyContextObject;
} // Avoid recreating masked context unless unmasked context has changed.
// Failing to do this will result in unnecessary calls to componentWillReceiveProps.
// This may trigger infinite loops if componentWillReceiveProps calls setState.
var instance = workInProgress.stateNode;
if (
instance &&
instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
) {
return instance.__reactInternalMemoizedMaskedChildContext;
}
var context = {};
for (var key in contextTypes) {
context[key] = unmaskedContext[key];
}
{
var name = getComponentName(type) || "Unknown";
checkPropTypes(contextTypes, context, "context", name);
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
// Context is created before the class component is instantiated so check for instance.
if (instance) {
cacheContext(workInProgress, unmaskedContext, context);
}
return context;
}
}
function hasContextChanged() {
{
return didPerformWorkStackCursor.current;
}
}
function isContextProvider(type) {
{
var childContextTypes = type.childContextTypes;
return childContextTypes !== null && childContextTypes !== undefined;
}
}
function popContext(fiber) {
{
pop(didPerformWorkStackCursor, fiber);
pop(contextStackCursor, fiber);
}
}
function popTopLevelContextObject(fiber) {
{
pop(didPerformWorkStackCursor, fiber);
pop(contextStackCursor, fiber);
}
}
function pushTopLevelContextObject(fiber, context, didChange) {
{
if (!(contextStackCursor.current === emptyContextObject)) {
{
throw Error(
"Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
push(contextStackCursor, context, fiber);
push(didPerformWorkStackCursor, didChange, fiber);
}
}
function processChildContext(fiber, type, parentContext) {
{
var instance = fiber.stateNode;
var childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.
// It has only been added in Fiber to match the (unintentional) behavior in Stack.
if (typeof instance.getChildContext !== "function") {
{
var componentName = getComponentName(type) || "Unknown";
if (!warnedAboutMissingGetChildContext[componentName]) {
warnedAboutMissingGetChildContext[componentName] = true;
error(
"%s.childContextTypes is specified but there is no getChildContext() method " +
"on the instance. You can either define getChildContext() on %s or remove " +
"childContextTypes from it.",
componentName,
componentName,
);
}
}
return parentContext;
}
var childContext = instance.getChildContext();
for (var contextKey in childContext) {
if (!(contextKey in childContextTypes)) {
{
throw Error(
(getComponentName(type) || "Unknown") +
'.getChildContext(): key "' +
contextKey +
'" is not defined in childContextTypes.',
);
}
}
}
{
var name = getComponentName(type) || "Unknown";
checkPropTypes(childContextTypes, childContext, "child context", name);
}
return _assign({}, parentContext, childContext);
}
}
function pushContextProvider(workInProgress) {
{
var instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
// If the instance does not exist yet, we will push null at first,
// and replace it on the stack later when invalidating the context.
var memoizedMergedChildContext =
(instance && instance.__reactInternalMemoizedMergedChildContext) ||
emptyContextObject; // Remember the parent context so we can merge with it later.
// Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
previousContext = contextStackCursor.current;
push(contextStackCursor, memoizedMergedChildContext, workInProgress);
push(
didPerformWorkStackCursor,
didPerformWorkStackCursor.current,
workInProgress,
);
return true;
}
}
function invalidateContextProvider(workInProgress, type, didChange) {
{
var instance = workInProgress.stateNode;
if (!instance) {
{
throw Error(
"Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
if (didChange) {
// Merge parent and own context.
// Skip this if we're not updating due to sCU.
// This avoids unnecessarily recomputing memoized values.
var mergedContext = processChildContext(
workInProgress,
type,
previousContext,
);
instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
// It is important to unwind the context in the reverse order.
pop(didPerformWorkStackCursor, workInProgress);
pop(contextStackCursor, workInProgress); // Now push the new context and mark that it has changed.
push(contextStackCursor, mergedContext, workInProgress);
push(didPerformWorkStackCursor, didChange, workInProgress);
} else {
pop(didPerformWorkStackCursor, workInProgress);
push(didPerformWorkStackCursor, didChange, workInProgress);
}
}
}
function findCurrentUnmaskedContext(fiber) {
{
// Currently this is only used with renderSubtreeIntoContainer; not sure if it
// makes sense elsewhere
if (!(isFiberMounted(fiber) && fiber.tag === ClassComponent)) {
{
throw Error(
"Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var node = fiber;
do {
switch (node.tag) {
case HostRoot:
return node.stateNode.context;
case ClassComponent: {
var Component = node.type;
if (isContextProvider(Component)) {
return node.stateNode.__reactInternalMemoizedMergedChildContext;
}
break;
}
}
node = node.return;
} while (node !== null);
{
{
throw Error(
"Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
}
var LegacyRoot = 0;
var BlockingRoot = 1;
var ConcurrentRoot = 2;
var rendererID = null;
var injectedHook = null;
var hasLoggedError = false;
var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
function injectInternals(internals) {
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
// No DevTools
return false;
}
var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
if (hook.isDisabled) {
// This isn't a real property on the hook, but it can be set to opt out
// of DevTools integration and associated warnings and logs.
// https://github.com/facebook/react/issues/3877
return true;
}
if (!hook.supportsFiber) {
{
error(
"The installed version of React DevTools is too old and will not work " +
"with the current version of React. Please update React DevTools. " +
"https://reactjs.org/link/react-devtools",
);
} // DevTools exists, even though it doesn't support Fiber.
return true;
}
try {
rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
injectedHook = hook;
} catch (err) {
// Catch all errors because it is unsafe to throw during initialization.
{
error("React instrumentation encountered an error: %s.", err);
}
} // DevTools exists
return true;
}
function onScheduleRoot(root, children) {
{
if (
injectedHook &&
typeof injectedHook.onScheduleFiberRoot === "function"
) {
try {
injectedHook.onScheduleFiberRoot(rendererID, root, children);
} catch (err) {
if (!hasLoggedError) {
hasLoggedError = true;
error("React instrumentation encountered an error: %s", err);
}
}
}
}
}
function onCommitRoot(root, priorityLevel) {
if (injectedHook && typeof injectedHook.onCommitFiberRoot === "function") {
try {
var didError = (root.current.flags & DidCapture) === DidCapture;
if (enableProfilerTimer) {
injectedHook.onCommitFiberRoot(
rendererID,
root,
priorityLevel,
didError,
);
} else {
injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
}
} catch (err) {
{
if (!hasLoggedError) {
hasLoggedError = true;
error("React instrumentation encountered an error: %s", err);
}
}
}
}
}
function onCommitUnmount(fiber) {
if (
injectedHook &&
typeof injectedHook.onCommitFiberUnmount === "function"
) {
try {
injectedHook.onCommitFiberUnmount(rendererID, fiber);
} catch (err) {
{
if (!hasLoggedError) {
hasLoggedError = true;
error("React instrumentation encountered an error: %s", err);
}
}
}
}
}
var Scheduler_runWithPriority = unstable_runWithPriority,
Scheduler_scheduleCallback = unstable_scheduleCallback,
Scheduler_cancelCallback = unstable_cancelCallback,
Scheduler_shouldYield = unstable_shouldYield,
Scheduler_requestPaint = unstable_requestPaint,
Scheduler_now$1 = unstable_now,
Scheduler_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel,
Scheduler_ImmediatePriority = unstable_ImmediatePriority,
Scheduler_UserBlockingPriority = unstable_UserBlockingPriority,
Scheduler_NormalPriority = unstable_NormalPriority,
Scheduler_LowPriority = unstable_LowPriority,
Scheduler_IdlePriority = unstable_IdlePriority;
{
// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if (!(__interactionsRef != null && __interactionsRef.current != null)) {
{
throw Error(
"It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling",
);
}
}
}
var fakeCallbackNode = {}; // Except for NoPriority, these correspond to Scheduler priorities. We use
// ascending numbers so we can compare them like numbers. They start at 90 to
// avoid clashing with Scheduler's priorities.
var ImmediatePriority$1 = 99;
var UserBlockingPriority$2 = 98;
var NormalPriority$1 = 97;
var LowPriority$1 = 96;
var IdlePriority$1 = 95; // NoPriority is the absence of priority. Also React-only.
var NoPriority$1 = 90;
var shouldYield = Scheduler_shouldYield;
var requestPaint = // Fall back gracefully if we're running an older version of Scheduler.
Scheduler_requestPaint !== undefined
? Scheduler_requestPaint
: function () {};
var syncQueue = null;
var immediateQueueCallbackNode = null;
var isFlushingSyncQueue = false;
var initialTimeMs$1 = Scheduler_now$1(); // If the initial timestamp is reasonably small, use Scheduler's `now` directly.
// This will be the case for modern browsers that support `performance.now`. In
// older browsers, Scheduler falls back to `Date.now`, which returns a Unix
// timestamp. In that case, subtract the module initialization time to simulate
// the behavior of performance.now and keep our times small enough to fit
// within 32 bits.
// TODO: Consider lifting this into Scheduler.
var now =
initialTimeMs$1 < 10000
? Scheduler_now$1
: function () {
return Scheduler_now$1() - initialTimeMs$1;
};
function getCurrentPriorityLevel() {
switch (Scheduler_getCurrentPriorityLevel()) {
case Scheduler_ImmediatePriority:
return ImmediatePriority$1;
case Scheduler_UserBlockingPriority:
return UserBlockingPriority$2;
case Scheduler_NormalPriority:
return NormalPriority$1;
case Scheduler_LowPriority:
return LowPriority$1;
case Scheduler_IdlePriority:
return IdlePriority$1;
default: {
{
throw Error("Unknown priority level.");
}
}
}
}
function reactPriorityToSchedulerPriority(reactPriorityLevel) {
switch (reactPriorityLevel) {
case ImmediatePriority$1:
return Scheduler_ImmediatePriority;
case UserBlockingPriority$2:
return Scheduler_UserBlockingPriority;
case NormalPriority$1:
return Scheduler_NormalPriority;
case LowPriority$1:
return Scheduler_LowPriority;
case IdlePriority$1:
return Scheduler_IdlePriority;
default: {
{
throw Error("Unknown priority level.");
}
}
}
}
function runWithPriority$1(reactPriorityLevel, fn) {
var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
return Scheduler_runWithPriority(priorityLevel, fn);
}
function scheduleCallback(reactPriorityLevel, callback, options) {
var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
return Scheduler_scheduleCallback(priorityLevel, callback, options);
}
function scheduleSyncCallback(callback) {
// Push this callback into an internal queue. We'll flush these either in
// the next tick, or earlier if something calls `flushSyncCallbackQueue`.
if (syncQueue === null) {
syncQueue = [callback]; // Flush the queue in the next tick, at the earliest.
immediateQueueCallbackNode = Scheduler_scheduleCallback(
Scheduler_ImmediatePriority,
flushSyncCallbackQueueImpl,
);
} else {
// Push onto existing queue. Don't need to schedule a callback because
// we already scheduled one when we created the queue.
syncQueue.push(callback);
}
return fakeCallbackNode;
}
function cancelCallback(callbackNode) {
if (callbackNode !== fakeCallbackNode) {
Scheduler_cancelCallback(callbackNode);
}
}
function flushSyncCallbackQueue() {
if (immediateQueueCallbackNode !== null) {
var node = immediateQueueCallbackNode;
immediateQueueCallbackNode = null;
Scheduler_cancelCallback(node);
}
flushSyncCallbackQueueImpl();
}
function flushSyncCallbackQueueImpl() {
if (!isFlushingSyncQueue && syncQueue !== null) {
// Prevent re-entrancy.
isFlushingSyncQueue = true;
var i = 0;
{
try {
var _isSync2 = true;
var _queue = syncQueue;
runWithPriority$1(ImmediatePriority$1, function () {
for (; i < _queue.length; i++) {
var callback = _queue[i];
do {
callback = callback(_isSync2);
} while (callback !== null);
}
});
syncQueue = null;
} catch (error) {
// If something throws, leave the remaining callbacks on the queue.
if (syncQueue !== null) {
syncQueue = syncQueue.slice(i + 1);
} // Resume flushing in the next tick
Scheduler_scheduleCallback(
Scheduler_ImmediatePriority,
flushSyncCallbackQueue,
);
throw error;
} finally {
isFlushingSyncQueue = false;
}
}
}
}
// TODO: this is special because it gets imported during build.
var ReactVersion = "17.0.2";
var NoMode = 0;
var StrictMode = 1; // TODO: Remove BlockingMode and ConcurrentMode by reading from the root
// tag instead
var BlockingMode = 2;
var ConcurrentMode = 4;
var ProfileMode = 8;
var DebugTracingMode = 16;
var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig;
var NoTransition = 0;
function requestCurrentTransition() {
return ReactCurrentBatchConfig.transition;
}
var ReactStrictModeWarnings = {
recordUnsafeLifecycleWarnings: function (fiber, instance) {},
flushPendingUnsafeLifecycleWarnings: function () {},
recordLegacyContextWarning: function (fiber, instance) {},
flushLegacyContextWarning: function () {},
discardPendingWarnings: function () {},
};
{
var findStrictRoot = function (fiber) {
var maybeStrictRoot = null;
var node = fiber;
while (node !== null) {
if (node.mode & StrictMode) {
maybeStrictRoot = node;
}
node = node.return;
}
return maybeStrictRoot;
};
var setToSortedString = function (set) {
var array = [];
set.forEach(function (value) {
array.push(value);
});
return array.sort().join(", ");
};
var pendingComponentWillMountWarnings = [];
var pendingUNSAFE_ComponentWillMountWarnings = [];
var pendingComponentWillReceivePropsWarnings = [];
var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
var pendingComponentWillUpdateWarnings = [];
var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
var didWarnAboutUnsafeLifecycles = new Set();
ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
fiber,
instance,
) {
// Dedup strategy: Warn once per component.
if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
return;
}
if (
typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
instance.componentWillMount.__suppressDeprecationWarning !== true
) {
pendingComponentWillMountWarnings.push(fiber);
}
if (
fiber.mode & StrictMode &&
typeof instance.UNSAFE_componentWillMount === "function"
) {
pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
}
if (
typeof instance.componentWillReceiveProps === "function" &&
instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
) {
pendingComponentWillReceivePropsWarnings.push(fiber);
}
if (
fiber.mode & StrictMode &&
typeof instance.UNSAFE_componentWillReceiveProps === "function"
) {
pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
}
if (
typeof instance.componentWillUpdate === "function" &&
instance.componentWillUpdate.__suppressDeprecationWarning !== true
) {
pendingComponentWillUpdateWarnings.push(fiber);
}
if (
fiber.mode & StrictMode &&
typeof instance.UNSAFE_componentWillUpdate === "function"
) {
pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
}
};
ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
// We do an initial pass to gather component names
var componentWillMountUniqueNames = new Set();
if (pendingComponentWillMountWarnings.length > 0) {
pendingComponentWillMountWarnings.forEach(function (fiber) {
componentWillMountUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingComponentWillMountWarnings = [];
}
var UNSAFE_componentWillMountUniqueNames = new Set();
if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
UNSAFE_componentWillMountUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingUNSAFE_ComponentWillMountWarnings = [];
}
var componentWillReceivePropsUniqueNames = new Set();
if (pendingComponentWillReceivePropsWarnings.length > 0) {
pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
componentWillReceivePropsUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingComponentWillReceivePropsWarnings = [];
}
var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (
fiber,
) {
UNSAFE_componentWillReceivePropsUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
}
var componentWillUpdateUniqueNames = new Set();
if (pendingComponentWillUpdateWarnings.length > 0) {
pendingComponentWillUpdateWarnings.forEach(function (fiber) {
componentWillUpdateUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingComponentWillUpdateWarnings = [];
}
var UNSAFE_componentWillUpdateUniqueNames = new Set();
if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
UNSAFE_componentWillUpdateUniqueNames.add(
getComponentName(fiber.type) || "Component",
);
didWarnAboutUnsafeLifecycles.add(fiber.type);
});
pendingUNSAFE_ComponentWillUpdateWarnings = [];
} // Finally, we flush all the warnings
// UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
if (UNSAFE_componentWillMountUniqueNames.size > 0) {
var sortedNames = setToSortedString(
UNSAFE_componentWillMountUniqueNames,
);
error(
"Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
"\nPlease update the following components: %s",
sortedNames,
);
}
if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
var _sortedNames = setToSortedString(
UNSAFE_componentWillReceivePropsUniqueNames,
);
error(
"Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
"and may indicate bugs in your code. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move data fetching code or side effects to componentDidUpdate.\n" +
"* If you're updating state whenever props change, " +
"refactor your code to use memoization techniques or move it to " +
"static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
"\nPlease update the following components: %s",
_sortedNames,
);
}
if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
var _sortedNames2 = setToSortedString(
UNSAFE_componentWillUpdateUniqueNames,
);
error(
"Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
"and may indicate bugs in your code. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move data fetching code or side effects to componentDidUpdate.\n" +
"\nPlease update the following components: %s",
_sortedNames2,
);
}
if (componentWillMountUniqueNames.size > 0) {
var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
warn(
"componentWillMount has been renamed, and is not recommended for use. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
"* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
"this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
"To rename all deprecated lifecycles to their new names, you can run " +
"`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
"\nPlease update the following components: %s",
_sortedNames3,
);
}
if (componentWillReceivePropsUniqueNames.size > 0) {
var _sortedNames4 = setToSortedString(
componentWillReceivePropsUniqueNames,
);
warn(
"componentWillReceiveProps has been renamed, and is not recommended for use. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move data fetching code or side effects to componentDidUpdate.\n" +
"* If you're updating state whenever props change, refactor your " +
"code to use memoization techniques or move it to " +
"static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
"* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
"this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
"To rename all deprecated lifecycles to their new names, you can run " +
"`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
"\nPlease update the following components: %s",
_sortedNames4,
);
}
if (componentWillUpdateUniqueNames.size > 0) {
var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
warn(
"componentWillUpdate has been renamed, and is not recommended for use. " +
"See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
"* Move data fetching code or side effects to componentDidUpdate.\n" +
"* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
"this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
"To rename all deprecated lifecycles to their new names, you can run " +
"`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
"\nPlease update the following components: %s",
_sortedNames5,
);
}
};
var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
var didWarnAboutLegacyContext = new Set();
ReactStrictModeWarnings.recordLegacyContextWarning = function (
fiber,
instance,
) {
var strictRoot = findStrictRoot(fiber);
if (strictRoot === null) {
error(
"Expected to find a StrictMode component in a strict mode tree. " +
"This error is likely caused by a bug in React. Please file an issue.",
);
return;
} // Dedup strategy: Warn once per component.
if (didWarnAboutLegacyContext.has(fiber.type)) {
return;
}
var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
if (
fiber.type.contextTypes != null ||
fiber.type.childContextTypes != null ||
(instance !== null && typeof instance.getChildContext === "function")
) {
if (warningsForRoot === undefined) {
warningsForRoot = [];
pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
}
warningsForRoot.push(fiber);
}
};
ReactStrictModeWarnings.flushLegacyContextWarning = function () {
pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
if (fiberArray.length === 0) {
return;
}
var firstFiber = fiberArray[0];
var uniqueNames = new Set();
fiberArray.forEach(function (fiber) {
uniqueNames.add(getComponentName(fiber.type) || "Component");
didWarnAboutLegacyContext.add(fiber.type);
});
var sortedNames = setToSortedString(uniqueNames);
try {
setCurrentFiber(firstFiber);
error(
"Legacy context API has been detected within a strict-mode tree." +
"\n\nThe old API will be supported in all 16.x releases, but applications " +
"using it should migrate to the new version." +
"\n\nPlease update the following components: %s" +
"\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
sortedNames,
);
} finally {
resetCurrentFiber();
}
});
};
ReactStrictModeWarnings.discardPendingWarnings = function () {
pendingComponentWillMountWarnings = [];
pendingUNSAFE_ComponentWillMountWarnings = [];
pendingComponentWillReceivePropsWarnings = [];
pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
pendingComponentWillUpdateWarnings = [];
pendingUNSAFE_ComponentWillUpdateWarnings = [];
pendingLegacyContextWarning = new Map();
};
}
function resolveDefaultProps(Component, baseProps) {
if (Component && Component.defaultProps) {
// Resolve default props. Taken from ReactElement
var props = _assign({}, baseProps);
var defaultProps = Component.defaultProps;
for (var propName in defaultProps) {
if (props[propName] === undefined) {
props[propName] = defaultProps[propName];
}
}
return props;
}
return baseProps;
}
// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
// Math.pow(2, 30) - 1
// 0b111111111111111111111111111111
var MAX_SIGNED_31_BIT_INT = 1073741823;
var valueCursor = createCursor(null);
var rendererSigil;
{
// Use this to detect multiple renderers using the same context
rendererSigil = {};
}
var currentlyRenderingFiber = null;
var lastContextDependency = null;
var lastContextWithAllBitsObserved = null;
var isDisallowedContextReadInDEV = false;
function resetContextDependencies() {
// This is called right before React yields execution, to ensure `readContext`
// cannot be called outside the render phase.
currentlyRenderingFiber = null;
lastContextDependency = null;
lastContextWithAllBitsObserved = null;
{
isDisallowedContextReadInDEV = false;
}
}
function enterDisallowedContextReadInDEV() {
{
isDisallowedContextReadInDEV = true;
}
}
function exitDisallowedContextReadInDEV() {
{
isDisallowedContextReadInDEV = false;
}
}
function pushProvider(providerFiber, nextValue) {
var context = providerFiber.type._context;
{
push(valueCursor, context._currentValue, providerFiber);
context._currentValue = nextValue;
{
if (
context._currentRenderer !== undefined &&
context._currentRenderer !== null &&
context._currentRenderer !== rendererSigil
) {
error(
"Detected multiple renderers concurrently rendering the " +
"same context provider. This is currently unsupported.",
);
}
context._currentRenderer = rendererSigil;
}
}
}
function popProvider(providerFiber) {
var currentValue = valueCursor.current;
pop(valueCursor, providerFiber);
var context = providerFiber.type._context;
{
context._currentValue = currentValue;
}
}
function calculateChangedBits(context, newValue, oldValue) {
if (objectIs(oldValue, newValue)) {
// No change
return 0;
} else {
var changedBits =
typeof context._calculateChangedBits === "function"
? context._calculateChangedBits(oldValue, newValue)
: MAX_SIGNED_31_BIT_INT;
{
if ((changedBits & MAX_SIGNED_31_BIT_INT) !== changedBits) {
error(
"calculateChangedBits: Expected the return value to be a " +
"31-bit integer. Instead received: %s",
changedBits,
);
}
}
return changedBits | 0;
}
}
function scheduleWorkOnParentPath(parent, renderLanes) {
// Update the child lanes of all the ancestors, including the alternates.
var node = parent;
while (node !== null) {
var alternate = node.alternate;
if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
node.childLanes = mergeLanes(node.childLanes, renderLanes);
if (alternate !== null) {
alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
}
} else if (
alternate !== null &&
!isSubsetOfLanes(alternate.childLanes, renderLanes)
) {
alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
} else {
// Neither alternate was updated, which means the rest of the
// ancestor path already has sufficient priority.
break;
}
node = node.return;
}
}
function propagateContextChange(
workInProgress,
context,
changedBits,
renderLanes,
) {
var fiber = workInProgress.child;
if (fiber !== null) {
// Set the return pointer of the child to the work-in-progress fiber.
fiber.return = workInProgress;
}
while (fiber !== null) {
var nextFiber = void 0; // Visit this fiber.
var list = fiber.dependencies;
if (list !== null) {
nextFiber = fiber.child;
var dependency = list.firstContext;
while (dependency !== null) {
// Check if the context matches.
if (
dependency.context === context &&
(dependency.observedBits & changedBits) !== 0
) {
// Match! Schedule an update on this fiber.
if (fiber.tag === ClassComponent) {
// Schedule a force update on the work-in-progress.
var update = createUpdate(
NoTimestamp,
pickArbitraryLane(renderLanes),
);
update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
// update to the current fiber, too, which means it will persist even if
// this render is thrown away. Since it's a race condition, not sure it's
// worth fixing.
enqueueUpdate(fiber, update);
}
fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
var alternate = fiber.alternate;
if (alternate !== null) {
alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
}
scheduleWorkOnParentPath(fiber.return, renderLanes); // Mark the updated lanes on the list, too.
list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
// dependency list.
break;
}
dependency = dependency.next;
}
} else if (fiber.tag === ContextProvider) {
// Don't scan deeper if this is a matching provider
nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
} else {
// Traverse down.
nextFiber = fiber.child;
}
if (nextFiber !== null) {
// Set the return pointer of the child to the work-in-progress fiber.
nextFiber.return = fiber;
} else {
// No child. Traverse to next sibling.
nextFiber = fiber;
while (nextFiber !== null) {
if (nextFiber === workInProgress) {
// We're back to the root of this subtree. Exit.
nextFiber = null;
break;
}
var sibling = nextFiber.sibling;
if (sibling !== null) {
// Set the return pointer of the sibling to the work-in-progress fiber.
sibling.return = nextFiber.return;
nextFiber = sibling;
break;
} // No more siblings. Traverse up.
nextFiber = nextFiber.return;
}
}
fiber = nextFiber;
}
}
function prepareToReadContext(workInProgress, renderLanes) {
currentlyRenderingFiber = workInProgress;
lastContextDependency = null;
lastContextWithAllBitsObserved = null;
var dependencies = workInProgress.dependencies;
if (dependencies !== null) {
var firstContext = dependencies.firstContext;
if (firstContext !== null) {
if (includesSomeLane(dependencies.lanes, renderLanes)) {
// Context list has a pending update. Mark that this fiber performed work.
markWorkInProgressReceivedUpdate();
} // Reset the work-in-progress list
dependencies.firstContext = null;
}
}
}
function readContext(context, observedBits) {
{
// This warning would fire if you read context inside a Hook like useMemo.
// Unlike the class check below, it's not enforced in production for perf.
if (isDisallowedContextReadInDEV) {
error(
"Context can only be read while React is rendering. " +
"In classes, you can read it in the render method or getDerivedStateFromProps. " +
"In function components, you can read it directly in the function body, but not " +
"inside Hooks like useReducer() or useMemo().",
);
}
}
if (lastContextWithAllBitsObserved === context);
else if (observedBits === false || observedBits === 0);
else {
var resolvedObservedBits; // Avoid deopting on observable arguments or heterogeneous types.
if (
typeof observedBits !== "number" ||
observedBits === MAX_SIGNED_31_BIT_INT
) {
// Observe all updates.
lastContextWithAllBitsObserved = context;
resolvedObservedBits = MAX_SIGNED_31_BIT_INT;
} else {
resolvedObservedBits = observedBits;
}
var contextItem = {
context: context,
observedBits: resolvedObservedBits,
next: null,
};
if (lastContextDependency === null) {
if (!(currentlyRenderingFiber !== null)) {
{
throw Error(
"Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().",
);
}
} // This is the first dependency for this component. Create a new list.
lastContextDependency = contextItem;
currentlyRenderingFiber.dependencies = {
lanes: NoLanes,
firstContext: contextItem,
responders: null,
};
} else {
// Append a new context item.
lastContextDependency = lastContextDependency.next = contextItem;
}
}
return context._currentValue;
}
var UpdateState = 0;
var ReplaceState = 1;
var ForceUpdate = 2;
var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
// It should only be read right after calling `processUpdateQueue`, via
// `checkHasForceUpdateAfterProcessing`.
var hasForceUpdate = false;
var didWarnUpdateInsideUpdate;
var currentlyProcessingQueue;
{
didWarnUpdateInsideUpdate = false;
currentlyProcessingQueue = null;
}
function initializeUpdateQueue(fiber) {
var queue = {
baseState: fiber.memoizedState,
firstBaseUpdate: null,
lastBaseUpdate: null,
shared: {
pending: null,
},
effects: null,
};
fiber.updateQueue = queue;
}
function cloneUpdateQueue(current, workInProgress) {
// Clone the update queue from current. Unless it's already a clone.
var queue = workInProgress.updateQueue;
var currentQueue = current.updateQueue;
if (queue === currentQueue) {
var clone = {
baseState: currentQueue.baseState,
firstBaseUpdate: currentQueue.firstBaseUpdate,
lastBaseUpdate: currentQueue.lastBaseUpdate,
shared: currentQueue.shared,
effects: currentQueue.effects,
};
workInProgress.updateQueue = clone;
}
}
function createUpdate(eventTime, lane) {
var update = {
eventTime: eventTime,
lane: lane,
tag: UpdateState,
payload: null,
callback: null,
next: null,
};
return update;
}
function enqueueUpdate(fiber, update) {
var updateQueue = fiber.updateQueue;
if (updateQueue === null) {
// Only occurs if the fiber has been unmounted.
return;
}
var sharedQueue = updateQueue.shared;
var pending = sharedQueue.pending;
if (pending === null) {
// This is the first update. Create a circular list.
update.next = update;
} else {
update.next = pending.next;
pending.next = update;
}
sharedQueue.pending = update;
{
if (
currentlyProcessingQueue === sharedQueue &&
!didWarnUpdateInsideUpdate
) {
error(
"An update (setState, replaceState, or forceUpdate) was scheduled " +
"from inside an update function. Update functions should be pure, " +
"with zero side-effects. Consider using componentDidUpdate or a " +
"callback.",
);
didWarnUpdateInsideUpdate = true;
}
}
}
function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
// Captured updates are updates that are thrown by a child during the render
// phase. They should be discarded if the render is aborted. Therefore,
// we should only put them on the work-in-progress queue, not the current one.
var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
var current = workInProgress.alternate;
if (current !== null) {
var currentQueue = current.updateQueue;
if (queue === currentQueue) {
// The work-in-progress queue is the same as current. This happens when
// we bail out on a parent fiber that then captures an error thrown by
// a child. Since we want to append the update only to the work-in
// -progress queue, we need to clone the updates. We usually clone during
// processUpdateQueue, but that didn't happen in this case because we
// skipped over the parent when we bailed out.
var newFirst = null;
var newLast = null;
var firstBaseUpdate = queue.firstBaseUpdate;
if (firstBaseUpdate !== null) {
// Loop through the updates and clone them.
var update = firstBaseUpdate;
do {
var clone = {
eventTime: update.eventTime,
lane: update.lane,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null,
};
if (newLast === null) {
newFirst = newLast = clone;
} else {
newLast.next = clone;
newLast = clone;
}
update = update.next;
} while (update !== null); // Append the captured update the end of the cloned list.
if (newLast === null) {
newFirst = newLast = capturedUpdate;
} else {
newLast.next = capturedUpdate;
newLast = capturedUpdate;
}
} else {
// There are no base updates.
newFirst = newLast = capturedUpdate;
}
queue = {
baseState: currentQueue.baseState,
firstBaseUpdate: newFirst,
lastBaseUpdate: newLast,
shared: currentQueue.shared,
effects: currentQueue.effects,
};
workInProgress.updateQueue = queue;
return;
}
} // Append the update to the end of the list.
var lastBaseUpdate = queue.lastBaseUpdate;
if (lastBaseUpdate === null) {
queue.firstBaseUpdate = capturedUpdate;
} else {
lastBaseUpdate.next = capturedUpdate;
}
queue.lastBaseUpdate = capturedUpdate;
}
function getStateFromUpdate(
workInProgress,
queue,
update,
prevState,
nextProps,
instance,
) {
switch (update.tag) {
case ReplaceState: {
var payload = update.payload;
if (typeof payload === "function") {
// Updater function
{
enterDisallowedContextReadInDEV();
}
var nextState = payload.call(instance, prevState, nextProps);
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
payload.call(instance, prevState, nextProps);
} finally {
reenableLogs();
}
}
exitDisallowedContextReadInDEV();
}
return nextState;
} // State object
return payload;
}
case CaptureUpdate: {
workInProgress.flags =
(workInProgress.flags & ~ShouldCapture) | DidCapture;
}
// Intentional fallthrough
case UpdateState: {
var _payload = update.payload;
var partialState;
if (typeof _payload === "function") {
// Updater function
{
enterDisallowedContextReadInDEV();
}
partialState = _payload.call(instance, prevState, nextProps);
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
_payload.call(instance, prevState, nextProps);
} finally {
reenableLogs();
}
}
exitDisallowedContextReadInDEV();
}
} else {
// Partial state object
partialState = _payload;
}
if (partialState === null || partialState === undefined) {
// Null and undefined are treated as no-ops.
return prevState;
} // Merge the partial state and the previous state.
return _assign({}, prevState, partialState);
}
case ForceUpdate: {
hasForceUpdate = true;
return prevState;
}
}
return prevState;
}
function processUpdateQueue(workInProgress, props, instance, renderLanes) {
// This is always non-null on a ClassComponent or HostRoot
var queue = workInProgress.updateQueue;
hasForceUpdate = false;
{
currentlyProcessingQueue = queue.shared;
}
var firstBaseUpdate = queue.firstBaseUpdate;
var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
var pendingQueue = queue.shared.pending;
if (pendingQueue !== null) {
queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
// and last so that it's non-circular.
var lastPendingUpdate = pendingQueue;
var firstPendingUpdate = lastPendingUpdate.next;
lastPendingUpdate.next = null; // Append pending updates to base queue
if (lastBaseUpdate === null) {
firstBaseUpdate = firstPendingUpdate;
} else {
lastBaseUpdate.next = firstPendingUpdate;
}
lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
// we need to transfer the updates to that queue, too. Because the base
// queue is a singly-linked list with no cycles, we can append to both
// lists and take advantage of structural sharing.
// TODO: Pass `current` as argument
var current = workInProgress.alternate;
if (current !== null) {
// This is always non-null on a ClassComponent or HostRoot
var currentQueue = current.updateQueue;
var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
if (currentLastBaseUpdate !== lastBaseUpdate) {
if (currentLastBaseUpdate === null) {
currentQueue.firstBaseUpdate = firstPendingUpdate;
} else {
currentLastBaseUpdate.next = firstPendingUpdate;
}
currentQueue.lastBaseUpdate = lastPendingUpdate;
}
}
} // These values may change as we process the queue.
if (firstBaseUpdate !== null) {
// Iterate through the list of updates to compute the result.
var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
// from the original lanes.
var newLanes = NoLanes;
var newBaseState = null;
var newFirstBaseUpdate = null;
var newLastBaseUpdate = null;
var update = firstBaseUpdate;
do {
var updateLane = update.lane;
var updateEventTime = update.eventTime;
if (!isSubsetOfLanes(renderLanes, updateLane)) {
// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
var clone = {
eventTime: updateEventTime,
lane: updateLane,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null,
};
if (newLastBaseUpdate === null) {
newFirstBaseUpdate = newLastBaseUpdate = clone;
newBaseState = newState;
} else {
newLastBaseUpdate = newLastBaseUpdate.next = clone;
} // Update the remaining priority in the queue.
newLanes = mergeLanes(newLanes, updateLane);
} else {
// This update does have sufficient priority.
if (newLastBaseUpdate !== null) {
var _clone = {
eventTime: updateEventTime,
// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane: NoLane,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null,
};
newLastBaseUpdate = newLastBaseUpdate.next = _clone;
} // Process this update.
newState = getStateFromUpdate(
workInProgress,
queue,
update,
newState,
props,
instance,
);
var callback = update.callback;
if (callback !== null) {
workInProgress.flags |= Callback;
var effects = queue.effects;
if (effects === null) {
queue.effects = [update];
} else {
effects.push(update);
}
}
}
update = update.next;
if (update === null) {
pendingQueue = queue.shared.pending;
if (pendingQueue === null) {
break;
} else {
// An update was scheduled from inside a reducer. Add the new
// pending updates to the end of the list and keep processing.
var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
// unravel them when transferring them to the base queue.
var _firstPendingUpdate = _lastPendingUpdate.next;
_lastPendingUpdate.next = null;
update = _firstPendingUpdate;
queue.lastBaseUpdate = _lastPendingUpdate;
queue.shared.pending = null;
}
}
} while (true);
if (newLastBaseUpdate === null) {
newBaseState = newState;
}
queue.baseState = newBaseState;
queue.firstBaseUpdate = newFirstBaseUpdate;
queue.lastBaseUpdate = newLastBaseUpdate; // Set the remaining expiration time to be whatever is remaining in the queue.
// This should be fine because the only two other things that contribute to
// expiration time are props and context. We're already in the middle of the
// begin phase by the time we start processing the queue, so we've already
// dealt with the props. Context in components that specify
// shouldComponentUpdate is tricky; but we'll have to account for
// that regardless.
markSkippedUpdateLanes(newLanes);
workInProgress.lanes = newLanes;
workInProgress.memoizedState = newState;
}
{
currentlyProcessingQueue = null;
}
}
function callCallback(callback, context) {
if (!(typeof callback === "function")) {
{
throw Error(
"Invalid argument passed as callback. Expected a function. Instead received: " +
callback,
);
}
}
callback.call(context);
}
function resetHasForceUpdateBeforeProcessing() {
hasForceUpdate = false;
}
function checkHasForceUpdateAfterProcessing() {
return hasForceUpdate;
}
function commitUpdateQueue(finishedWork, finishedQueue, instance) {
// Commit the effects
var effects = finishedQueue.effects;
finishedQueue.effects = null;
if (effects !== null) {
for (var i = 0; i < effects.length; i++) {
var effect = effects[i];
var callback = effect.callback;
if (callback !== null) {
effect.callback = null;
callCallback(callback, instance);
}
}
}
}
var fakeInternalInstance = {};
var isArray = Array.isArray; // React.Component uses a shared frozen object by default.
// We'll use it to determine whether we need to initialize legacy refs.
var emptyRefsObject = new React.Component().refs;
var didWarnAboutStateAssignmentForComponent;
var didWarnAboutUninitializedState;
var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
var didWarnAboutLegacyLifecyclesAndDerivedState;
var didWarnAboutUndefinedDerivedState;
var warnOnUndefinedDerivedState;
var warnOnInvalidCallback;
var didWarnAboutDirectlyAssigningPropsToState;
var didWarnAboutContextTypeAndContextTypes;
var didWarnAboutInvalidateContextType;
{
didWarnAboutStateAssignmentForComponent = new Set();
didWarnAboutUninitializedState = new Set();
didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
didWarnAboutDirectlyAssigningPropsToState = new Set();
didWarnAboutUndefinedDerivedState = new Set();
didWarnAboutContextTypeAndContextTypes = new Set();
didWarnAboutInvalidateContextType = new Set();
var didWarnOnInvalidCallback = new Set();
warnOnInvalidCallback = function (callback, callerName) {
if (callback === null || typeof callback === "function") {
return;
}
var key = callerName + "_" + callback;
if (!didWarnOnInvalidCallback.has(key)) {
didWarnOnInvalidCallback.add(key);
error(
"%s(...): Expected the last optional `callback` argument to be a " +
"function. Instead received: %s.",
callerName,
callback,
);
}
};
warnOnUndefinedDerivedState = function (type, partialState) {
if (partialState === undefined) {
var componentName = getComponentName(type) || "Component";
if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
didWarnAboutUndefinedDerivedState.add(componentName);
error(
"%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
"You have returned undefined.",
componentName,
);
}
}
}; // This is so gross but it's at least non-critical and can be removed if
// it causes problems. This is meant to give a nicer error message for
// ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
// ...)) which otherwise throws a "_processChildContext is not a function"
// exception.
Object.defineProperty(fakeInternalInstance, "_processChildContext", {
enumerable: false,
value: function () {
{
{
throw Error(
"_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).",
);
}
}
},
});
Object.freeze(fakeInternalInstance);
}
function applyDerivedStateFromProps(
workInProgress,
ctor,
getDerivedStateFromProps,
nextProps,
) {
var prevState = workInProgress.memoizedState;
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
// Invoke the function an extra time to help detect side-effects.
getDerivedStateFromProps(nextProps, prevState);
} finally {
reenableLogs();
}
}
}
var partialState = getDerivedStateFromProps(nextProps, prevState);
{
warnOnUndefinedDerivedState(ctor, partialState);
} // Merge the partial state and the previous state.
var memoizedState =
partialState === null || partialState === undefined
? prevState
: _assign({}, prevState, partialState);
workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
// base state.
if (workInProgress.lanes === NoLanes) {
// Queue is always non-null for classes
var updateQueue = workInProgress.updateQueue;
updateQueue.baseState = memoizedState;
}
}
var classComponentUpdater = {
isMounted: isMounted,
enqueueSetState: function (inst, payload, callback) {
var fiber = get(inst);
var eventTime = requestEventTime();
var lane = requestUpdateLane(fiber);
var update = createUpdate(eventTime, lane);
update.payload = payload;
if (callback !== undefined && callback !== null) {
{
warnOnInvalidCallback(callback, "setState");
}
update.callback = callback;
}
enqueueUpdate(fiber, update);
scheduleUpdateOnFiber(fiber, lane, eventTime);
},
enqueueReplaceState: function (inst, payload, callback) {
var fiber = get(inst);
var eventTime = requestEventTime();
var lane = requestUpdateLane(fiber);
var update = createUpdate(eventTime, lane);
update.tag = ReplaceState;
update.payload = payload;
if (callback !== undefined && callback !== null) {
{
warnOnInvalidCallback(callback, "replaceState");
}
update.callback = callback;
}
enqueueUpdate(fiber, update);
scheduleUpdateOnFiber(fiber, lane, eventTime);
},
enqueueForceUpdate: function (inst, callback) {
var fiber = get(inst);
var eventTime = requestEventTime();
var lane = requestUpdateLane(fiber);
var update = createUpdate(eventTime, lane);
update.tag = ForceUpdate;
if (callback !== undefined && callback !== null) {
{
warnOnInvalidCallback(callback, "forceUpdate");
}
update.callback = callback;
}
enqueueUpdate(fiber, update);
scheduleUpdateOnFiber(fiber, lane, eventTime);
},
};
function checkShouldComponentUpdate(
workInProgress,
ctor,
oldProps,
newProps,
oldState,
newState,
nextContext,
) {
var instance = workInProgress.stateNode;
if (typeof instance.shouldComponentUpdate === "function") {
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
// Invoke the function an extra time to help detect side-effects.
instance.shouldComponentUpdate(newProps, newState, nextContext);
} finally {
reenableLogs();
}
}
}
var shouldUpdate = instance.shouldComponentUpdate(
newProps,
newState,
nextContext,
);
{
if (shouldUpdate === undefined) {
error(
"%s.shouldComponentUpdate(): Returned undefined instead of a " +
"boolean value. Make sure to return true or false.",
getComponentName(ctor) || "Component",
);
}
}
return shouldUpdate;
}
if (ctor.prototype && ctor.prototype.isPureReactComponent) {
return (
!shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
);
}
return true;
}
function checkClassInstance(workInProgress, ctor, newProps) {
var instance = workInProgress.stateNode;
{
var name = getComponentName(ctor) || "Component";
var renderPresent = instance.render;
if (!renderPresent) {
if (ctor.prototype && typeof ctor.prototype.render === "function") {
error(
"%s(...): No `render` method found on the returned component " +
"instance: did you accidentally return an object from the constructor?",
name,
);
} else {
error(
"%s(...): No `render` method found on the returned component " +
"instance: you may have forgotten to define `render`.",
name,
);
}
}
if (
instance.getInitialState &&
!instance.getInitialState.isReactClassApproved &&
!instance.state
) {
error(
"getInitialState was defined on %s, a plain JavaScript class. " +
"This is only supported for classes created using React.createClass. " +
"Did you mean to define a state property instead?",
name,
);
}
if (
instance.getDefaultProps &&
!instance.getDefaultProps.isReactClassApproved
) {
error(
"getDefaultProps was defined on %s, a plain JavaScript class. " +
"This is only supported for classes created using React.createClass. " +
"Use a static property to define defaultProps instead.",
name,
);
}
if (instance.propTypes) {
error(
"propTypes was defined as an instance property on %s. Use a static " +
"property to define propTypes instead.",
name,
);
}
if (instance.contextType) {
error(
"contextType was defined as an instance property on %s. Use a static " +
"property to define contextType instead.",
name,
);
}
{
if (instance.contextTypes) {
error(
"contextTypes was defined as an instance property on %s. Use a static " +
"property to define contextTypes instead.",
name,
);
}
if (
ctor.contextType &&
ctor.contextTypes &&
!didWarnAboutContextTypeAndContextTypes.has(ctor)
) {
didWarnAboutContextTypeAndContextTypes.add(ctor);
error(
"%s declares both contextTypes and contextType static properties. " +
"The legacy contextTypes property will be ignored.",
name,
);
}
}
if (typeof instance.componentShouldUpdate === "function") {
error(
"%s has a method called " +
"componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
"The name is phrased as a question because the function is " +
"expected to return a value.",
name,
);
}
if (
ctor.prototype &&
ctor.prototype.isPureReactComponent &&
typeof instance.shouldComponentUpdate !== "undefined"
) {
error(
"%s has a method called shouldComponentUpdate(). " +
"shouldComponentUpdate should not be used when extending React.PureComponent. " +
"Please extend React.Component if shouldComponentUpdate is used.",
getComponentName(ctor) || "A pure component",
);
}
if (typeof instance.componentDidUnmount === "function") {
error(
"%s has a method called " +
"componentDidUnmount(). But there is no such lifecycle method. " +
"Did you mean componentWillUnmount()?",
name,
);
}
if (typeof instance.componentDidReceiveProps === "function") {
error(
"%s has a method called " +
"componentDidReceiveProps(). But there is no such lifecycle method. " +
"If you meant to update the state in response to changing props, " +
"use componentWillReceiveProps(). If you meant to fetch data or " +
"run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
name,
);
}
if (typeof instance.componentWillRecieveProps === "function") {
error(
"%s has a method called " +
"componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
name,
);
}
if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
error(
"%s has a method called " +
"UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
name,
);
}
var hasMutatedProps = instance.props !== newProps;
if (instance.props !== undefined && hasMutatedProps) {
error(
"%s(...): When calling super() in `%s`, make sure to pass " +
"up the same props that your component's constructor was passed.",
name,
name,
);
}
if (instance.defaultProps) {
error(
"Setting defaultProps as an instance property on %s is not supported and will be ignored." +
" Instead, define defaultProps as a static property on %s.",
name,
name,
);
}
if (
typeof instance.getSnapshotBeforeUpdate === "function" &&
typeof instance.componentDidUpdate !== "function" &&
!didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
) {
didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
error(
"%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
"This component defines getSnapshotBeforeUpdate() only.",
getComponentName(ctor),
);
}
if (typeof instance.getDerivedStateFromProps === "function") {
error(
"%s: getDerivedStateFromProps() is defined as an instance method " +
"and will be ignored. Instead, declare it as a static method.",
name,
);
}
if (typeof instance.getDerivedStateFromError === "function") {
error(
"%s: getDerivedStateFromError() is defined as an instance method " +
"and will be ignored. Instead, declare it as a static method.",
name,
);
}
if (typeof ctor.getSnapshotBeforeUpdate === "function") {
error(
"%s: getSnapshotBeforeUpdate() is defined as a static method " +
"and will be ignored. Instead, declare it as an instance method.",
name,
);
}
var _state = instance.state;
if (_state && (typeof _state !== "object" || isArray(_state))) {
error("%s.state: must be set to an object or null", name);
}
if (
typeof instance.getChildContext === "function" &&
typeof ctor.childContextTypes !== "object"
) {
error(
"%s.getChildContext(): childContextTypes must be defined in order to " +
"use getChildContext().",
name,
);
}
}
}
function adoptClassInstance(workInProgress, instance) {
instance.updater = classComponentUpdater;
workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
set(instance, workInProgress);
{
instance._reactInternalInstance = fakeInternalInstance;
}
}
function constructClassInstance(workInProgress, ctor, props) {
var isLegacyContextConsumer = false;
var unmaskedContext = emptyContextObject;
var context = emptyContextObject;
var contextType = ctor.contextType;
{
if ("contextType" in ctor) {
var isValid = // Allow null for conditional declaration
contextType === null ||
(contextType !== undefined &&
contextType.$$typeof === REACT_CONTEXT_TYPE &&
contextType._context === undefined); // Not a <Context.Consumer>
if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
didWarnAboutInvalidateContextType.add(ctor);
var addendum = "";
if (contextType === undefined) {
addendum =
" However, it is set to undefined. " +
"This can be caused by a typo or by mixing up named and default imports. " +
"This can also happen due to a circular dependency, so " +
"try moving the createContext() call to a separate file.";
} else if (typeof contextType !== "object") {
addendum = " However, it is set to a " + typeof contextType + ".";
} else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
addendum =
" Did you accidentally pass the Context.Provider instead?";
} else if (contextType._context !== undefined) {
// <Context.Consumer>
addendum =
" Did you accidentally pass the Context.Consumer instead?";
} else {
addendum =
" However, it is set to an object with keys {" +
Object.keys(contextType).join(", ") +
"}.";
}
error(
"%s defines an invalid contextType. " +
"contextType should point to the Context object returned by React.createContext().%s",
getComponentName(ctor) || "Component",
addendum,
);
}
}
}
if (typeof contextType === "object" && contextType !== null) {
context = readContext(contextType);
} else {
unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
var contextTypes = ctor.contextTypes;
isLegacyContextConsumer =
contextTypes !== null && contextTypes !== undefined;
context = isLegacyContextConsumer
? getMaskedContext(workInProgress, unmaskedContext)
: emptyContextObject;
} // Instantiate twice to help detect side-effects.
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
new ctor(props, context); // eslint-disable-line no-new
} finally {
reenableLogs();
}
}
}
var instance = new ctor(props, context);
var state = (workInProgress.memoizedState =
instance.state !== null && instance.state !== undefined
? instance.state
: null);
adoptClassInstance(workInProgress, instance);
{
if (
typeof ctor.getDerivedStateFromProps === "function" &&
state === null
) {
var componentName = getComponentName(ctor) || "Component";
if (!didWarnAboutUninitializedState.has(componentName)) {
didWarnAboutUninitializedState.add(componentName);
error(
"`%s` uses `getDerivedStateFromProps` but its initial state is " +
"%s. This is not recommended. Instead, define the initial state by " +
"assigning an object to `this.state` in the constructor of `%s`. " +
"This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
componentName,
instance.state === null ? "null" : "undefined",
componentName,
);
}
} // If new component APIs are defined, "unsafe" lifecycles won't be called.
// Warn about these lifecycles if they are present.
// Don't warn about react-lifecycles-compat polyfilled methods though.
if (
typeof ctor.getDerivedStateFromProps === "function" ||
typeof instance.getSnapshotBeforeUpdate === "function"
) {
var foundWillMountName = null;
var foundWillReceivePropsName = null;
var foundWillUpdateName = null;
if (
typeof instance.componentWillMount === "function" &&
instance.componentWillMount.__suppressDeprecationWarning !== true
) {
foundWillMountName = "componentWillMount";
} else if (typeof instance.UNSAFE_componentWillMount === "function") {
foundWillMountName = "UNSAFE_componentWillMount";
}
if (
typeof instance.componentWillReceiveProps === "function" &&
instance.componentWillReceiveProps.__suppressDeprecationWarning !==
true
) {
foundWillReceivePropsName = "componentWillReceiveProps";
} else if (
typeof instance.UNSAFE_componentWillReceiveProps === "function"
) {
foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
}
if (
typeof instance.componentWillUpdate === "function" &&
instance.componentWillUpdate.__suppressDeprecationWarning !== true
) {
foundWillUpdateName = "componentWillUpdate";
} else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
foundWillUpdateName = "UNSAFE_componentWillUpdate";
}
if (
foundWillMountName !== null ||
foundWillReceivePropsName !== null ||
foundWillUpdateName !== null
) {
var _componentName = getComponentName(ctor) || "Component";
var newApiName =
typeof ctor.getDerivedStateFromProps === "function"
? "getDerivedStateFromProps()"
: "getSnapshotBeforeUpdate()";
if (
!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)
) {
didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
error(
"Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" +
"%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" +
"The above lifecycles should be removed. Learn more about this warning here:\n" +
"https://reactjs.org/link/unsafe-component-lifecycles",
_componentName,
newApiName,
foundWillMountName !== null ? "\n " + foundWillMountName : "",
foundWillReceivePropsName !== null
? "\n " + foundWillReceivePropsName
: "",
foundWillUpdateName !== null ? "\n " + foundWillUpdateName : "",
);
}
}
}
} // Cache unmasked context so we can avoid recreating masked context unless necessary.
// ReactFiberContext usually updates this cache but can't for newly-created instances.
if (isLegacyContextConsumer) {
cacheContext(workInProgress, unmaskedContext, context);
}
return instance;
}
function callComponentWillMount(workInProgress, instance) {
var oldState = instance.state;
if (typeof instance.componentWillMount === "function") {
instance.componentWillMount();
}
if (typeof instance.UNSAFE_componentWillMount === "function") {
instance.UNSAFE_componentWillMount();
}
if (oldState !== instance.state) {
{
error(
"%s.componentWillMount(): Assigning directly to this.state is " +
"deprecated (except inside a component's " +
"constructor). Use setState instead.",
getComponentName(workInProgress.type) || "Component",
);
}
classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
}
}
function callComponentWillReceiveProps(
workInProgress,
instance,
newProps,
nextContext,
) {
var oldState = instance.state;
if (typeof instance.componentWillReceiveProps === "function") {
instance.componentWillReceiveProps(newProps, nextContext);
}
if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
}
if (instance.state !== oldState) {
{
var componentName =
getComponentName(workInProgress.type) || "Component";
if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
didWarnAboutStateAssignmentForComponent.add(componentName);
error(
"%s.componentWillReceiveProps(): Assigning directly to " +
"this.state is deprecated (except inside a component's " +
"constructor). Use setState instead.",
componentName,
);
}
}
classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
}
} // Invokes the mount life-cycles on a previously never rendered instance.
function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
{
checkClassInstance(workInProgress, ctor, newProps);
}
var instance = workInProgress.stateNode;
instance.props = newProps;
instance.state = workInProgress.memoizedState;
instance.refs = emptyRefsObject;
initializeUpdateQueue(workInProgress);
var contextType = ctor.contextType;
if (typeof contextType === "object" && contextType !== null) {
instance.context = readContext(contextType);
} else {
var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
instance.context = getMaskedContext(workInProgress, unmaskedContext);
}
{
if (instance.state === newProps) {
var componentName = getComponentName(ctor) || "Component";
if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
didWarnAboutDirectlyAssigningPropsToState.add(componentName);
error(
"%s: It is not recommended to assign props directly to state " +
"because updates to props won't be reflected in state. " +
"In most cases, it is better to use props directly.",
componentName,
);
}
}
if (workInProgress.mode & StrictMode) {
ReactStrictModeWarnings.recordLegacyContextWarning(
workInProgress,
instance,
);
}
{
ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
workInProgress,
instance,
);
}
}
processUpdateQueue(workInProgress, newProps, instance, renderLanes);
instance.state = workInProgress.memoizedState;
var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
if (typeof getDerivedStateFromProps === "function") {
applyDerivedStateFromProps(
workInProgress,
ctor,
getDerivedStateFromProps,
newProps,
);
instance.state = workInProgress.memoizedState;
} // In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if (
typeof ctor.getDerivedStateFromProps !== "function" &&
typeof instance.getSnapshotBeforeUpdate !== "function" &&
(typeof instance.UNSAFE_componentWillMount === "function" ||
typeof instance.componentWillMount === "function")
) {
callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
// process them now.
processUpdateQueue(workInProgress, newProps, instance, renderLanes);
instance.state = workInProgress.memoizedState;
}
if (typeof instance.componentDidMount === "function") {
workInProgress.flags |= Update;
}
}
function resumeMountClassInstance(
workInProgress,
ctor,
newProps,
renderLanes,
) {
var instance = workInProgress.stateNode;
var oldProps = workInProgress.memoizedProps;
instance.props = oldProps;
var oldContext = instance.context;
var contextType = ctor.contextType;
var nextContext = emptyContextObject;
if (typeof contextType === "object" && contextType !== null) {
nextContext = readContext(contextType);
} else {
var nextLegacyUnmaskedContext = getUnmaskedContext(
workInProgress,
ctor,
true,
);
nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
}
var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
var hasNewLifecycles =
typeof getDerivedStateFromProps === "function" ||
typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
// ever the previously attempted to render - not the "current". However,
// during componentDidUpdate we pass the "current" props.
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if (
!hasNewLifecycles &&
(typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
typeof instance.componentWillReceiveProps === "function")
) {
if (oldProps !== newProps || oldContext !== nextContext) {
callComponentWillReceiveProps(
workInProgress,
instance,
newProps,
nextContext,
);
}
}
resetHasForceUpdateBeforeProcessing();
var oldState = workInProgress.memoizedState;
var newState = (instance.state = oldState);
processUpdateQueue(workInProgress, newProps, instance, renderLanes);
newState = workInProgress.memoizedState;
if (
oldProps === newProps &&
oldState === newState &&
!hasContextChanged() &&
!checkHasForceUpdateAfterProcessing()
) {
// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if (typeof instance.componentDidMount === "function") {
workInProgress.flags |= Update;
}
return false;
}
if (typeof getDerivedStateFromProps === "function") {
applyDerivedStateFromProps(
workInProgress,
ctor,
getDerivedStateFromProps,
newProps,
);
newState = workInProgress.memoizedState;
}
var shouldUpdate =
checkHasForceUpdateAfterProcessing() ||
checkShouldComponentUpdate(
workInProgress,
ctor,
oldProps,
newProps,
oldState,
newState,
nextContext,
);
if (shouldUpdate) {
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if (
!hasNewLifecycles &&
(typeof instance.UNSAFE_componentWillMount === "function" ||
typeof instance.componentWillMount === "function")
) {
if (typeof instance.componentWillMount === "function") {
instance.componentWillMount();
}
if (typeof instance.UNSAFE_componentWillMount === "function") {
instance.UNSAFE_componentWillMount();
}
}
if (typeof instance.componentDidMount === "function") {
workInProgress.flags |= Update;
}
} else {
// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if (typeof instance.componentDidMount === "function") {
workInProgress.flags |= Update;
} // If shouldComponentUpdate returned false, we should still update the
// memoized state to indicate that this work can be reused.
workInProgress.memoizedProps = newProps;
workInProgress.memoizedState = newState;
} // Update the existing instance's state, props, and context pointers even
// if shouldComponentUpdate returns false.
instance.props = newProps;
instance.state = newState;
instance.context = nextContext;
return shouldUpdate;
} // Invokes the update life-cycles and returns false if it shouldn't rerender.
function updateClassInstance(
current,
workInProgress,
ctor,
newProps,
renderLanes,
) {
var instance = workInProgress.stateNode;
cloneUpdateQueue(current, workInProgress);
var unresolvedOldProps = workInProgress.memoizedProps;
var oldProps =
workInProgress.type === workInProgress.elementType
? unresolvedOldProps
: resolveDefaultProps(workInProgress.type, unresolvedOldProps);
instance.props = oldProps;
var unresolvedNewProps = workInProgress.pendingProps;
var oldContext = instance.context;
var contextType = ctor.contextType;
var nextContext = emptyContextObject;
if (typeof contextType === "object" && contextType !== null) {
nextContext = readContext(contextType);
} else {
var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
}
var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
var hasNewLifecycles =
typeof getDerivedStateFromProps === "function" ||
typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
// ever the previously attempted to render - not the "current". However,
// during componentDidUpdate we pass the "current" props.
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if (
!hasNewLifecycles &&
(typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
typeof instance.componentWillReceiveProps === "function")
) {
if (
unresolvedOldProps !== unresolvedNewProps ||
oldContext !== nextContext
) {
callComponentWillReceiveProps(
workInProgress,
instance,
newProps,
nextContext,
);
}
}
resetHasForceUpdateBeforeProcessing();
var oldState = workInProgress.memoizedState;
var newState = (instance.state = oldState);
processUpdateQueue(workInProgress, newProps, instance, renderLanes);
newState = workInProgress.memoizedState;
if (
unresolvedOldProps === unresolvedNewProps &&
oldState === newState &&
!hasContextChanged() &&
!checkHasForceUpdateAfterProcessing()
) {
// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if (typeof instance.componentDidUpdate === "function") {
if (
unresolvedOldProps !== current.memoizedProps ||
oldState !== current.memoizedState
) {
workInProgress.flags |= Update;
}
}
if (typeof instance.getSnapshotBeforeUpdate === "function") {
if (
unresolvedOldProps !== current.memoizedProps ||
oldState !== current.memoizedState
) {
workInProgress.flags |= Snapshot;
}
}
return false;
}
if (typeof getDerivedStateFromProps === "function") {
applyDerivedStateFromProps(
workInProgress,
ctor,
getDerivedStateFromProps,
newProps,
);
newState = workInProgress.memoizedState;
}
var shouldUpdate =
checkHasForceUpdateAfterProcessing() ||
checkShouldComponentUpdate(
workInProgress,
ctor,
oldProps,
newProps,
oldState,
newState,
nextContext,
);
if (shouldUpdate) {
// In order to support react-lifecycles-compat polyfilled components,
// Unsafe lifecycles should not be invoked for components using the new APIs.
if (
!hasNewLifecycles &&
(typeof instance.UNSAFE_componentWillUpdate === "function" ||
typeof instance.componentWillUpdate === "function")
) {
if (typeof instance.componentWillUpdate === "function") {
instance.componentWillUpdate(newProps, newState, nextContext);
}
if (typeof instance.UNSAFE_componentWillUpdate === "function") {
instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
}
}
if (typeof instance.componentDidUpdate === "function") {
workInProgress.flags |= Update;
}
if (typeof instance.getSnapshotBeforeUpdate === "function") {
workInProgress.flags |= Snapshot;
}
} else {
// If an update was already in progress, we should schedule an Update
// effect even though we're bailing out, so that cWU/cDU are called.
if (typeof instance.componentDidUpdate === "function") {
if (
unresolvedOldProps !== current.memoizedProps ||
oldState !== current.memoizedState
) {
workInProgress.flags |= Update;
}
}
if (typeof instance.getSnapshotBeforeUpdate === "function") {
if (
unresolvedOldProps !== current.memoizedProps ||
oldState !== current.memoizedState
) {
workInProgress.flags |= Snapshot;
}
} // If shouldComponentUpdate returned false, we should still update the
// memoized props/state to indicate that this work can be reused.
workInProgress.memoizedProps = newProps;
workInProgress.memoizedState = newState;
} // Update the existing instance's state, props, and context pointers even
// if shouldComponentUpdate returns false.
instance.props = newProps;
instance.state = newState;
instance.context = nextContext;
return shouldUpdate;
}
var didWarnAboutMaps;
var didWarnAboutGenerators;
var didWarnAboutStringRefs;
var ownerHasKeyUseWarning;
var ownerHasFunctionTypeWarning;
var warnForMissingKey = function (child, returnFiber) {};
{
didWarnAboutMaps = false;
didWarnAboutGenerators = false;
didWarnAboutStringRefs = {};
/**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/
ownerHasKeyUseWarning = {};
ownerHasFunctionTypeWarning = {};
warnForMissingKey = function (child, returnFiber) {
if (child === null || typeof child !== "object") {
return;
}
if (!child._store || child._store.validated || child.key != null) {
return;
}
if (!(typeof child._store === "object")) {
{
throw Error(
"React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
child._store.validated = true;
var componentName = getComponentName(returnFiber.type) || "Component";
if (ownerHasKeyUseWarning[componentName]) {
return;
}
ownerHasKeyUseWarning[componentName] = true;
error(
"Each child in a list should have a unique " +
'"key" prop. See https://reactjs.org/link/warning-keys for ' +
"more information.",
);
};
}
var isArray$1 = Array.isArray;
function coerceRef(returnFiber, current, element) {
var mixedRef = element.ref;
if (
mixedRef !== null &&
typeof mixedRef !== "function" &&
typeof mixedRef !== "object"
) {
{
// TODO: Clean this up once we turn on the string ref warning for
// everyone, because the strict mode case will no longer be relevant
if (
(returnFiber.mode & StrictMode || warnAboutStringRefs) && // We warn in ReactElement.js if owner and self are equal for string refs
// because these cannot be automatically converted to an arrow function
// using a codemod. Therefore, we don't have to warn about string refs again.
!(
element._owner &&
element._self &&
element._owner.stateNode !== element._self
)
) {
var componentName = getComponentName(returnFiber.type) || "Component";
if (!didWarnAboutStringRefs[componentName]) {
{
error(
'A string ref, "%s", has been found within a strict mode tree. ' +
"String refs are a source of potential bugs and should be avoided. " +
"We recommend using useRef() or createRef() instead. " +
"Learn more about using refs safely here: " +
"https://reactjs.org/link/strict-mode-string-ref",
mixedRef,
);
}
didWarnAboutStringRefs[componentName] = true;
}
}
}
if (element._owner) {
var owner = element._owner;
var inst;
if (owner) {
var ownerFiber = owner;
if (!(ownerFiber.tag === ClassComponent)) {
{
throw Error(
"Function components cannot have string refs. We recommend using useRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref",
);
}
}
inst = ownerFiber.stateNode;
}
if (!inst) {
{
throw Error(
"Missing owner for string ref " +
mixedRef +
". This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
if (
current !== null &&
current.ref !== null &&
typeof current.ref === "function" &&
current.ref._stringRef === stringRef
) {
return current.ref;
}
var ref = function (value) {
var refs = inst.refs;
if (refs === emptyRefsObject) {
// This is a lazy pooled frozen object, so we need to initialize.
refs = inst.refs = {};
}
if (value === null) {
delete refs[stringRef];
} else {
refs[stringRef] = value;
}
};
ref._stringRef = stringRef;
return ref;
} else {
if (!(typeof mixedRef === "string")) {
{
throw Error(
"Expected ref to be a function, a string, an object returned by React.createRef(), or null.",
);
}
}
if (!element._owner) {
{
throw Error(
"Element ref was specified as a string (" +
mixedRef +
") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://reactjs.org/link/refs-must-have-owner for more information.",
);
}
}
}
}
return mixedRef;
}
function throwOnInvalidObjectType(returnFiber, newChild) {
if (returnFiber.type !== "textarea") {
{
{
throw Error(
"Objects are not valid as a React child (found: " +
(Object.prototype.toString.call(newChild) === "[object Object]"
? "object with keys {" + Object.keys(newChild).join(", ") + "}"
: newChild) +
"). If you meant to render a collection of children, use an array instead.",
);
}
}
}
}
function warnOnFunctionType(returnFiber) {
{
var componentName = getComponentName(returnFiber.type) || "Component";
if (ownerHasFunctionTypeWarning[componentName]) {
return;
}
ownerHasFunctionTypeWarning[componentName] = true;
error(
"Functions are not valid as a React child. This may happen if " +
"you return a Component instead of <Component /> from render. " +
"Or maybe you meant to call this function rather than return it.",
);
}
} // We avoid inlining this to avoid potential deopts from using try/catch.
// to be able to optimize each path individually by branching early. This needs
// a compiler or we can do it manually. Helpers that don't need this branching
// live outside of this function.
function ChildReconciler(shouldTrackSideEffects) {
function deleteChild(returnFiber, childToDelete) {
if (!shouldTrackSideEffects) {
// Noop.
return;
} // Deletions are added in reversed order so we add it to the front.
// At this point, the return fiber's effect list is empty except for
// deletions, so we can just append the deletion to the list. The remaining
// effects aren't added until the complete phase. Once we implement
// resuming, this may not be true.
var last = returnFiber.lastEffect;
if (last !== null) {
last.nextEffect = childToDelete;
returnFiber.lastEffect = childToDelete;
} else {
returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
}
childToDelete.nextEffect = null;
childToDelete.flags = Deletion;
}
function deleteRemainingChildren(returnFiber, currentFirstChild) {
if (!shouldTrackSideEffects) {
// Noop.
return null;
} // TODO: For the shouldClone case, this could be micro-optimized a bit by
// assuming that after the first child we've already added everything.
var childToDelete = currentFirstChild;
while (childToDelete !== null) {
deleteChild(returnFiber, childToDelete);
childToDelete = childToDelete.sibling;
}
return null;
}
function mapRemainingChildren(returnFiber, currentFirstChild) {
// Add the remaining children to a temporary map so that we can find them by
// keys quickly. Implicit (null) keys get added to this set with their index
// instead.
var existingChildren = new Map();
var existingChild = currentFirstChild;
while (existingChild !== null) {
if (existingChild.key !== null) {
existingChildren.set(existingChild.key, existingChild);
} else {
existingChildren.set(existingChild.index, existingChild);
}
existingChild = existingChild.sibling;
}
return existingChildren;
}
function useFiber(fiber, pendingProps) {
// We currently set sibling to null and index to 0 here because it is easy
// to forget to do before returning it. E.g. for the single child case.
var clone = createWorkInProgress(fiber, pendingProps);
clone.index = 0;
clone.sibling = null;
return clone;
}
function placeChild(newFiber, lastPlacedIndex, newIndex) {
newFiber.index = newIndex;
if (!shouldTrackSideEffects) {
// Noop.
return lastPlacedIndex;
}
var current = newFiber.alternate;
if (current !== null) {
var oldIndex = current.index;
if (oldIndex < lastPlacedIndex) {
// This is a move.
newFiber.flags = Placement;
return lastPlacedIndex;
} else {
// This item can stay in place.
return oldIndex;
}
} else {
// This is an insertion.
newFiber.flags = Placement;
return lastPlacedIndex;
}
}
function placeSingleChild(newFiber) {
// This is simpler for the single child case. We only need to do a
// placement for inserting new children.
if (shouldTrackSideEffects && newFiber.alternate === null) {
newFiber.flags = Placement;
}
return newFiber;
}
function updateTextNode(returnFiber, current, textContent, lanes) {
if (current === null || current.tag !== HostText) {
// Insert
var created = createFiberFromText(textContent, returnFiber.mode, lanes);
created.return = returnFiber;
return created;
} else {
// Update
var existing = useFiber(current, textContent);
existing.return = returnFiber;
return existing;
}
}
function updateElement(returnFiber, current, element, lanes) {
if (current !== null) {
if (
current.elementType === element.type || // Keep this check inline so it only runs on the false path:
isCompatibleFamilyForHotReloading(current, element)
) {
// Move based on index
var existing = useFiber(current, element.props);
existing.ref = coerceRef(returnFiber, current, element);
existing.return = returnFiber;
{
existing._debugSource = element._source;
existing._debugOwner = element._owner;
}
return existing;
}
} // Insert
var created = createFiberFromElement(element, returnFiber.mode, lanes);
created.ref = coerceRef(returnFiber, current, element);
created.return = returnFiber;
return created;
}
function updatePortal(returnFiber, current, portal, lanes) {
if (
current === null ||
current.tag !== HostPortal ||
current.stateNode.containerInfo !== portal.containerInfo ||
current.stateNode.implementation !== portal.implementation
) {
// Insert
var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
created.return = returnFiber;
return created;
} else {
// Update
var existing = useFiber(current, portal.children || []);
existing.return = returnFiber;
return existing;
}
}
function updateFragment(returnFiber, current, fragment, lanes, key) {
if (current === null || current.tag !== Fragment) {
// Insert
var created = createFiberFromFragment(
fragment,
returnFiber.mode,
lanes,
key,
);
created.return = returnFiber;
return created;
} else {
// Update
var existing = useFiber(current, fragment);
existing.return = returnFiber;
return existing;
}
}
function createChild(returnFiber, newChild, lanes) {
if (typeof newChild === "string" || typeof newChild === "number") {
// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
var created = createFiberFromText(
"" + newChild,
returnFiber.mode,
lanes,
);
created.return = returnFiber;
return created;
}
if (typeof newChild === "object" && newChild !== null) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE: {
var _created = createFiberFromElement(
newChild,
returnFiber.mode,
lanes,
);
_created.ref = coerceRef(returnFiber, null, newChild);
_created.return = returnFiber;
return _created;
}
case REACT_PORTAL_TYPE: {
var _created2 = createFiberFromPortal(
newChild,
returnFiber.mode,
lanes,
);
_created2.return = returnFiber;
return _created2;
}
}
if (isArray$1(newChild) || getIteratorFn(newChild)) {
var _created3 = createFiberFromFragment(
newChild,
returnFiber.mode,
lanes,
null,
);
_created3.return = returnFiber;
return _created3;
}
throwOnInvalidObjectType(returnFiber, newChild);
}
{
if (typeof newChild === "function") {
warnOnFunctionType(returnFiber);
}
}
return null;
}
function updateSlot(returnFiber, oldFiber, newChild, lanes) {
// Update the fiber if the keys match, otherwise return null.
var key = oldFiber !== null ? oldFiber.key : null;
if (typeof newChild === "string" || typeof newChild === "number") {
// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
if (key !== null) {
return null;
}
return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
}
if (typeof newChild === "object" && newChild !== null) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE: {
if (newChild.key === key) {
if (newChild.type === REACT_FRAGMENT_TYPE) {
return updateFragment(
returnFiber,
oldFiber,
newChild.props.children,
lanes,
key,
);
}
return updateElement(returnFiber, oldFiber, newChild, lanes);
} else {
return null;
}
}
case REACT_PORTAL_TYPE: {
if (newChild.key === key) {
return updatePortal(returnFiber, oldFiber, newChild, lanes);
} else {
return null;
}
}
}
if (isArray$1(newChild) || getIteratorFn(newChild)) {
if (key !== null) {
return null;
}
return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
}
throwOnInvalidObjectType(returnFiber, newChild);
}
{
if (typeof newChild === "function") {
warnOnFunctionType(returnFiber);
}
}
return null;
}
function updateFromMap(
existingChildren,
returnFiber,
newIdx,
newChild,
lanes,
) {
if (typeof newChild === "string" || typeof newChild === "number") {
// Text nodes don't have keys, so we neither have to check the old nor
// new node for the key. If both are text nodes, they match.
var matchedFiber = existingChildren.get(newIdx) || null;
return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
}
if (typeof newChild === "object" && newChild !== null) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE: {
var _matchedFiber =
existingChildren.get(
newChild.key === null ? newIdx : newChild.key,
) || null;
if (newChild.type === REACT_FRAGMENT_TYPE) {
return updateFragment(
returnFiber,
_matchedFiber,
newChild.props.children,
lanes,
newChild.key,
);
}
return updateElement(returnFiber, _matchedFiber, newChild, lanes);
}
case REACT_PORTAL_TYPE: {
var _matchedFiber2 =
existingChildren.get(
newChild.key === null ? newIdx : newChild.key,
) || null;
return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
}
}
if (isArray$1(newChild) || getIteratorFn(newChild)) {
var _matchedFiber3 = existingChildren.get(newIdx) || null;
return updateFragment(
returnFiber,
_matchedFiber3,
newChild,
lanes,
null,
);
}
throwOnInvalidObjectType(returnFiber, newChild);
}
{
if (typeof newChild === "function") {
warnOnFunctionType(returnFiber);
}
}
return null;
}
/**
* Warns if there is a duplicate or missing key
*/
function warnOnInvalidKey(child, knownKeys, returnFiber) {
{
if (typeof child !== "object" || child === null) {
return knownKeys;
}
switch (child.$$typeof) {
case REACT_ELEMENT_TYPE:
case REACT_PORTAL_TYPE:
warnForMissingKey(child, returnFiber);
var key = child.key;
if (typeof key !== "string") {
break;
}
if (knownKeys === null) {
knownKeys = new Set();
knownKeys.add(key);
break;
}
if (!knownKeys.has(key)) {
knownKeys.add(key);
break;
}
error(
"Encountered two children with the same key, `%s`. " +
"Keys should be unique so that components maintain their identity " +
"across updates. Non-unique keys may cause children to be " +
"duplicated and/or omitted — the behavior is unsupported and " +
"could change in a future version.",
key,
);
break;
}
}
return knownKeys;
}
function reconcileChildrenArray(
returnFiber,
currentFirstChild,
newChildren,
lanes,
) {
// This algorithm can't optimize by searching from both ends since we
// don't have backpointers on fibers. I'm trying to see how far we can get
// with that model. If it ends up not being worth the tradeoffs, we can
// add it later.
// Even with a two ended optimization, we'd want to optimize for the case
// where there are few changes and brute force the comparison instead of
// going for the Map. It'd like to explore hitting that path first in
// forward-only mode and only go for the Map once we notice that we need
// lots of look ahead. This doesn't handle reversal as well as two ended
// search but that's unusual. Besides, for the two ended optimization to
// work on Iterables, we'd need to copy the whole set.
// In this first iteration, we'll just live with hitting the bad case
// (adding everything to a Map) in for every insert/move.
// If you change this code, also update reconcileChildrenIterator() which
// uses the same algorithm.
{
// First, validate keys.
var knownKeys = null;
for (var i = 0; i < newChildren.length; i++) {
var child = newChildren[i];
knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
}
}
var resultingFirstChild = null;
var previousNewFiber = null;
var oldFiber = currentFirstChild;
var lastPlacedIndex = 0;
var newIdx = 0;
var nextOldFiber = null;
for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
if (oldFiber.index > newIdx) {
nextOldFiber = oldFiber;
oldFiber = null;
} else {
nextOldFiber = oldFiber.sibling;
}
var newFiber = updateSlot(
returnFiber,
oldFiber,
newChildren[newIdx],
lanes,
);
if (newFiber === null) {
// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
if (oldFiber === null) {
oldFiber = nextOldFiber;
}
break;
}
if (shouldTrackSideEffects) {
if (oldFiber && newFiber.alternate === null) {
// We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber, oldFiber);
}
}
lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = newFiber;
} else {
// TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling = newFiber;
}
previousNewFiber = newFiber;
oldFiber = nextOldFiber;
}
if (newIdx === newChildren.length) {
// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber, oldFiber);
return resultingFirstChild;
}
if (oldFiber === null) {
// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for (; newIdx < newChildren.length; newIdx++) {
var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
if (_newFiber === null) {
continue;
}
lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = _newFiber;
} else {
previousNewFiber.sibling = _newFiber;
}
previousNewFiber = _newFiber;
}
return resultingFirstChild;
} // Add all children to a key map for quick lookups.
var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
for (; newIdx < newChildren.length; newIdx++) {
var _newFiber2 = updateFromMap(
existingChildren,
returnFiber,
newIdx,
newChildren[newIdx],
lanes,
);
if (_newFiber2 !== null) {
if (shouldTrackSideEffects) {
if (_newFiber2.alternate !== null) {
// The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(
_newFiber2.key === null ? newIdx : _newFiber2.key,
);
}
}
lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
resultingFirstChild = _newFiber2;
} else {
previousNewFiber.sibling = _newFiber2;
}
previousNewFiber = _newFiber2;
}
}
if (shouldTrackSideEffects) {
// Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function (child) {
return deleteChild(returnFiber, child);
});
}
return resultingFirstChild;
}
function reconcileChildrenIterator(
returnFiber,
currentFirstChild,
newChildrenIterable,
lanes,
) {
// This is the same implementation as reconcileChildrenArray(),
// but using the iterator instead.
var iteratorFn = getIteratorFn(newChildrenIterable);
if (!(typeof iteratorFn === "function")) {
{
throw Error(
"An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
{
// We don't support rendering Generators because it's a mutation.
// See https://github.com/facebook/react/issues/12995
if (
typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
newChildrenIterable[Symbol.toStringTag] === "Generator"
) {
if (!didWarnAboutGenerators) {
error(
"Using Generators as children is unsupported and will likely yield " +
"unexpected results because enumerating a generator mutates it. " +
"You may convert it to an array with `Array.from()` or the " +
"`[...spread]` operator before rendering. Keep in mind " +
"you might need to polyfill these features for older browsers.",
);
}
didWarnAboutGenerators = true;
} // Warn about using Maps as children
if (newChildrenIterable.entries === iteratorFn) {
if (!didWarnAboutMaps) {
error(
"Using Maps as children is not supported. " +
"Use an array of keyed ReactElements instead.",
);
}
didWarnAboutMaps = true;
} // First, validate keys.
// We'll get a different iterator later for the main pass.
var _newChildren = iteratorFn.call(newChildrenIterable);
if (_newChildren) {
var knownKeys = null;
var _step = _newChildren.next();
for (; !_step.done; _step = _newChildren.next()) {
var child = _step.value;
knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
}
}
}
var newChildren = iteratorFn.call(newChildrenIterable);
if (!(newChildren != null)) {
{
throw Error("An iterable object provided no iterator.");
}
}
var resultingFirstChild = null;
var previousNewFiber = null;
var oldFiber = currentFirstChild;
var lastPlacedIndex = 0;
var newIdx = 0;
var nextOldFiber = null;
var step = newChildren.next();
for (
;
oldFiber !== null && !step.done;
newIdx++, step = newChildren.next()
) {
if (oldFiber.index > newIdx) {
nextOldFiber = oldFiber;
oldFiber = null;
} else {
nextOldFiber = oldFiber.sibling;
}
var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
if (newFiber === null) {
// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
if (oldFiber === null) {
oldFiber = nextOldFiber;
}
break;
}
if (shouldTrackSideEffects) {
if (oldFiber && newFiber.alternate === null) {
// We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber, oldFiber);
}
}
lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = newFiber;
} else {
// TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling = newFiber;
}
previousNewFiber = newFiber;
oldFiber = nextOldFiber;
}
if (step.done) {
// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber, oldFiber);
return resultingFirstChild;
}
if (oldFiber === null) {
// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for (; !step.done; newIdx++, step = newChildren.next()) {
var _newFiber3 = createChild(returnFiber, step.value, lanes);
if (_newFiber3 === null) {
continue;
}
lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
// TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = _newFiber3;
} else {
previousNewFiber.sibling = _newFiber3;
}
previousNewFiber = _newFiber3;
}
return resultingFirstChild;
} // Add all children to a key map for quick lookups.
var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
for (; !step.done; newIdx++, step = newChildren.next()) {
var _newFiber4 = updateFromMap(
existingChildren,
returnFiber,
newIdx,
step.value,
lanes,
);
if (_newFiber4 !== null) {
if (shouldTrackSideEffects) {
if (_newFiber4.alternate !== null) {
// The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(
_newFiber4.key === null ? newIdx : _newFiber4.key,
);
}
}
lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
if (previousNewFiber === null) {
resultingFirstChild = _newFiber4;
} else {
previousNewFiber.sibling = _newFiber4;
}
previousNewFiber = _newFiber4;
}
}
if (shouldTrackSideEffects) {
// Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function (child) {
return deleteChild(returnFiber, child);
});
}
return resultingFirstChild;
}
function reconcileSingleTextNode(
returnFiber,
currentFirstChild,
textContent,
lanes,
) {
// There's no need to check for keys on text nodes since we don't have a
// way to define them.
if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
// We already have an existing node so let's just update it and delete
// the rest.
deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
var existing = useFiber(currentFirstChild, textContent);
existing.return = returnFiber;
return existing;
} // The existing first child is not a text node so we need to create one
// and delete the existing ones.
deleteRemainingChildren(returnFiber, currentFirstChild);
var created = createFiberFromText(textContent, returnFiber.mode, lanes);
created.return = returnFiber;
return created;
}
function reconcileSingleElement(
returnFiber,
currentFirstChild,
element,
lanes,
) {
var key = element.key;
var child = currentFirstChild;
while (child !== null) {
// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if (child.key === key) {
switch (child.tag) {
case Fragment: {
if (element.type === REACT_FRAGMENT_TYPE) {
deleteRemainingChildren(returnFiber, child.sibling);
var existing = useFiber(child, element.props.children);
existing.return = returnFiber;
{
existing._debugSource = element._source;
existing._debugOwner = element._owner;
}
return existing;
}
break;
}
case Block:
// We intentionally fallthrough here if enableBlocksAPI is not on.
// eslint-disable-next-lined no-fallthrough
default: {
if (
child.elementType === element.type || // Keep this check inline so it only runs on the false path:
isCompatibleFamilyForHotReloading(child, element)
) {
deleteRemainingChildren(returnFiber, child.sibling);
var _existing3 = useFiber(child, element.props);
_existing3.ref = coerceRef(returnFiber, child, element);
_existing3.return = returnFiber;
{
_existing3._debugSource = element._source;
_existing3._debugOwner = element._owner;
}
return _existing3;
}
break;
}
} // Didn't match.
deleteRemainingChildren(returnFiber, child);
break;
} else {
deleteChild(returnFiber, child);
}
child = child.sibling;
}
if (element.type === REACT_FRAGMENT_TYPE) {
var created = createFiberFromFragment(
element.props.children,
returnFiber.mode,
lanes,
element.key,
);
created.return = returnFiber;
return created;
} else {
var _created4 = createFiberFromElement(
element,
returnFiber.mode,
lanes,
);
_created4.ref = coerceRef(returnFiber, currentFirstChild, element);
_created4.return = returnFiber;
return _created4;
}
}
function reconcileSinglePortal(
returnFiber,
currentFirstChild,
portal,
lanes,
) {
var key = portal.key;
var child = currentFirstChild;
while (child !== null) {
// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if (child.key === key) {
if (
child.tag === HostPortal &&
child.stateNode.containerInfo === portal.containerInfo &&
child.stateNode.implementation === portal.implementation
) {
deleteRemainingChildren(returnFiber, child.sibling);
var existing = useFiber(child, portal.children || []);
existing.return = returnFiber;
return existing;
} else {
deleteRemainingChildren(returnFiber, child);
break;
}
} else {
deleteChild(returnFiber, child);
}
child = child.sibling;
}
var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
created.return = returnFiber;
return created;
} // This API will tag the children with the side-effect of the reconciliation
// itself. They will be added to the side-effect list as we pass through the
// children and the parent.
function reconcileChildFibers(
returnFiber,
currentFirstChild,
newChild,
lanes,
) {
// This function is not recursive.
// If the top level item is an array, we treat it as a set of children,
// not as a fragment. Nested arrays on the other hand will be treated as
// fragment nodes. Recursion happens at the normal flow.
// Handle top level unkeyed fragments as if they were arrays.
// This leads to an ambiguity between <>{[...]}</> and <>...</>.
// We treat the ambiguous cases above the same.
var isUnkeyedTopLevelFragment =
typeof newChild === "object" &&
newChild !== null &&
newChild.type === REACT_FRAGMENT_TYPE &&
newChild.key === null;
if (isUnkeyedTopLevelFragment) {
newChild = newChild.props.children;
} // Handle object types
var isObject = typeof newChild === "object" && newChild !== null;
if (isObject) {
switch (newChild.$$typeof) {
case REACT_ELEMENT_TYPE:
return placeSingleChild(
reconcileSingleElement(
returnFiber,
currentFirstChild,
newChild,
lanes,
),
);
case REACT_PORTAL_TYPE:
return placeSingleChild(
reconcileSinglePortal(
returnFiber,
currentFirstChild,
newChild,
lanes,
),
);
}
}
if (typeof newChild === "string" || typeof newChild === "number") {
return placeSingleChild(
reconcileSingleTextNode(
returnFiber,
currentFirstChild,
"" + newChild,
lanes,
),
);
}
if (isArray$1(newChild)) {
return reconcileChildrenArray(
returnFiber,
currentFirstChild,
newChild,
lanes,
);
}
if (getIteratorFn(newChild)) {
return reconcileChildrenIterator(
returnFiber,
currentFirstChild,
newChild,
lanes,
);
}
if (isObject) {
throwOnInvalidObjectType(returnFiber, newChild);
}
{
if (typeof newChild === "function") {
warnOnFunctionType(returnFiber);
}
}
if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
// If the new child is undefined, and the return fiber is a composite
// component, throw an error. If Fiber return types are disabled,
// we already threw above.
switch (returnFiber.tag) {
case ClassComponent: {
{
var instance = returnFiber.stateNode;
if (instance.render._isMockFunction) {
// We allow auto-mocks to proceed as if they're returning null.
break;
}
}
}
// Intentionally fall through to the next case, which handles both
// functions and classes
// eslint-disable-next-lined no-fallthrough
case Block:
case FunctionComponent:
case ForwardRef:
case SimpleMemoComponent: {
{
{
throw Error(
(getComponentName(returnFiber.type) || "Component") +
"(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.",
);
}
}
}
}
} // Remaining cases are all treated as empty.
return deleteRemainingChildren(returnFiber, currentFirstChild);
}
return reconcileChildFibers;
}
var reconcileChildFibers = ChildReconciler(true);
var mountChildFibers = ChildReconciler(false);
function cloneChildFibers(current, workInProgress) {
if (!(current === null || workInProgress.child === current.child)) {
{
throw Error("Resuming work not yet implemented.");
}
}
if (workInProgress.child === null) {
return;
}
var currentChild = workInProgress.child;
var newChild = createWorkInProgress(
currentChild,
currentChild.pendingProps,
);
workInProgress.child = newChild;
newChild.return = workInProgress;
while (currentChild.sibling !== null) {
currentChild = currentChild.sibling;
newChild = newChild.sibling = createWorkInProgress(
currentChild,
currentChild.pendingProps,
);
newChild.return = workInProgress;
}
newChild.sibling = null;
} // Reset a workInProgress child set to prepare it for a second pass.
function resetChildFibers(workInProgress, lanes) {
var child = workInProgress.child;
while (child !== null) {
resetWorkInProgress(child, lanes);
child = child.sibling;
}
}
var NO_CONTEXT = {};
var contextStackCursor$1 = createCursor(NO_CONTEXT);
var contextFiberStackCursor = createCursor(NO_CONTEXT);
var rootInstanceStackCursor = createCursor(NO_CONTEXT);
function requiredContext(c) {
if (!(c !== NO_CONTEXT)) {
{
throw Error(
"Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
return c;
}
function getRootHostContainer() {
var rootInstance = requiredContext(rootInstanceStackCursor.current);
return rootInstance;
}
function pushHostContainer(fiber, nextRootInstance) {
// Push current root instance onto the stack;
// This allows us to reset root when portals are popped.
push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
// This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
// However, we can't just call getRootHostContext() and push it because
// we'd have a different number of entries on the stack depending on
// whether getRootHostContext() throws somewhere in renderer code or not.
// So we push an empty value first. This lets us safely unwind on errors.
push(contextStackCursor$1, NO_CONTEXT, fiber);
var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
pop(contextStackCursor$1, fiber);
push(contextStackCursor$1, nextRootContext, fiber);
}
function popHostContainer(fiber) {
pop(contextStackCursor$1, fiber);
pop(contextFiberStackCursor, fiber);
pop(rootInstanceStackCursor, fiber);
}
function getHostContext() {
var context = requiredContext(contextStackCursor$1.current);
return context;
}
function pushHostContext(fiber) {
var rootInstance = requiredContext(rootInstanceStackCursor.current);
var context = requiredContext(contextStackCursor$1.current);
var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
if (context === nextContext) {
return;
} // Track the context and the Fiber that provided it.
// This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor, fiber, fiber);
push(contextStackCursor$1, nextContext, fiber);
}
function popHostContext(fiber) {
// Do not pop unless this Fiber provided the current context.
// pushHostContext() only pushes Fibers that provide unique contexts.
if (contextFiberStackCursor.current !== fiber) {
return;
}
pop(contextStackCursor$1, fiber);
pop(contextFiberStackCursor, fiber);
}
var DefaultSuspenseContext = 0; // The Suspense Context is split into two parts. The lower bits is
// inherited deeply down the subtree. The upper bits only affect
// this immediate suspense boundary and gets reset each new
// boundary or suspense list.
var SubtreeSuspenseContextMask = 1; // Subtree Flags:
// InvisibleParentSuspenseContext indicates that one of our parent Suspense
// boundaries is not currently showing visible main content.
// Either because it is already showing a fallback or is not mounted at all.
// We can use this to determine if it is desirable to trigger a fallback at
// the parent. If not, then we might need to trigger undesirable boundaries
// and/or suspend the commit to avoid hiding the parent content.
var InvisibleParentSuspenseContext = 1; // Shallow Flags:
// ForceSuspenseFallback can be used by SuspenseList to force newly added
// items into their fallback state during one of the render passes.
var ForceSuspenseFallback = 2;
var suspenseStackCursor = createCursor(DefaultSuspenseContext);
function hasSuspenseContext(parentContext, flag) {
return (parentContext & flag) !== 0;
}
function setDefaultShallowSuspenseContext(parentContext) {
return parentContext & SubtreeSuspenseContextMask;
}
function setShallowSuspenseContext(parentContext, shallowContext) {
return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
}
function addSubtreeSuspenseContext(parentContext, subtreeContext) {
return parentContext | subtreeContext;
}
function pushSuspenseContext(fiber, newContext) {
push(suspenseStackCursor, newContext, fiber);
}
function popSuspenseContext(fiber) {
pop(suspenseStackCursor, fiber);
}
function shouldCaptureSuspense(workInProgress, hasInvisibleParent) {
// If it was the primary children that just suspended, capture and render the
// fallback. Otherwise, don't capture and bubble to the next boundary.
var nextState = workInProgress.memoizedState;
if (nextState !== null) {
if (nextState.dehydrated !== null) {
// A dehydrated boundary always captures.
return true;
}
return false;
}
var props = workInProgress.memoizedProps; // In order to capture, the Suspense component must have a fallback prop.
if (props.fallback === undefined) {
return false;
} // Regular boundaries always capture.
if (props.unstable_avoidThisFallback !== true) {
return true;
} // If it's a boundary we should avoid, then we prefer to bubble up to the
// parent boundary if it is currently invisible.
if (hasInvisibleParent) {
return false;
} // If the parent is not able to handle it, we must handle it.
return true;
}
function findFirstSuspended(row) {
var node = row;
while (node !== null) {
if (node.tag === SuspenseComponent) {
var state = node.memoizedState;
if (state !== null) {
var dehydrated = state.dehydrated;
if (
dehydrated === null ||
isSuspenseInstancePending(dehydrated) ||
isSuspenseInstanceFallback(dehydrated)
) {
return node;
}
}
} else if (
node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
// keep track of whether it suspended or not.
node.memoizedProps.revealOrder !== undefined
) {
var didSuspend = (node.flags & DidCapture) !== NoFlags;
if (didSuspend) {
return node;
}
} else if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
if (node === row) {
return null;
}
while (node.sibling === null) {
if (node.return === null || node.return === row) {
return null;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
return null;
}
var NoFlags$1 =
/* */
0; // Represents whether effect should fire.
var HasEffect =
/* */
1; // Represents the phase in which the effect (not the clean-up) fires.
var Layout =
/* */
2;
var Passive$1 =
/* */
4;
// This may have been an insertion or a hydration.
var hydrationParentFiber = null;
var nextHydratableInstance = null;
var isHydrating = false;
function enterHydrationState(fiber) {
var parentInstance = fiber.stateNode.containerInfo;
nextHydratableInstance = getFirstHydratableChild(parentInstance);
hydrationParentFiber = fiber;
isHydrating = true;
return true;
}
function deleteHydratableInstance(returnFiber, instance) {
{
switch (returnFiber.tag) {
case HostRoot:
didNotHydrateContainerInstance(
returnFiber.stateNode.containerInfo,
instance,
);
break;
case HostComponent:
didNotHydrateInstance(
returnFiber.type,
returnFiber.memoizedProps,
returnFiber.stateNode,
instance,
);
break;
}
}
var childToDelete = createFiberFromHostInstanceForDeletion();
childToDelete.stateNode = instance;
childToDelete.return = returnFiber;
childToDelete.flags = Deletion; // This might seem like it belongs on progressedFirstDeletion. However,
// these children are not part of the reconciliation list of children.
// Even if we abort and rereconcile the children, that will try to hydrate
// again and the nodes are still in the host tree so these will be
// recreated.
if (returnFiber.lastEffect !== null) {
returnFiber.lastEffect.nextEffect = childToDelete;
returnFiber.lastEffect = childToDelete;
} else {
returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
}
}
function insertNonHydratedInstance(returnFiber, fiber) {
fiber.flags = (fiber.flags & ~Hydrating) | Placement;
{
switch (returnFiber.tag) {
case HostRoot: {
var parentContainer = returnFiber.stateNode.containerInfo;
switch (fiber.tag) {
case HostComponent:
var type = fiber.type;
var props = fiber.pendingProps;
didNotFindHydratableContainerInstance(parentContainer, type);
break;
case HostText:
var text = fiber.pendingProps;
didNotFindHydratableContainerTextInstance(parentContainer, text);
break;
}
break;
}
case HostComponent: {
var parentType = returnFiber.type;
var parentProps = returnFiber.memoizedProps;
var parentInstance = returnFiber.stateNode;
switch (fiber.tag) {
case HostComponent:
var _type = fiber.type;
var _props = fiber.pendingProps;
didNotFindHydratableInstance(
parentType,
parentProps,
parentInstance,
_type,
);
break;
case HostText:
var _text = fiber.pendingProps;
didNotFindHydratableTextInstance(
parentType,
parentProps,
parentInstance,
_text,
);
break;
case SuspenseComponent:
didNotFindHydratableSuspenseInstance(parentType, parentProps);
break;
}
break;
}
default:
return;
}
}
}
function tryHydrate(fiber, nextInstance) {
switch (fiber.tag) {
case HostComponent: {
var type = fiber.type;
var props = fiber.pendingProps;
var instance = canHydrateInstance(nextInstance, type);
if (instance !== null) {
fiber.stateNode = instance;
return true;
}
return false;
}
case HostText: {
var text = fiber.pendingProps;
var textInstance = canHydrateTextInstance(nextInstance, text);
if (textInstance !== null) {
fiber.stateNode = textInstance;
return true;
}
return false;
}
case SuspenseComponent: {
return false;
}
default:
return false;
}
}
function tryToClaimNextHydratableInstance(fiber) {
if (!isHydrating) {
return;
}
var nextInstance = nextHydratableInstance;
if (!nextInstance) {
// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber, fiber);
isHydrating = false;
hydrationParentFiber = fiber;
return;
}
var firstAttemptedInstance = nextInstance;
if (!tryHydrate(fiber, nextInstance)) {
// If we can't hydrate this instance let's try the next one.
// We use this as a heuristic. It's based on intuition and not data so it
// might be flawed or unnecessary.
nextInstance = getNextHydratableSibling(firstAttemptedInstance);
if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber, fiber);
isHydrating = false;
hydrationParentFiber = fiber;
return;
} // We matched the next one, we'll now assume that the first one was
// superfluous and we'll delete it. Since we can't eagerly delete it
// we'll have to schedule a deletion. To do that, this node needs a dummy
// fiber associated with it.
deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
}
hydrationParentFiber = fiber;
nextHydratableInstance = getFirstHydratableChild(nextInstance);
}
function prepareToHydrateHostInstance(
fiber,
rootContainerInstance,
hostContext,
) {
var instance = fiber.stateNode;
var updatePayload = hydrateInstance(
instance,
fiber.type,
fiber.memoizedProps,
rootContainerInstance,
hostContext,
fiber,
); // TODO: Type this specific to this type of component.
fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
// is a new ref we mark this as an update.
if (updatePayload !== null) {
return true;
}
return false;
}
function prepareToHydrateHostTextInstance(fiber) {
var textInstance = fiber.stateNode;
var textContent = fiber.memoizedProps;
var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
{
if (shouldUpdate) {
// We assume that prepareToHydrateHostTextInstance is called in a context where the
// hydration parent is the parent host component of this host text.
var returnFiber = hydrationParentFiber;
if (returnFiber !== null) {
switch (returnFiber.tag) {
case HostRoot: {
var parentContainer = returnFiber.stateNode.containerInfo;
didNotMatchHydratedContainerTextInstance(
parentContainer,
textInstance,
textContent,
);
break;
}
case HostComponent: {
var parentType = returnFiber.type;
var parentProps = returnFiber.memoizedProps;
var parentInstance = returnFiber.stateNode;
didNotMatchHydratedTextInstance(
parentType,
parentProps,
parentInstance,
textInstance,
textContent,
);
break;
}
}
}
}
}
return shouldUpdate;
}
function skipPastDehydratedSuspenseInstance(fiber) {
var suspenseState = fiber.memoizedState;
var suspenseInstance =
suspenseState !== null ? suspenseState.dehydrated : null;
if (!suspenseInstance) {
{
throw Error(
"Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
}
function popToNextHostParent(fiber) {
var parent = fiber.return;
while (
parent !== null &&
parent.tag !== HostComponent &&
parent.tag !== HostRoot &&
parent.tag !== SuspenseComponent
) {
parent = parent.return;
}
hydrationParentFiber = parent;
}
function popHydrationState(fiber) {
if (fiber !== hydrationParentFiber) {
// We're deeper than the current hydration context, inside an inserted
// tree.
return false;
}
if (!isHydrating) {
// If we're not currently hydrating but we're in a hydration context, then
// we were an insertion and now need to pop up reenter hydration of our
// siblings.
popToNextHostParent(fiber);
isHydrating = true;
return false;
}
var type = fiber.type; // If we have any remaining hydratable nodes, we need to delete them now.
// We only do this deeper than head and body since they tend to have random
// other nodes in them. We also ignore components with pure text content in
// side of them.
// TODO: Better heuristic.
if (
fiber.tag !== HostComponent ||
(type !== "head" &&
type !== "body" &&
!shouldSetTextContent(type, fiber.memoizedProps))
) {
var nextInstance = nextHydratableInstance;
while (nextInstance) {
deleteHydratableInstance(fiber, nextInstance);
nextInstance = getNextHydratableSibling(nextInstance);
}
}
popToNextHostParent(fiber);
if (fiber.tag === SuspenseComponent) {
nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
} else {
nextHydratableInstance = hydrationParentFiber
? getNextHydratableSibling(fiber.stateNode)
: null;
}
return true;
}
function resetHydrationState() {
hydrationParentFiber = null;
nextHydratableInstance = null;
isHydrating = false;
}
function getIsHydrating() {
return isHydrating;
}
// and should be reset before starting a new render.
// This tracks which mutable sources need to be reset after a render.
var workInProgressSources = [];
var rendererSigil$1;
{
// Used to detect multiple renderers using the same mutable source.
rendererSigil$1 = {};
}
function markSourceAsDirty(mutableSource) {
workInProgressSources.push(mutableSource);
}
function resetWorkInProgressVersions() {
for (var i = 0; i < workInProgressSources.length; i++) {
var mutableSource = workInProgressSources[i];
{
mutableSource._workInProgressVersionPrimary = null;
}
}
workInProgressSources.length = 0;
}
function getWorkInProgressVersion(mutableSource) {
{
return mutableSource._workInProgressVersionPrimary;
}
}
function setWorkInProgressVersion(mutableSource, version) {
{
mutableSource._workInProgressVersionPrimary = version;
}
workInProgressSources.push(mutableSource);
}
function warnAboutMultipleRenderersDEV(mutableSource) {
{
{
if (mutableSource._currentPrimaryRenderer == null) {
mutableSource._currentPrimaryRenderer = rendererSigil$1;
} else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
error(
"Detected multiple renderers concurrently rendering the " +
"same mutable source. This is currently unsupported.",
);
}
}
}
} // Eager reads the version of a mutable source and stores it on the root.
var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;
var didWarnAboutMismatchedHooksForComponent;
var didWarnAboutUseOpaqueIdentifier;
{
didWarnAboutUseOpaqueIdentifier = {};
didWarnAboutMismatchedHooksForComponent = new Set();
}
// These are set right before calling the component.
var renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
// the work-in-progress hook.
var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
// current hook list is the list that belongs to the current fiber. The
// work-in-progress hook list is a new list that will be added to the
// work-in-progress fiber.
var currentHook = null;
var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
// does not get reset if we do another render pass; only when we're completely
// finished evaluating this component. This is an optimization so we know
// whether we need to clear render phase updates after a throw.
var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
// gets reset after each attempt.
// TODO: Maybe there's some way to consolidate this with
// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
var didScheduleRenderPhaseUpdateDuringThisPass = false;
var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
// The list stores the order of hooks used during the initial render (mount).
// Subsequent renders (updates) reference this list.
var hookTypesDev = null;
var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
// When true, such Hooks will always be "remounted". Only used during hot reload.
var ignorePreviousDependencies = false;
function mountHookTypesDev() {
{
var hookName = currentHookNameInDev;
if (hookTypesDev === null) {
hookTypesDev = [hookName];
} else {
hookTypesDev.push(hookName);
}
}
}
function updateHookTypesDev() {
{
var hookName = currentHookNameInDev;
if (hookTypesDev !== null) {
hookTypesUpdateIndexDev++;
if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
warnOnHookMismatchInDev(hookName);
}
}
}
}
function checkDepsAreArrayDev(deps) {
{
if (deps !== undefined && deps !== null && !Array.isArray(deps)) {
// Verify deps, but only on mount to avoid extra checks.
// It's unlikely their type would change as usually you define them inline.
error(
"%s received a final argument that is not an array (instead, received `%s`). When " +
"specified, the final argument must be an array.",
currentHookNameInDev,
typeof deps,
);
}
}
}
function warnOnHookMismatchInDev(currentHookName) {
{
var componentName = getComponentName(currentlyRenderingFiber$1.type);
if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
didWarnAboutMismatchedHooksForComponent.add(componentName);
if (hookTypesDev !== null) {
var table = "";
var secondColumnStart = 30;
for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
var oldHookName = hookTypesDev[i];
var newHookName =
i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
// lol @ IE not supporting String#repeat
while (row.length < secondColumnStart) {
row += " ";
}
row += newHookName + "\n";
table += row;
}
error(
"React has detected a change in the order of Hooks called by %s. " +
"This will lead to bugs and errors if not fixed. " +
"For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
" Previous render Next render\n" +
" ------------------------------------------------------\n" +
"%s" +
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
componentName,
table,
);
}
}
}
}
function throwInvalidHookError() {
{
{
throw Error(
"Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.",
);
}
}
}
function areHookInputsEqual(nextDeps, prevDeps) {
{
if (ignorePreviousDependencies) {
// Only true when this component is being hot reloaded.
return false;
}
}
if (prevDeps === null) {
{
error(
"%s received a final argument during this render, but not during " +
"the previous render. Even though the final argument is optional, " +
"its type cannot change between renders.",
currentHookNameInDev,
);
}
return false;
}
{
// Don't bother comparing lengths in prod because these arrays should be
// passed inline.
if (nextDeps.length !== prevDeps.length) {
error(
"The final argument passed to %s changed size between renders. The " +
"order and size of this array must remain constant.\n\n" +
"Previous: %s\n" +
"Incoming: %s",
currentHookNameInDev,
"[" + prevDeps.join(", ") + "]",
"[" + nextDeps.join(", ") + "]",
);
}
}
for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
if (objectIs(nextDeps[i], prevDeps[i])) {
continue;
}
return false;
}
return true;
}
function renderWithHooks(
current,
workInProgress,
Component,
props,
secondArg,
nextRenderLanes,
) {
renderLanes = nextRenderLanes;
currentlyRenderingFiber$1 = workInProgress;
{
hookTypesDev = current !== null ? current._debugHookTypes : null;
hookTypesUpdateIndexDev = -1; // Used for hot reloading:
ignorePreviousDependencies =
current !== null && current.type !== workInProgress.type;
}
workInProgress.memoizedState = null;
workInProgress.updateQueue = null;
workInProgress.lanes = NoLanes; // The following should have already been reset
// currentHook = null;
// workInProgressHook = null;
// didScheduleRenderPhaseUpdate = false;
// TODO Warn if no hooks are used at all during mount, then some are used during update.
// Currently we will identify the update render as a mount because memoizedState === null.
// This is tricky because it's valid for certain types of components (e.g. React.lazy)
// Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
// Non-stateful hooks (e.g. context) don't get added to memoizedState,
// so memoizedState would be null during updates and mounts.
{
if (current !== null && current.memoizedState !== null) {
ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
} else if (hookTypesDev !== null) {
// This dispatcher handles an edge case where a component is updating,
// but no stateful hooks have been used.
// We want to match the production code behavior (which will use HooksDispatcherOnMount),
// but with the extra DEV validation to ensure hooks ordering hasn't changed.
// This dispatcher does that.
ReactCurrentDispatcher$1.current =
HooksDispatcherOnMountWithHookTypesInDEV;
} else {
ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
}
}
var children = Component(props, secondArg); // Check if there was a render phase update
if (didScheduleRenderPhaseUpdateDuringThisPass) {
// Keep rendering in a loop for as long as render phase updates continue to
// be scheduled. Use a counter to prevent infinite loops.
var numberOfReRenders = 0;
do {
didScheduleRenderPhaseUpdateDuringThisPass = false;
if (!(numberOfReRenders < RE_RENDER_LIMIT)) {
{
throw Error(
"Too many re-renders. React limits the number of renders to prevent an infinite loop.",
);
}
}
numberOfReRenders += 1;
{
// Even when hot reloading, allow dependencies to stabilize
// after first render to prevent infinite render phase updates.
ignorePreviousDependencies = false;
} // Start over from the beginning of the list
currentHook = null;
workInProgressHook = null;
workInProgress.updateQueue = null;
{
// Also validate hook order for cascading updates.
hookTypesUpdateIndexDev = -1;
}
ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
children = Component(props, secondArg);
} while (didScheduleRenderPhaseUpdateDuringThisPass);
} // We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
{
workInProgress._debugHookTypes = hookTypesDev;
} // This check uses currentHook so that it works the same in DEV and prod bundles.
// hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
var didRenderTooFewHooks =
currentHook !== null && currentHook.next !== null;
renderLanes = NoLanes;
currentlyRenderingFiber$1 = null;
currentHook = null;
workInProgressHook = null;
{
currentHookNameInDev = null;
hookTypesDev = null;
hookTypesUpdateIndexDev = -1;
}
didScheduleRenderPhaseUpdate = false;
if (!!didRenderTooFewHooks) {
{
throw Error(
"Rendered fewer hooks than expected. This may be caused by an accidental early return statement.",
);
}
}
return children;
}
function bailoutHooks(current, workInProgress, lanes) {
workInProgress.updateQueue = current.updateQueue;
workInProgress.flags &= ~(Passive | Update);
current.lanes = removeLanes(current.lanes, lanes);
}
function resetHooksAfterThrow() {
// We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
if (didScheduleRenderPhaseUpdate) {
// There were render phase updates. These are only valid for this render
// phase, which we are now aborting. Remove the updates from the queues so
// they do not persist to the next render. Do not remove updates from hooks
// that weren't processed.
//
// Only reset the updates from the queue if it has a clone. If it does
// not have a clone, that means it wasn't processed, and the updates were
// scheduled before we entered the render phase.
var hook = currentlyRenderingFiber$1.memoizedState;
while (hook !== null) {
var queue = hook.queue;
if (queue !== null) {
queue.pending = null;
}
hook = hook.next;
}
didScheduleRenderPhaseUpdate = false;
}
renderLanes = NoLanes;
currentlyRenderingFiber$1 = null;
currentHook = null;
workInProgressHook = null;
{
hookTypesDev = null;
hookTypesUpdateIndexDev = -1;
currentHookNameInDev = null;
isUpdatingOpaqueValueInRenderPhase = false;
}
didScheduleRenderPhaseUpdateDuringThisPass = false;
}
function mountWorkInProgressHook() {
var hook = {
memoizedState: null,
baseState: null,
baseQueue: null,
queue: null,
next: null,
};
if (workInProgressHook === null) {
// This is the first hook in the list
currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
} else {
// Append to the end of the list
workInProgressHook = workInProgressHook.next = hook;
}
return workInProgressHook;
}
function updateWorkInProgressHook() {
// This function is used both for updates and for re-renders triggered by a
// render phase update. It assumes there is either a current hook we can
// clone, or a work-in-progress hook from a previous render pass that we can
// use as a base. When we reach the end of the base list, we must switch to
// the dispatcher used for mounts.
var nextCurrentHook;
if (currentHook === null) {
var current = currentlyRenderingFiber$1.alternate;
if (current !== null) {
nextCurrentHook = current.memoizedState;
} else {
nextCurrentHook = null;
}
} else {
nextCurrentHook = currentHook.next;
}
var nextWorkInProgressHook;
if (workInProgressHook === null) {
nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
} else {
nextWorkInProgressHook = workInProgressHook.next;
}
if (nextWorkInProgressHook !== null) {
// There's already a work-in-progress. Reuse it.
workInProgressHook = nextWorkInProgressHook;
nextWorkInProgressHook = workInProgressHook.next;
currentHook = nextCurrentHook;
} else {
// Clone from the current hook.
if (!(nextCurrentHook !== null)) {
{
throw Error("Rendered more hooks than during the previous render.");
}
}
currentHook = nextCurrentHook;
var newHook = {
memoizedState: currentHook.memoizedState,
baseState: currentHook.baseState,
baseQueue: currentHook.baseQueue,
queue: currentHook.queue,
next: null,
};
if (workInProgressHook === null) {
// This is the first hook in the list.
currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
} else {
// Append to the end of the list.
workInProgressHook = workInProgressHook.next = newHook;
}
}
return workInProgressHook;
}
function createFunctionComponentUpdateQueue() {
return {
lastEffect: null,
};
}
function basicStateReducer(state, action) {
// $FlowFixMe: Flow doesn't like mixed types
return typeof action === "function" ? action(state) : action;
}
function mountReducer(reducer, initialArg, init) {
var hook = mountWorkInProgressHook();
var initialState;
if (init !== undefined) {
initialState = init(initialArg);
} else {
initialState = initialArg;
}
hook.memoizedState = hook.baseState = initialState;
var queue = (hook.queue = {
pending: null,
dispatch: null,
lastRenderedReducer: reducer,
lastRenderedState: initialState,
});
var dispatch = (queue.dispatch = dispatchAction.bind(
null,
currentlyRenderingFiber$1,
queue,
));
return [hook.memoizedState, dispatch];
}
function updateReducer(reducer, initialArg, init) {
var hook = updateWorkInProgressHook();
var queue = hook.queue;
if (!(queue !== null)) {
{
throw Error(
"Should have a queue. This is likely a bug in React. Please file an issue.",
);
}
}
queue.lastRenderedReducer = reducer;
var current = currentHook; // The last rebase update that is NOT part of the base state.
var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
var pendingQueue = queue.pending;
if (pendingQueue !== null) {
// We have new updates that haven't been processed yet.
// We'll add them to the base queue.
if (baseQueue !== null) {
// Merge the pending queue and the base queue.
var baseFirst = baseQueue.next;
var pendingFirst = pendingQueue.next;
baseQueue.next = pendingFirst;
pendingQueue.next = baseFirst;
}
{
if (current.baseQueue !== baseQueue) {
// Internal invariant that should never happen, but feasibly could in
// the future if we implement resuming, or some form of that.
error(
"Internal error: Expected work-in-progress queue to be a clone. " +
"This is a bug in React.",
);
}
}
current.baseQueue = baseQueue = pendingQueue;
queue.pending = null;
}
if (baseQueue !== null) {
// We have a queue to process.
var first = baseQueue.next;
var newState = current.baseState;
var newBaseState = null;
var newBaseQueueFirst = null;
var newBaseQueueLast = null;
var update = first;
do {
var updateLane = update.lane;
if (!isSubsetOfLanes(renderLanes, updateLane)) {
// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
var clone = {
lane: updateLane,
action: update.action,
eagerReducer: update.eagerReducer,
eagerState: update.eagerState,
next: null,
};
if (newBaseQueueLast === null) {
newBaseQueueFirst = newBaseQueueLast = clone;
newBaseState = newState;
} else {
newBaseQueueLast = newBaseQueueLast.next = clone;
} // Update the remaining priority in the queue.
// TODO: Don't need to accumulate this. Instead, we can remove
// renderLanes from the original lanes.
currentlyRenderingFiber$1.lanes = mergeLanes(
currentlyRenderingFiber$1.lanes,
updateLane,
);
markSkippedUpdateLanes(updateLane);
} else {
// This update does have sufficient priority.
if (newBaseQueueLast !== null) {
var _clone = {
// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane: NoLane,
action: update.action,
eagerReducer: update.eagerReducer,
eagerState: update.eagerState,
next: null,
};
newBaseQueueLast = newBaseQueueLast.next = _clone;
} // Process this update.
if (update.eagerReducer === reducer) {
// If this update was processed eagerly, and its reducer matches the
// current reducer, we can use the eagerly computed state.
newState = update.eagerState;
} else {
var action = update.action;
newState = reducer(newState, action);
}
}
update = update.next;
} while (update !== null && update !== first);
if (newBaseQueueLast === null) {
newBaseState = newState;
} else {
newBaseQueueLast.next = newBaseQueueFirst;
} // Mark that the fiber performed work, but only if the new state is
// different from the current state.
if (!objectIs(newState, hook.memoizedState)) {
markWorkInProgressReceivedUpdate();
}
hook.memoizedState = newState;
hook.baseState = newBaseState;
hook.baseQueue = newBaseQueueLast;
queue.lastRenderedState = newState;
}
var dispatch = queue.dispatch;
return [hook.memoizedState, dispatch];
}
function rerenderReducer(reducer, initialArg, init) {
var hook = updateWorkInProgressHook();
var queue = hook.queue;
if (!(queue !== null)) {
{
throw Error(
"Should have a queue. This is likely a bug in React. Please file an issue.",
);
}
}
queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
// work-in-progress hook.
var dispatch = queue.dispatch;
var lastRenderPhaseUpdate = queue.pending;
var newState = hook.memoizedState;
if (lastRenderPhaseUpdate !== null) {
// The queue doesn't persist past this render pass.
queue.pending = null;
var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
var update = firstRenderPhaseUpdate;
do {
// Process this render phase update. We don't have to check the
// priority because it will always be the same as the current
// render's.
var action = update.action;
newState = reducer(newState, action);
update = update.next;
} while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
// different from the current state.
if (!objectIs(newState, hook.memoizedState)) {
markWorkInProgressReceivedUpdate();
}
hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
// the base state unless the queue is empty.
// TODO: Not sure if this is the desired semantics, but it's what we
// do for gDSFP. I can't remember why.
if (hook.baseQueue === null) {
hook.baseState = newState;
}
queue.lastRenderedState = newState;
}
return [newState, dispatch];
}
function readFromUnsubcribedMutableSource(root, source, getSnapshot) {
{
warnAboutMultipleRenderersDEV(source);
}
var getVersion = source._getVersion;
var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
var isSafeToReadFromSource = false; // Check the version first.
// If this render has already been started with a specific version,
// we can use it alone to determine if we can safely read from the source.
var currentRenderVersion = getWorkInProgressVersion(source);
if (currentRenderVersion !== null) {
// It's safe to read if the store hasn't been mutated since the last time
// we read something.
isSafeToReadFromSource = currentRenderVersion === version;
} else {
// If there's no version, then this is the first time we've read from the
// source during the current render pass, so we need to do a bit more work.
// What we need to determine is if there are any hooks that already
// subscribed to the source, and if so, whether there are any pending
// mutations that haven't been synchronized yet.
//
// If there are no pending mutations, then `root.mutableReadLanes` will be
// empty, and we know we can safely read.
//
// If there *are* pending mutations, we may still be able to safely read
// if the currently rendering lanes are inclusive of the pending mutation
// lanes, since that guarantees that the value we're about to read from
// the source is consistent with the values that we read during the most
// recent mutation.
isSafeToReadFromSource = isSubsetOfLanes(
renderLanes,
root.mutableReadLanes,
);
if (isSafeToReadFromSource) {
// If it's safe to read from this source during the current render,
// store the version in case other components read from it.
// A changed version number will let those components know to throw and restart the render.
setWorkInProgressVersion(source, version);
}
}
if (isSafeToReadFromSource) {
var snapshot = getSnapshot(source._source);
{
if (typeof snapshot === "function") {
error(
"Mutable source should not return a function as the snapshot value. " +
"Functions may close over mutable values and cause tearing.",
);
}
}
return snapshot;
} else {
// This handles the special case of a mutable source being shared between renderers.
// In that case, if the source is mutated between the first and second renderer,
// The second renderer don't know that it needs to reset the WIP version during unwind,
// (because the hook only marks sources as dirty if it's written to their WIP version).
// That would cause this tear check to throw again and eventually be visible to the user.
// We can avoid this infinite loop by explicitly marking the source as dirty.
//
// This can lead to tearing in the first renderer when it resumes,
// but there's nothing we can do about that (short of throwing here and refusing to continue the render).
markSourceAsDirty(source);
{
{
throw Error(
"Cannot read from mutable source during the current render without tearing. This is a bug in React. Please file an issue.",
);
}
}
}
}
function useMutableSource(hook, source, getSnapshot, subscribe) {
var root = getWorkInProgressRoot();
if (!(root !== null)) {
{
throw Error(
"Expected a work-in-progress root. This is a bug in React. Please file an issue.",
);
}
}
var getVersion = source._getVersion;
var version = getVersion(source._source);
var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
var _dispatcher$useState = dispatcher.useState(function () {
return readFromUnsubcribedMutableSource(root, source, getSnapshot);
}),
currentSnapshot = _dispatcher$useState[0],
setSnapshot = _dispatcher$useState[1];
var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
// We use it to clear the pending update queue if we have a new source.
var stateHook = workInProgressHook;
var memoizedState = hook.memoizedState;
var refs = memoizedState.refs;
var prevGetSnapshot = refs.getSnapshot;
var prevSource = memoizedState.source;
var prevSubscribe = memoizedState.subscribe;
var fiber = currentlyRenderingFiber$1;
hook.memoizedState = {
refs: refs,
source: source,
subscribe: subscribe,
}; // Sync the values needed by our subscription handler after each commit.
dispatcher.useEffect(
function () {
refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
// but this hook recreates the queue in certain cases to avoid updates from stale sources.
// handleChange() below needs to reference the dispatch function without re-subscribing,
// so we use a ref to ensure that it always has the latest version.
refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
var maybeNewVersion = getVersion(source._source);
if (!objectIs(version, maybeNewVersion)) {
var maybeNewSnapshot = getSnapshot(source._source);
{
if (typeof maybeNewSnapshot === "function") {
error(
"Mutable source should not return a function as the snapshot value. " +
"Functions may close over mutable values and cause tearing.",
);
}
}
if (!objectIs(snapshot, maybeNewSnapshot)) {
setSnapshot(maybeNewSnapshot);
var lane = requestUpdateLane(fiber);
markRootMutableRead(root, lane);
} // If the source mutated between render and now,
// there may be state updates already scheduled from the old source.
// Entangle the updates so that they render in the same batch.
markRootEntangled(root, root.mutableReadLanes);
}
},
[getSnapshot, source, subscribe],
); // If we got a new source or subscribe function, re-subscribe in a passive effect.
dispatcher.useEffect(
function () {
var handleChange = function () {
var latestGetSnapshot = refs.getSnapshot;
var latestSetSnapshot = refs.setSnapshot;
try {
latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
var lane = requestUpdateLane(fiber);
markRootMutableRead(root, lane);
} catch (error) {
// A selector might throw after a source mutation.
// e.g. it might try to read from a part of the store that no longer exists.
// In this case we should still schedule an update with React.
// Worst case the selector will throw again and then an error boundary will handle it.
latestSetSnapshot(function () {
throw error;
});
}
};
var unsubscribe = subscribe(source._source, handleChange);
{
if (typeof unsubscribe !== "function") {
error(
"Mutable source subscribe function must return an unsubscribe function.",
);
}
}
return unsubscribe;
},
[source, subscribe],
); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
//
// If either the source or the subscription have changed we can't can't trust the update queue.
// Maybe the source changed in a way that the old subscription ignored but the new one depends on.
//
// If the getSnapshot function changed, we also shouldn't rely on the update queue.
// It's possible that the underlying source was mutated between the when the last "change" event fired,
// and when the current render (with the new getSnapshot function) is processed.
//
// In both cases, we need to throw away pending updates (since they are no longer relevant)
// and treat reading from the source as we do in the mount case.
if (
!objectIs(prevGetSnapshot, getSnapshot) ||
!objectIs(prevSource, source) ||
!objectIs(prevSubscribe, subscribe)
) {
// Create a new queue and setState method,
// So if there are interleaved updates, they get pushed to the older queue.
// When this becomes current, the previous queue and dispatch method will be discarded,
// including any interleaving updates that occur.
var newQueue = {
pending: null,
dispatch: null,
lastRenderedReducer: basicStateReducer,
lastRenderedState: snapshot,
};
newQueue.dispatch = setSnapshot = dispatchAction.bind(
null,
currentlyRenderingFiber$1,
newQueue,
);
stateHook.queue = newQueue;
stateHook.baseQueue = null;
snapshot = readFromUnsubcribedMutableSource(root, source, getSnapshot);
stateHook.memoizedState = stateHook.baseState = snapshot;
}
return snapshot;
}
function mountMutableSource(source, getSnapshot, subscribe) {
var hook = mountWorkInProgressHook();
hook.memoizedState = {
refs: {
getSnapshot: getSnapshot,
setSnapshot: null,
},
source: source,
subscribe: subscribe,
};
return useMutableSource(hook, source, getSnapshot, subscribe);
}
function updateMutableSource(source, getSnapshot, subscribe) {
var hook = updateWorkInProgressHook();
return useMutableSource(hook, source, getSnapshot, subscribe);
}
function mountState(initialState) {
var hook = mountWorkInProgressHook();
if (typeof initialState === "function") {
// $FlowFixMe: Flow doesn't like mixed types
initialState = initialState();
}
hook.memoizedState = hook.baseState = initialState;
var queue = (hook.queue = {
pending: null,
dispatch: null,
lastRenderedReducer: basicStateReducer,
lastRenderedState: initialState,
});
var dispatch = (queue.dispatch = dispatchAction.bind(
null,
currentlyRenderingFiber$1,
queue,
));
return [hook.memoizedState, dispatch];
}
function updateState(initialState) {
return updateReducer(basicStateReducer);
}
function rerenderState(initialState) {
return rerenderReducer(basicStateReducer);
}
function pushEffect(tag, create, destroy, deps) {
var effect = {
tag: tag,
create: create,
destroy: destroy,
deps: deps,
// Circular
next: null,
};
var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
if (componentUpdateQueue === null) {
componentUpdateQueue = createFunctionComponentUpdateQueue();
currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
componentUpdateQueue.lastEffect = effect.next = effect;
} else {
var lastEffect = componentUpdateQueue.lastEffect;
if (lastEffect === null) {
componentUpdateQueue.lastEffect = effect.next = effect;
} else {
var firstEffect = lastEffect.next;
lastEffect.next = effect;
effect.next = firstEffect;
componentUpdateQueue.lastEffect = effect;
}
}
return effect;
}
function mountRef(initialValue) {
var hook = mountWorkInProgressHook();
var ref = {
current: initialValue,
};
{
Object.seal(ref);
}
hook.memoizedState = ref;
return ref;
}
function updateRef(initialValue) {
var hook = updateWorkInProgressHook();
return hook.memoizedState;
}
function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
var hook = mountWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
currentlyRenderingFiber$1.flags |= fiberFlags;
hook.memoizedState = pushEffect(
HasEffect | hookFlags,
create,
undefined,
nextDeps,
);
}
function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
var hook = updateWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
var destroy = undefined;
if (currentHook !== null) {
var prevEffect = currentHook.memoizedState;
destroy = prevEffect.destroy;
if (nextDeps !== null) {
var prevDeps = prevEffect.deps;
if (areHookInputsEqual(nextDeps, prevDeps)) {
pushEffect(hookFlags, create, destroy, nextDeps);
return;
}
}
}
currentlyRenderingFiber$1.flags |= fiberFlags;
hook.memoizedState = pushEffect(
HasEffect | hookFlags,
create,
destroy,
nextDeps,
);
}
function mountEffect(create, deps) {
{
// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if ("undefined" !== typeof jest) {
warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
}
}
return mountEffectImpl(Update | Passive, Passive$1, create, deps);
}
function updateEffect(create, deps) {
{
// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if ("undefined" !== typeof jest) {
warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
}
}
return updateEffectImpl(Update | Passive, Passive$1, create, deps);
}
function mountLayoutEffect(create, deps) {
return mountEffectImpl(Update, Layout, create, deps);
}
function updateLayoutEffect(create, deps) {
return updateEffectImpl(Update, Layout, create, deps);
}
function imperativeHandleEffect(create, ref) {
if (typeof ref === "function") {
var refCallback = ref;
var _inst = create();
refCallback(_inst);
return function () {
refCallback(null);
};
} else if (ref !== null && ref !== undefined) {
var refObject = ref;
{
if (!refObject.hasOwnProperty("current")) {
error(
"Expected useImperativeHandle() first argument to either be a " +
"ref callback or React.createRef() object. Instead received: %s.",
"an object with keys {" + Object.keys(refObject).join(", ") + "}",
);
}
}
var _inst2 = create();
refObject.current = _inst2;
return function () {
refObject.current = null;
};
}
}
function mountImperativeHandle(ref, create, deps) {
{
if (typeof create !== "function") {
error(
"Expected useImperativeHandle() second argument to be a function " +
"that creates a handle. Instead received: %s.",
create !== null ? typeof create : "null",
);
}
} // TODO: If deps are provided, should we skip comparing the ref itself?
var effectDeps =
deps !== null && deps !== undefined ? deps.concat([ref]) : null;
return mountEffectImpl(
Update,
Layout,
imperativeHandleEffect.bind(null, create, ref),
effectDeps,
);
}
function updateImperativeHandle(ref, create, deps) {
{
if (typeof create !== "function") {
error(
"Expected useImperativeHandle() second argument to be a function " +
"that creates a handle. Instead received: %s.",
create !== null ? typeof create : "null",
);
}
} // TODO: If deps are provided, should we skip comparing the ref itself?
var effectDeps =
deps !== null && deps !== undefined ? deps.concat([ref]) : null;
return updateEffectImpl(
Update,
Layout,
imperativeHandleEffect.bind(null, create, ref),
effectDeps,
);
}
function mountDebugValue(value, formatterFn) {
// This hook is normally a no-op.
// The react-debug-hooks package injects its own implementation
// so that e.g. DevTools can display custom hook values.
}
var updateDebugValue = mountDebugValue;
function mountCallback(callback, deps) {
var hook = mountWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
hook.memoizedState = [callback, nextDeps];
return callback;
}
function updateCallback(callback, deps) {
var hook = updateWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
var prevState = hook.memoizedState;
if (prevState !== null) {
if (nextDeps !== null) {
var prevDeps = prevState[1];
if (areHookInputsEqual(nextDeps, prevDeps)) {
return prevState[0];
}
}
}
hook.memoizedState = [callback, nextDeps];
return callback;
}
function mountMemo(nextCreate, deps) {
var hook = mountWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
var nextValue = nextCreate();
hook.memoizedState = [nextValue, nextDeps];
return nextValue;
}
function updateMemo(nextCreate, deps) {
var hook = updateWorkInProgressHook();
var nextDeps = deps === undefined ? null : deps;
var prevState = hook.memoizedState;
if (prevState !== null) {
// Assume these are defined. If they're not, areHookInputsEqual will warn.
if (nextDeps !== null) {
var prevDeps = prevState[1];
if (areHookInputsEqual(nextDeps, prevDeps)) {
return prevState[0];
}
}
}
var nextValue = nextCreate();
hook.memoizedState = [nextValue, nextDeps];
return nextValue;
}
function mountDeferredValue(value) {
var _mountState = mountState(value),
prevValue = _mountState[0],
setValue = _mountState[1];
mountEffect(
function () {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally {
ReactCurrentBatchConfig$1.transition = prevTransition;
}
},
[value],
);
return prevValue;
}
function updateDeferredValue(value) {
var _updateState = updateState(),
prevValue = _updateState[0],
setValue = _updateState[1];
updateEffect(
function () {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally {
ReactCurrentBatchConfig$1.transition = prevTransition;
}
},
[value],
);
return prevValue;
}
function rerenderDeferredValue(value) {
var _rerenderState = rerenderState(),
prevValue = _rerenderState[0],
setValue = _rerenderState[1];
updateEffect(
function () {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally {
ReactCurrentBatchConfig$1.transition = prevTransition;
}
},
[value],
);
return prevValue;
}
function startTransition(setPending, callback) {
var priorityLevel = getCurrentPriorityLevel();
{
runWithPriority$1(
priorityLevel < UserBlockingPriority$2
? UserBlockingPriority$2
: priorityLevel,
function () {
setPending(true);
},
);
runWithPriority$1(
priorityLevel > NormalPriority$1 ? NormalPriority$1 : priorityLevel,
function () {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setPending(false);
callback();
} finally {
ReactCurrentBatchConfig$1.transition = prevTransition;
}
},
);
}
}
function mountTransition() {
var _mountState2 = mountState(false),
isPending = _mountState2[0],
setPending = _mountState2[1]; // The `start` method can be stored on a ref, since `setPending`
// never changes.
var start = startTransition.bind(null, setPending);
mountRef(start);
return [start, isPending];
}
function updateTransition() {
var _updateState2 = updateState(),
isPending = _updateState2[0];
var startRef = updateRef();
var start = startRef.current;
return [start, isPending];
}
function rerenderTransition() {
var _rerenderState2 = rerenderState(),
isPending = _rerenderState2[0];
var startRef = updateRef();
var start = startRef.current;
return [start, isPending];
}
var isUpdatingOpaqueValueInRenderPhase = false;
function getIsUpdatingOpaqueValueInRenderPhaseInDEV() {
{
return isUpdatingOpaqueValueInRenderPhase;
}
}
function warnOnOpaqueIdentifierAccessInDEV(fiber) {
{
// TODO: Should warn in effects and callbacks, too
var name = getComponentName(fiber.type) || "Unknown";
if (getIsRendering() && !didWarnAboutUseOpaqueIdentifier[name]) {
error(
"The object passed back from useOpaqueIdentifier is meant to be " +
"passed through to attributes only. Do not read the " +
"value directly.",
);
didWarnAboutUseOpaqueIdentifier[name] = true;
}
}
}
function mountOpaqueIdentifier() {
var makeId = makeClientIdInDEV.bind(
null,
warnOnOpaqueIdentifierAccessInDEV.bind(null, currentlyRenderingFiber$1),
);
if (getIsHydrating()) {
var didUpgrade = false;
var fiber = currentlyRenderingFiber$1;
var readValue = function () {
if (!didUpgrade) {
// Only upgrade once. This works even inside the render phase because
// the update is added to a shared queue, which outlasts the
// in-progress render.
didUpgrade = true;
{
isUpdatingOpaqueValueInRenderPhase = true;
setId(makeId());
isUpdatingOpaqueValueInRenderPhase = false;
warnOnOpaqueIdentifierAccessInDEV(fiber);
}
}
{
{
throw Error(
"The object passed back from useOpaqueIdentifier is meant to be passed through to attributes only. Do not read the value directly.",
);
}
}
};
var id = makeOpaqueHydratingObject(readValue);
var setId = mountState(id)[1];
if ((currentlyRenderingFiber$1.mode & BlockingMode) === NoMode) {
currentlyRenderingFiber$1.flags |= Update | Passive;
pushEffect(
HasEffect | Passive$1,
function () {
setId(makeId());
},
undefined,
null,
);
}
return id;
} else {
var _id = makeId();
mountState(_id);
return _id;
}
}
function updateOpaqueIdentifier() {
var id = updateState()[0];
return id;
}
function rerenderOpaqueIdentifier() {
var id = rerenderState()[0];
return id;
}
function dispatchAction(fiber, queue, action) {
{
if (typeof arguments[3] === "function") {
error(
"State updates from the useState() and useReducer() Hooks don't support the " +
"second callback argument. To execute a side effect after " +
"rendering, declare it in the component body with useEffect().",
);
}
}
var eventTime = requestEventTime();
var lane = requestUpdateLane(fiber);
var update = {
lane: lane,
action: action,
eagerReducer: null,
eagerState: null,
next: null,
}; // Append the update to the end of the list.
var pending = queue.pending;
if (pending === null) {
// This is the first update. Create a circular list.
update.next = update;
} else {
update.next = pending.next;
pending.next = update;
}
queue.pending = update;
var alternate = fiber.alternate;
if (
fiber === currentlyRenderingFiber$1 ||
(alternate !== null && alternate === currentlyRenderingFiber$1)
) {
// This is a render phase update. Stash it in a lazily-created map of
// queue -> linked list of updates. After this render pass, we'll restart
// and apply the stashed updates on top of the work-in-progress hook.
didScheduleRenderPhaseUpdateDuringThisPass =
didScheduleRenderPhaseUpdate = true;
} else {
if (
fiber.lanes === NoLanes &&
(alternate === null || alternate.lanes === NoLanes)
) {
// The queue is currently empty, which means we can eagerly compute the
// next state before entering the render phase. If the new state is the
// same as the current state, we may be able to bail out entirely.
var lastRenderedReducer = queue.lastRenderedReducer;
if (lastRenderedReducer !== null) {
var prevDispatcher;
{
prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
}
try {
var currentState = queue.lastRenderedState;
var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
// it, on the update object. If the reducer hasn't changed by the
// time we enter the render phase, then the eager state can be used
// without calling the reducer again.
update.eagerReducer = lastRenderedReducer;
update.eagerState = eagerState;
if (objectIs(eagerState, currentState)) {
// Fast path. We can bail out without scheduling React to re-render.
// It's still possible that we'll need to rebase this update later,
// if the component re-renders for a different reason and by that
// time the reducer has changed.
return;
}
} catch (error) {
// Suppress the error. It will throw again in the render phase.
} finally {
{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
}
}
}
{
// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if ("undefined" !== typeof jest) {
warnIfNotScopedWithMatchingAct(fiber);
warnIfNotCurrentlyActingUpdatesInDev(fiber);
}
}
scheduleUpdateOnFiber(fiber, lane, eventTime);
}
}
var ContextOnlyDispatcher = {
readContext: readContext,
useCallback: throwInvalidHookError,
useContext: throwInvalidHookError,
useEffect: throwInvalidHookError,
useImperativeHandle: throwInvalidHookError,
useLayoutEffect: throwInvalidHookError,
useMemo: throwInvalidHookError,
useReducer: throwInvalidHookError,
useRef: throwInvalidHookError,
useState: throwInvalidHookError,
useDebugValue: throwInvalidHookError,
useDeferredValue: throwInvalidHookError,
useTransition: throwInvalidHookError,
useMutableSource: throwInvalidHookError,
useOpaqueIdentifier: throwInvalidHookError,
unstable_isNewReconciler: enableNewReconciler,
};
var HooksDispatcherOnMountInDEV = null;
var HooksDispatcherOnMountWithHookTypesInDEV = null;
var HooksDispatcherOnUpdateInDEV = null;
var HooksDispatcherOnRerenderInDEV = null;
var InvalidNestedHooksDispatcherOnMountInDEV = null;
var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
{
var warnInvalidContextAccess = function () {
error(
"Context can only be read while React is rendering. " +
"In classes, you can read it in the render method or getDerivedStateFromProps. " +
"In function components, you can read it directly in the function body, but not " +
"inside Hooks like useReducer() or useMemo().",
);
};
var warnInvalidHookAccess = function () {
error(
"Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
"You can only call Hooks at the top level of your React function. " +
"For more information, see " +
"https://reactjs.org/link/rules-of-hooks",
);
};
HooksDispatcherOnMountInDEV = {
readContext: function (context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
mountHookTypesDev();
checkDepsAreArrayDev(deps);
return mountCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
mountHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
mountHookTypesDev();
checkDepsAreArrayDev(deps);
return mountEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
mountHookTypesDev();
checkDepsAreArrayDev(deps);
return mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
mountHookTypesDev();
checkDepsAreArrayDev(deps);
return mountLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
mountHookTypesDev();
checkDepsAreArrayDev(deps);
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
mountHookTypesDev();
return mountRef(initialValue);
},
useState: function (initialState) {
currentHookNameInDev = "useState";
mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
mountHookTypesDev();
return mountDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
mountHookTypesDev();
return mountDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
mountHookTypesDev();
return mountTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
mountHookTypesDev();
return mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
mountHookTypesDev();
return mountOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
HooksDispatcherOnMountWithHookTypesInDEV = {
readContext: function (context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
updateHookTypesDev();
return mountCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
updateHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
updateHookTypesDev();
return mountEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
updateHookTypesDev();
return mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
updateHookTypesDev();
return mountLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
updateHookTypesDev();
return mountRef(initialValue);
},
useState: function (initialState) {
currentHookNameInDev = "useState";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
updateHookTypesDev();
return mountDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
updateHookTypesDev();
return mountDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
updateHookTypesDev();
return mountTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
updateHookTypesDev();
return mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
updateHookTypesDev();
return mountOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
HooksDispatcherOnUpdateInDEV = {
readContext: function (context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
updateHookTypesDev();
return updateCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
updateHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
updateHookTypesDev();
return updateEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
updateHookTypesDev();
return updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
updateHookTypesDev();
return updateLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
updateHookTypesDev();
return updateRef();
},
useState: function (initialState) {
currentHookNameInDev = "useState";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
updateHookTypesDev();
return updateDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
updateHookTypesDev();
return updateDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
updateHookTypesDev();
return updateTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
updateHookTypesDev();
return updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
updateHookTypesDev();
return updateOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
HooksDispatcherOnRerenderInDEV = {
readContext: function (context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
updateHookTypesDev();
return updateCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
updateHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
updateHookTypesDev();
return updateEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
updateHookTypesDev();
return updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
updateHookTypesDev();
return updateLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return updateMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return rerenderReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
updateHookTypesDev();
return updateRef();
},
useState: function (initialState) {
currentHookNameInDev = "useState";
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return rerenderState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
updateHookTypesDev();
return updateDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
updateHookTypesDev();
return rerenderDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
updateHookTypesDev();
return rerenderTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
updateHookTypesDev();
return updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
updateHookTypesDev();
return rerenderOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
InvalidNestedHooksDispatcherOnMountInDEV = {
readContext: function (context, observedBits) {
warnInvalidContextAccess();
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
warnInvalidHookAccess();
mountHookTypesDev();
return mountCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
warnInvalidHookAccess();
mountHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
warnInvalidHookAccess();
mountHookTypesDev();
return mountEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
warnInvalidHookAccess();
mountHookTypesDev();
return mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
warnInvalidHookAccess();
mountHookTypesDev();
return mountLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
warnInvalidHookAccess();
mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
warnInvalidHookAccess();
mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
warnInvalidHookAccess();
mountHookTypesDev();
return mountRef(initialValue);
},
useState: function (initialState) {
currentHookNameInDev = "useState";
warnInvalidHookAccess();
mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
warnInvalidHookAccess();
mountHookTypesDev();
return mountDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
warnInvalidHookAccess();
mountHookTypesDev();
return mountDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
warnInvalidHookAccess();
mountHookTypesDev();
return mountTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
warnInvalidHookAccess();
mountHookTypesDev();
return mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
warnInvalidHookAccess();
mountHookTypesDev();
return mountOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
InvalidNestedHooksDispatcherOnUpdateInDEV = {
readContext: function (context, observedBits) {
warnInvalidContextAccess();
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
warnInvalidHookAccess();
updateHookTypesDev();
return updateCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
warnInvalidHookAccess();
updateHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
warnInvalidHookAccess();
updateHookTypesDev();
return updateEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
warnInvalidHookAccess();
updateHookTypesDev();
return updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
warnInvalidHookAccess();
updateHookTypesDev();
return updateLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
warnInvalidHookAccess();
updateHookTypesDev();
return updateRef();
},
useState: function (initialState) {
currentHookNameInDev = "useState";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
warnInvalidHookAccess();
updateHookTypesDev();
return updateDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
warnInvalidHookAccess();
updateHookTypesDev();
return updateDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
warnInvalidHookAccess();
updateHookTypesDev();
return updateTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
warnInvalidHookAccess();
updateHookTypesDev();
return updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
warnInvalidHookAccess();
updateHookTypesDev();
return updateOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
InvalidNestedHooksDispatcherOnRerenderInDEV = {
readContext: function (context, observedBits) {
warnInvalidContextAccess();
return readContext(context, observedBits);
},
useCallback: function (callback, deps) {
currentHookNameInDev = "useCallback";
warnInvalidHookAccess();
updateHookTypesDev();
return updateCallback(callback, deps);
},
useContext: function (context, observedBits) {
currentHookNameInDev = "useContext";
warnInvalidHookAccess();
updateHookTypesDev();
return readContext(context, observedBits);
},
useEffect: function (create, deps) {
currentHookNameInDev = "useEffect";
warnInvalidHookAccess();
updateHookTypesDev();
return updateEffect(create, deps);
},
useImperativeHandle: function (ref, create, deps) {
currentHookNameInDev = "useImperativeHandle";
warnInvalidHookAccess();
updateHookTypesDev();
return updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function (create, deps) {
currentHookNameInDev = "useLayoutEffect";
warnInvalidHookAccess();
updateHookTypesDev();
return updateLayoutEffect(create, deps);
},
useMemo: function (create, deps) {
currentHookNameInDev = "useMemo";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function (reducer, initialArg, init) {
currentHookNameInDev = "useReducer";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return rerenderReducer(reducer, initialArg, init);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function (initialValue) {
currentHookNameInDev = "useRef";
warnInvalidHookAccess();
updateHookTypesDev();
return updateRef();
},
useState: function (initialState) {
currentHookNameInDev = "useState";
warnInvalidHookAccess();
updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current =
InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return rerenderState(initialState);
} finally {
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function (value, formatterFn) {
currentHookNameInDev = "useDebugValue";
warnInvalidHookAccess();
updateHookTypesDev();
return updateDebugValue();
},
useDeferredValue: function (value) {
currentHookNameInDev = "useDeferredValue";
warnInvalidHookAccess();
updateHookTypesDev();
return rerenderDeferredValue(value);
},
useTransition: function () {
currentHookNameInDev = "useTransition";
warnInvalidHookAccess();
updateHookTypesDev();
return rerenderTransition();
},
useMutableSource: function (source, getSnapshot, subscribe) {
currentHookNameInDev = "useMutableSource";
warnInvalidHookAccess();
updateHookTypesDev();
return updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function () {
currentHookNameInDev = "useOpaqueIdentifier";
warnInvalidHookAccess();
updateHookTypesDev();
return rerenderOpaqueIdentifier();
},
unstable_isNewReconciler: enableNewReconciler,
};
}
var now$1 = unstable_now;
var commitTime = 0;
var profilerStartTime = -1;
function getCommitTime() {
return commitTime;
}
function recordCommitTime() {
commitTime = now$1();
}
function startProfilerTimer(fiber) {
profilerStartTime = now$1();
if (fiber.actualStartTime < 0) {
fiber.actualStartTime = now$1();
}
}
function stopProfilerTimerIfRunning(fiber) {
profilerStartTime = -1;
}
function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
if (profilerStartTime >= 0) {
var elapsedTime = now$1() - profilerStartTime;
fiber.actualDuration += elapsedTime;
if (overrideBaseTime) {
fiber.selfBaseDuration = elapsedTime;
}
profilerStartTime = -1;
}
}
function transferActualDuration(fiber) {
// Transfer time spent rendering these children so we don't lose it
// after we rerender. This is used as a helper in special cases
// where we should count the work of multiple passes.
var child = fiber.child;
while (child) {
fiber.actualDuration += child.actualDuration;
child = child.sibling;
}
}
var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
var didReceiveUpdate = false;
var didWarnAboutBadClass;
var didWarnAboutModulePatternComponent;
var didWarnAboutContextTypeOnFunctionComponent;
var didWarnAboutGetDerivedStateOnFunctionComponent;
var didWarnAboutFunctionRefs;
var didWarnAboutReassigningProps;
var didWarnAboutRevealOrder;
var didWarnAboutTailOptions;
{
didWarnAboutBadClass = {};
didWarnAboutModulePatternComponent = {};
didWarnAboutContextTypeOnFunctionComponent = {};
didWarnAboutGetDerivedStateOnFunctionComponent = {};
didWarnAboutFunctionRefs = {};
didWarnAboutReassigningProps = false;
didWarnAboutRevealOrder = {};
didWarnAboutTailOptions = {};
}
function reconcileChildren(
current,
workInProgress,
nextChildren,
renderLanes,
) {
if (current === null) {
// If this is a fresh new component that hasn't been rendered yet, we
// won't update its child set by applying minimal side-effects. Instead,
// we will add them all to the child before it gets rendered. That means
// we can optimize this reconciliation pass by not tracking side-effects.
workInProgress.child = mountChildFibers(
workInProgress,
null,
nextChildren,
renderLanes,
);
} else {
// If the current child is the same as the work in progress, it means that
// we haven't yet started any work on these children. Therefore, we use
// the clone algorithm to create a copy of all the current children.
// If we had any progressed work already, that is invalid at this point so
// let's throw it out.
workInProgress.child = reconcileChildFibers(
workInProgress,
current.child,
nextChildren,
renderLanes,
);
}
}
function forceUnmountCurrentAndReconcile(
current,
workInProgress,
nextChildren,
renderLanes,
) {
// This function is fork of reconcileChildren. It's used in cases where we
// want to reconcile without matching against the existing set. This has the
// effect of all current children being unmounted; even if the type and key
// are the same, the old child is unmounted and a new child is created.
//
// To do this, we're going to go through the reconcile algorithm twice. In
// the first pass, we schedule a deletion for all the current children by
// passing null.
workInProgress.child = reconcileChildFibers(
workInProgress,
current.child,
null,
renderLanes,
); // In the second pass, we mount the new children. The trick here is that we
// pass null in place of where we usually pass the current child set. This has
// the effect of remounting all children regardless of whether their
// identities match.
workInProgress.child = reconcileChildFibers(
workInProgress,
null,
nextChildren,
renderLanes,
);
}
function updateForwardRef(
current,
workInProgress,
Component,
nextProps,
renderLanes,
) {
// TODO: current can be non-null here even if the component
// hasn't yet mounted. This happens after the first render suspends.
// We'll need to figure out if this is fine or can cause issues.
{
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var innerPropTypes = Component.propTypes;
if (innerPropTypes) {
checkPropTypes(
innerPropTypes,
nextProps, // Resolved props
"prop",
getComponentName(Component),
);
}
}
}
var render = Component.render;
var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
var nextChildren;
prepareToReadContext(workInProgress, renderLanes);
{
ReactCurrentOwner$1.current = workInProgress;
setIsRendering(true);
nextChildren = renderWithHooks(
current,
workInProgress,
render,
nextProps,
ref,
renderLanes,
);
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
nextChildren = renderWithHooks(
current,
workInProgress,
render,
nextProps,
ref,
renderLanes,
);
} finally {
reenableLogs();
}
}
setIsRendering(false);
}
if (current !== null && !didReceiveUpdate) {
bailoutHooks(current, workInProgress, renderLanes);
return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function updateMemoComponent(
current,
workInProgress,
Component,
nextProps,
updateLanes,
renderLanes,
) {
if (current === null) {
var type = Component.type;
if (
isSimpleFunctionComponent(type) &&
Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
Component.defaultProps === undefined
) {
var resolvedType = type;
{
resolvedType = resolveFunctionForHotReloading(type);
} // If this is a plain function component without default props,
// and with only the default shallow comparison, we upgrade it
// to a SimpleMemoComponent to allow fast path updates.
workInProgress.tag = SimpleMemoComponent;
workInProgress.type = resolvedType;
{
validateFunctionComponentInDev(workInProgress, type);
}
return updateSimpleMemoComponent(
current,
workInProgress,
resolvedType,
nextProps,
updateLanes,
renderLanes,
);
}
{
var innerPropTypes = type.propTypes;
if (innerPropTypes) {
// Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
checkPropTypes(
innerPropTypes,
nextProps, // Resolved props
"prop",
getComponentName(type),
);
}
}
var child = createFiberFromTypeAndProps(
Component.type,
null,
nextProps,
workInProgress,
workInProgress.mode,
renderLanes,
);
child.ref = workInProgress.ref;
child.return = workInProgress;
workInProgress.child = child;
return child;
}
{
var _type = Component.type;
var _innerPropTypes = _type.propTypes;
if (_innerPropTypes) {
// Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
checkPropTypes(
_innerPropTypes,
nextProps, // Resolved props
"prop",
getComponentName(_type),
);
}
}
var currentChild = current.child; // This is always exactly one child
if (!includesSomeLane(updateLanes, renderLanes)) {
// This will be the props with resolved defaultProps,
// unlike current.memoizedProps which will be the unresolved ones.
var prevProps = currentChild.memoizedProps; // Default to shallow comparison
var compare = Component.compare;
compare = compare !== null ? compare : shallowEqual;
if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
return bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
}
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
var newChild = createWorkInProgress(currentChild, nextProps);
newChild.ref = workInProgress.ref;
newChild.return = workInProgress;
workInProgress.child = newChild;
return newChild;
}
function updateSimpleMemoComponent(
current,
workInProgress,
Component,
nextProps,
updateLanes,
renderLanes,
) {
// TODO: current can be non-null here even if the component
// hasn't yet mounted. This happens when the inner render suspends.
// We'll need to figure out if this is fine or can cause issues.
{
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var outerMemoType = workInProgress.elementType;
if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
// We warn when you define propTypes on lazy()
// so let's just skip over it to find memo() outer wrapper.
// Inner props for memo are validated later.
var lazyComponent = outerMemoType;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
outerMemoType = init(payload);
} catch (x) {
outerMemoType = null;
} // Inner propTypes will be validated in the function component path.
var outerPropTypes = outerMemoType && outerMemoType.propTypes;
if (outerPropTypes) {
checkPropTypes(
outerPropTypes,
nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
"prop",
getComponentName(outerMemoType),
);
}
}
}
}
if (current !== null) {
var prevProps = current.memoizedProps;
if (
shallowEqual(prevProps, nextProps) &&
current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
workInProgress.type === current.type
) {
didReceiveUpdate = false;
if (!includesSomeLane(renderLanes, updateLanes)) {
// The pending lanes were cleared at the beginning of beginWork. We're
// about to bail out, but there might be other lanes that weren't
// included in the current render. Usually, the priority level of the
// remaining updates is accumlated during the evaluation of the
// component (i.e. when processing the update queue). But since since
// we're bailing out early *without* evaluating the component, we need
// to account for it here, too. Reset to the value of the current fiber.
// NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
// because a MemoComponent fiber does not have hooks or an update queue;
// rather, it wraps around an inner component, which may or may not
// contains hooks.
// TODO: Move the reset at in beginWork out of the common path so that
// this is no longer necessary.
workInProgress.lanes = current.lanes;
return bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
} else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags) {
// This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
didReceiveUpdate = true;
}
}
}
return updateFunctionComponent(
current,
workInProgress,
Component,
nextProps,
renderLanes,
);
}
function updateOffscreenComponent(current, workInProgress, renderLanes) {
var nextProps = workInProgress.pendingProps;
var nextChildren = nextProps.children;
var prevState = current !== null ? current.memoizedState : null;
if (
nextProps.mode === "hidden" ||
nextProps.mode === "unstable-defer-without-hiding"
) {
if ((workInProgress.mode & ConcurrentMode) === NoMode) {
// In legacy sync mode, don't defer the subtree. Render it now.
// TODO: Figure out what we should do in Blocking mode.
var nextState = {
baseLanes: NoLanes,
};
workInProgress.memoizedState = nextState;
pushRenderLanes(workInProgress, renderLanes);
} else if (!includesSomeLane(renderLanes, OffscreenLane)) {
var nextBaseLanes;
if (prevState !== null) {
var prevBaseLanes = prevState.baseLanes;
nextBaseLanes = mergeLanes(prevBaseLanes, renderLanes);
} else {
nextBaseLanes = renderLanes;
} // Schedule this fiber to re-render at offscreen priority. Then bailout.
{
markSpawnedWork(OffscreenLane);
}
workInProgress.lanes = workInProgress.childLanes =
laneToLanes(OffscreenLane);
var _nextState = {
baseLanes: nextBaseLanes,
};
workInProgress.memoizedState = _nextState; // We're about to bail out, but we need to push this to the stack anyway
// to avoid a push/pop misalignment.
pushRenderLanes(workInProgress, nextBaseLanes);
return null;
} else {
// Rendering at offscreen, so we can clear the base lanes.
var _nextState2 = {
baseLanes: NoLanes,
};
workInProgress.memoizedState = _nextState2; // Push the lanes that were skipped when we bailed out.
var subtreeRenderLanes =
prevState !== null ? prevState.baseLanes : renderLanes;
pushRenderLanes(workInProgress, subtreeRenderLanes);
}
} else {
var _subtreeRenderLanes;
if (prevState !== null) {
_subtreeRenderLanes = mergeLanes(prevState.baseLanes, renderLanes); // Since we're not hidden anymore, reset the state
workInProgress.memoizedState = null;
} else {
// We weren't previously hidden, and we still aren't, so there's nothing
// special to do. Need to push to the stack regardless, though, to avoid
// a push/pop misalignment.
_subtreeRenderLanes = renderLanes;
}
pushRenderLanes(workInProgress, _subtreeRenderLanes);
}
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
} // Note: These happen to have identical begin phases, for now. We shouldn't hold
// ourselves to this constraint, though. If the behavior diverges, we should
// fork the function.
var updateLegacyHiddenComponent = updateOffscreenComponent;
function updateFragment(current, workInProgress, renderLanes) {
var nextChildren = workInProgress.pendingProps;
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function updateMode(current, workInProgress, renderLanes) {
var nextChildren = workInProgress.pendingProps.children;
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function updateProfiler(current, workInProgress, renderLanes) {
{
workInProgress.flags |= Update; // Reset effect durations for the next eventual effect phase.
// These are reset during render to allow the DevTools commit hook a chance to read them,
var stateNode = workInProgress.stateNode;
stateNode.effectDuration = 0;
stateNode.passiveEffectDuration = 0;
}
var nextProps = workInProgress.pendingProps;
var nextChildren = nextProps.children;
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function markRef(current, workInProgress) {
var ref = workInProgress.ref;
if (
(current === null && ref !== null) ||
(current !== null && current.ref !== ref)
) {
// Schedule a Ref effect
workInProgress.flags |= Ref;
}
}
function updateFunctionComponent(
current,
workInProgress,
Component,
nextProps,
renderLanes,
) {
{
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var innerPropTypes = Component.propTypes;
if (innerPropTypes) {
checkPropTypes(
innerPropTypes,
nextProps, // Resolved props
"prop",
getComponentName(Component),
);
}
}
}
var context;
{
var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
context = getMaskedContext(workInProgress, unmaskedContext);
}
var nextChildren;
prepareToReadContext(workInProgress, renderLanes);
{
ReactCurrentOwner$1.current = workInProgress;
setIsRendering(true);
nextChildren = renderWithHooks(
current,
workInProgress,
Component,
nextProps,
context,
renderLanes,
);
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
nextChildren = renderWithHooks(
current,
workInProgress,
Component,
nextProps,
context,
renderLanes,
);
} finally {
reenableLogs();
}
}
setIsRendering(false);
}
if (current !== null && !didReceiveUpdate) {
bailoutHooks(current, workInProgress, renderLanes);
return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function updateClassComponent(
current,
workInProgress,
Component,
nextProps,
renderLanes,
) {
{
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var innerPropTypes = Component.propTypes;
if (innerPropTypes) {
checkPropTypes(
innerPropTypes,
nextProps, // Resolved props
"prop",
getComponentName(Component),
);
}
}
} // Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
var hasContext;
if (isContextProvider(Component)) {
hasContext = true;
pushContextProvider(workInProgress);
} else {
hasContext = false;
}
prepareToReadContext(workInProgress, renderLanes);
var instance = workInProgress.stateNode;
var shouldUpdate;
if (instance === null) {
if (current !== null) {
// A class component without an instance only mounts if it suspended
// inside a non-concurrent tree, in an inconsistent state. We want to
// treat it like a new mount, even though an empty version of it already
// committed. Disconnect the alternate pointers.
current.alternate = null;
workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags |= Placement;
} // In the initial pass we might need to construct the instance.
constructClassInstance(workInProgress, Component, nextProps);
mountClassInstance(workInProgress, Component, nextProps, renderLanes);
shouldUpdate = true;
} else if (current === null) {
// In a resume, we'll already have an instance we can reuse.
shouldUpdate = resumeMountClassInstance(
workInProgress,
Component,
nextProps,
renderLanes,
);
} else {
shouldUpdate = updateClassInstance(
current,
workInProgress,
Component,
nextProps,
renderLanes,
);
}
var nextUnitOfWork = finishClassComponent(
current,
workInProgress,
Component,
shouldUpdate,
hasContext,
renderLanes,
);
{
var inst = workInProgress.stateNode;
if (shouldUpdate && inst.props !== nextProps) {
if (!didWarnAboutReassigningProps) {
error(
"It looks like %s is reassigning its own `this.props` while rendering. " +
"This is not supported and can lead to confusing bugs.",
getComponentName(workInProgress.type) || "a component",
);
}
didWarnAboutReassigningProps = true;
}
}
return nextUnitOfWork;
}
function finishClassComponent(
current,
workInProgress,
Component,
shouldUpdate,
hasContext,
renderLanes,
) {
// Refs should update even if shouldComponentUpdate returns false
markRef(current, workInProgress);
var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags;
if (!shouldUpdate && !didCaptureError) {
// Context providers should defer to sCU for rendering
if (hasContext) {
invalidateContextProvider(workInProgress, Component, false);
}
return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
}
var instance = workInProgress.stateNode; // Rerender
ReactCurrentOwner$1.current = workInProgress;
var nextChildren;
if (
didCaptureError &&
typeof Component.getDerivedStateFromError !== "function"
) {
// If we captured an error, but getDerivedStateFromError is not defined,
// unmount all the children. componentDidCatch will schedule an update to
// re-render a fallback. This is temporary until we migrate everyone to
// the new API.
// TODO: Warn in a future release.
nextChildren = null;
{
stopProfilerTimerIfRunning();
}
} else {
{
setIsRendering(true);
nextChildren = instance.render();
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
instance.render();
} finally {
reenableLogs();
}
}
setIsRendering(false);
}
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
if (current !== null && didCaptureError) {
// If we're recovering from an error, reconcile without reusing any of
// the existing children. Conceptually, the normal children and the children
// that are shown on error are two different sets, so we shouldn't reuse
// normal children even if their identities match.
forceUnmountCurrentAndReconcile(
current,
workInProgress,
nextChildren,
renderLanes,
);
} else {
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
} // Memoize state using the values we just used to render.
// TODO: Restructure so we never read values from the instance.
workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
if (hasContext) {
invalidateContextProvider(workInProgress, Component, true);
}
return workInProgress.child;
}
function pushHostRootContext(workInProgress) {
var root = workInProgress.stateNode;
if (root.pendingContext) {
pushTopLevelContextObject(
workInProgress,
root.pendingContext,
root.pendingContext !== root.context,
);
} else if (root.context) {
// Should always be set
pushTopLevelContextObject(workInProgress, root.context, false);
}
pushHostContainer(workInProgress, root.containerInfo);
}
function updateHostRoot(current, workInProgress, renderLanes) {
pushHostRootContext(workInProgress);
var updateQueue = workInProgress.updateQueue;
if (!(current !== null && updateQueue !== null)) {
{
throw Error(
"If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var nextProps = workInProgress.pendingProps;
var prevState = workInProgress.memoizedState;
var prevChildren = prevState !== null ? prevState.element : null;
cloneUpdateQueue(current, workInProgress);
processUpdateQueue(workInProgress, nextProps, null, renderLanes);
var nextState = workInProgress.memoizedState; // Caution: React DevTools currently depends on this property
// being called "element".
var nextChildren = nextState.element;
if (nextChildren === prevChildren) {
resetHydrationState();
return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
}
var root = workInProgress.stateNode;
if (root.hydrate && enterHydrationState(workInProgress)) {
// If we don't have any current children this might be the first pass.
// We always try to hydrate. If this isn't a hydration pass there won't
// be any children to hydrate which is effectively the same thing as
// not hydrating.
{
var mutableSourceEagerHydrationData =
root.mutableSourceEagerHydrationData;
if (mutableSourceEagerHydrationData != null) {
for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
var mutableSource = mutableSourceEagerHydrationData[i];
var version = mutableSourceEagerHydrationData[i + 1];
setWorkInProgressVersion(mutableSource, version);
}
}
}
var child = mountChildFibers(
workInProgress,
null,
nextChildren,
renderLanes,
);
workInProgress.child = child;
var node = child;
while (node) {
// Mark each child as hydrating. This is a fast path to know whether this
// tree is part of a hydrating tree. This is used to determine if a child
// node has fully mounted yet, and for scheduling event replaying.
// Conceptually this is similar to Placement in that a new subtree is
// inserted into the React tree here. It just happens to not need DOM
// mutations because it already exists.
node.flags = (node.flags & ~Placement) | Hydrating;
node = node.sibling;
}
} else {
// Otherwise reset hydration state in case we aborted and resumed another
// root.
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
resetHydrationState();
}
return workInProgress.child;
}
function updateHostComponent(current, workInProgress, renderLanes) {
pushHostContext(workInProgress);
if (current === null) {
tryToClaimNextHydratableInstance(workInProgress);
}
var type = workInProgress.type;
var nextProps = workInProgress.pendingProps;
var prevProps = current !== null ? current.memoizedProps : null;
var nextChildren = nextProps.children;
var isDirectTextChild = shouldSetTextContent(type, nextProps);
if (isDirectTextChild) {
// We special case a direct text child of a host node. This is a common
// case. We won't handle it as a reified child. We will instead handle
// this in the host environment that also has access to this prop. That
// avoids allocating another HostText fiber and traversing it.
nextChildren = null;
} else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
// If we're switching from a direct text child to a normal child, or to
// empty, we need to schedule the text content to be reset.
workInProgress.flags |= ContentReset;
}
markRef(current, workInProgress);
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
return workInProgress.child;
}
function updateHostText(current, workInProgress) {
if (current === null) {
tryToClaimNextHydratableInstance(workInProgress);
} // Nothing to do here. This is terminal. We'll do the completion step
// immediately after.
return null;
}
function mountLazyComponent(
_current,
workInProgress,
elementType,
updateLanes,
renderLanes,
) {
if (_current !== null) {
// A lazy component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate = null;
workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags |= Placement;
}
var props = workInProgress.pendingProps;
var lazyComponent = elementType;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
var Component = init(payload); // Store the unwrapped component in the type.
workInProgress.type = Component;
var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
var resolvedProps = resolveDefaultProps(Component, props);
var child;
switch (resolvedTag) {
case FunctionComponent: {
{
validateFunctionComponentInDev(workInProgress, Component);
workInProgress.type = Component =
resolveFunctionForHotReloading(Component);
}
child = updateFunctionComponent(
null,
workInProgress,
Component,
resolvedProps,
renderLanes,
);
return child;
}
case ClassComponent: {
{
workInProgress.type = Component =
resolveClassForHotReloading(Component);
}
child = updateClassComponent(
null,
workInProgress,
Component,
resolvedProps,
renderLanes,
);
return child;
}
case ForwardRef: {
{
workInProgress.type = Component =
resolveForwardRefForHotReloading(Component);
}
child = updateForwardRef(
null,
workInProgress,
Component,
resolvedProps,
renderLanes,
);
return child;
}
case MemoComponent: {
{
if (workInProgress.type !== workInProgress.elementType) {
var outerPropTypes = Component.propTypes;
if (outerPropTypes) {
checkPropTypes(
outerPropTypes,
resolvedProps, // Resolved for outer only
"prop",
getComponentName(Component),
);
}
}
}
child = updateMemoComponent(
null,
workInProgress,
Component,
resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
updateLanes,
renderLanes,
);
return child;
}
}
var hint = "";
{
if (
Component !== null &&
typeof Component === "object" &&
Component.$$typeof === REACT_LAZY_TYPE
) {
hint = " Did you wrap a component in React.lazy() more than once?";
}
} // This message intentionally doesn't mention ForwardRef or MemoComponent
// because the fact that it's a separate type of work is an
// implementation detail.
{
{
throw Error(
"Element type is invalid. Received a promise that resolves to: " +
Component +
". Lazy element type must resolve to a class or function." +
hint,
);
}
}
}
function mountIncompleteClassComponent(
_current,
workInProgress,
Component,
nextProps,
renderLanes,
) {
if (_current !== null) {
// An incomplete component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate = null;
workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags |= Placement;
} // Promote the fiber to a class and try rendering again.
workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
// Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
var hasContext;
if (isContextProvider(Component)) {
hasContext = true;
pushContextProvider(workInProgress);
} else {
hasContext = false;
}
prepareToReadContext(workInProgress, renderLanes);
constructClassInstance(workInProgress, Component, nextProps);
mountClassInstance(workInProgress, Component, nextProps, renderLanes);
return finishClassComponent(
null,
workInProgress,
Component,
true,
hasContext,
renderLanes,
);
}
function mountIndeterminateComponent(
_current,
workInProgress,
Component,
renderLanes,
) {
if (_current !== null) {
// An indeterminate component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate = null;
workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
workInProgress.flags |= Placement;
}
var props = workInProgress.pendingProps;
var context;
{
var unmaskedContext = getUnmaskedContext(
workInProgress,
Component,
false,
);
context = getMaskedContext(workInProgress, unmaskedContext);
}
prepareToReadContext(workInProgress, renderLanes);
var value;
{
if (
Component.prototype &&
typeof Component.prototype.render === "function"
) {
var componentName = getComponentName(Component) || "Unknown";
if (!didWarnAboutBadClass[componentName]) {
error(
"The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
"This is likely to cause errors. Change %s to extend React.Component instead.",
componentName,
componentName,
);
didWarnAboutBadClass[componentName] = true;
}
}
if (workInProgress.mode & StrictMode) {
ReactStrictModeWarnings.recordLegacyContextWarning(
workInProgress,
null,
);
}
setIsRendering(true);
ReactCurrentOwner$1.current = workInProgress;
value = renderWithHooks(
null,
workInProgress,
Component,
props,
context,
renderLanes,
);
setIsRendering(false);
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
{
// Support for module components is deprecated and is removed behind a flag.
// Whether or not it would crash later, we want to show a good message in DEV first.
if (
typeof value === "object" &&
value !== null &&
typeof value.render === "function" &&
value.$$typeof === undefined
) {
var _componentName = getComponentName(Component) || "Unknown";
if (!didWarnAboutModulePatternComponent[_componentName]) {
error(
"The <%s /> component appears to be a function component that returns a class instance. " +
"Change %s to a class that extends React.Component instead. " +
"If you can't use a class try assigning the prototype on the function as a workaround. " +
"`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
"cannot be called with `new` by React.",
_componentName,
_componentName,
_componentName,
);
didWarnAboutModulePatternComponent[_componentName] = true;
}
}
}
if (
// Run these checks in production only if the flag is off.
// Eventually we'll delete this branch altogether.
typeof value === "object" &&
value !== null &&
typeof value.render === "function" &&
value.$$typeof === undefined
) {
{
var _componentName2 = getComponentName(Component) || "Unknown";
if (!didWarnAboutModulePatternComponent[_componentName2]) {
error(
"The <%s /> component appears to be a function component that returns a class instance. " +
"Change %s to a class that extends React.Component instead. " +
"If you can't use a class try assigning the prototype on the function as a workaround. " +
"`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
"cannot be called with `new` by React.",
_componentName2,
_componentName2,
_componentName2,
);
didWarnAboutModulePatternComponent[_componentName2] = true;
}
} // Proceed under the assumption that this is a class instance
workInProgress.tag = ClassComponent; // Throw out any hooks that were used.
workInProgress.memoizedState = null;
workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
var hasContext = false;
if (isContextProvider(Component)) {
hasContext = true;
pushContextProvider(workInProgress);
} else {
hasContext = false;
}
workInProgress.memoizedState =
value.state !== null && value.state !== undefined ? value.state : null;
initializeUpdateQueue(workInProgress);
var getDerivedStateFromProps = Component.getDerivedStateFromProps;
if (typeof getDerivedStateFromProps === "function") {
applyDerivedStateFromProps(
workInProgress,
Component,
getDerivedStateFromProps,
props,
);
}
adoptClassInstance(workInProgress, value);
mountClassInstance(workInProgress, Component, props, renderLanes);
return finishClassComponent(
null,
workInProgress,
Component,
true,
hasContext,
renderLanes,
);
} else {
// Proceed under the assumption that this is a function component
workInProgress.tag = FunctionComponent;
{
if (workInProgress.mode & StrictMode) {
disableLogs();
try {
value = renderWithHooks(
null,
workInProgress,
Component,
props,
context,
renderLanes,
);
} finally {
reenableLogs();
}
}
}
reconcileChildren(null, workInProgress, value, renderLanes);
{
validateFunctionComponentInDev(workInProgress, Component);
}
return workInProgress.child;
}
}
function validateFunctionComponentInDev(workInProgress, Component) {
{
if (Component) {
if (Component.childContextTypes) {
error(
"%s(...): childContextTypes cannot be defined on a function component.",
Component.displayName || Component.name || "Component",
);
}
}
if (workInProgress.ref !== null) {
var info = "";
var ownerName = getCurrentFiberOwnerNameInDevOrNull();
if (ownerName) {
info += "\n\nCheck the render method of `" + ownerName + "`.";
}
var warningKey = ownerName || workInProgress._debugID || "";
var debugSource = workInProgress._debugSource;
if (debugSource) {
warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
}
if (!didWarnAboutFunctionRefs[warningKey]) {
didWarnAboutFunctionRefs[warningKey] = true;
error(
"Function components cannot be given refs. " +
"Attempts to access this ref will fail. " +
"Did you mean to use React.forwardRef()?%s",
info,
);
}
}
if (typeof Component.getDerivedStateFromProps === "function") {
var _componentName3 = getComponentName(Component) || "Unknown";
if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
error(
"%s: Function components do not support getDerivedStateFromProps.",
_componentName3,
);
didWarnAboutGetDerivedStateOnFunctionComponent[
_componentName3
] = true;
}
}
if (
typeof Component.contextType === "object" &&
Component.contextType !== null
) {
var _componentName4 = getComponentName(Component) || "Unknown";
if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
error(
"%s: Function components do not support contextType.",
_componentName4,
);
didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
}
}
}
}
var SUSPENDED_MARKER = {
dehydrated: null,
retryLane: NoLane,
};
function mountSuspenseOffscreenState(renderLanes) {
return {
baseLanes: renderLanes,
};
}
function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
return {
baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
};
} // TODO: Probably should inline this back
function shouldRemainOnFallback(
suspenseContext,
current,
workInProgress,
renderLanes,
) {
// If we're already showing a fallback, there are cases where we need to
// remain on that fallback regardless of whether the content has resolved.
// For example, SuspenseList coordinates when nested content appears.
if (current !== null) {
var suspenseState = current.memoizedState;
if (suspenseState === null) {
// Currently showing content. Don't hide it, even if ForceSuspenseFallack
// is true. More precise name might be "ForceRemainSuspenseFallback".
// Note: This is a factoring smell. Can't remain on a fallback if there's
// no fallback to remain on.
return false;
}
} // Not currently showing content. Consult the Suspense context.
return hasSuspenseContext(suspenseContext, ForceSuspenseFallback);
}
function getRemainingWorkInPrimaryTree(current, renderLanes) {
// TODO: Should not remove render lanes that were pinged during this render
return removeLanes(current.childLanes, renderLanes);
}
function updateSuspenseComponent(current, workInProgress, renderLanes) {
var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
{
if (shouldSuspend(workInProgress)) {
workInProgress.flags |= DidCapture;
}
}
var suspenseContext = suspenseStackCursor.current;
var showFallback = false;
var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags;
if (didSuspend || shouldRemainOnFallback(suspenseContext, current)) {
// Something in this boundary's subtree already suspended. Switch to
// rendering the fallback children.
showFallback = true;
workInProgress.flags &= ~DidCapture;
} else {
// Attempting the main content
if (current === null || current.memoizedState !== null) {
// This is a new mount or this boundary is already showing a fallback state.
// Mark this subtree context as having at least one invisible parent that could
// handle the fallback state.
// Boundaries without fallbacks or should be avoided are not considered since
// they cannot handle preferred fallback states.
if (
nextProps.fallback !== undefined &&
nextProps.unstable_avoidThisFallback !== true
) {
suspenseContext = addSubtreeSuspenseContext(
suspenseContext,
InvisibleParentSuspenseContext,
);
}
}
}
suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
pushSuspenseContext(workInProgress, suspenseContext); // OK, the next part is confusing. We're about to reconcile the Suspense
// boundary's children. This involves some custom reconcilation logic. Two
// main reasons this is so complicated.
//
// First, Legacy Mode has different semantics for backwards compatibility. The
// primary tree will commit in an inconsistent state, so when we do the
// second pass to render the fallback, we do some exceedingly, uh, clever
// hacks to make that not totally break. Like transferring effects and
// deletions from hidden tree. In Concurrent Mode, it's much simpler,
// because we bailout on the primary tree completely and leave it in its old
// state, no effects. Same as what we do for Offscreen (except that
// Offscreen doesn't have the first render pass).
//
// Second is hydration. During hydration, the Suspense fiber has a slightly
// different layout, where the child points to a dehydrated fragment, which
// contains the DOM rendered by the server.
//
// Third, even if you set all that aside, Suspense is like error boundaries in
// that we first we try to render one tree, and if that fails, we render again
// and switch to a different tree. Like a try/catch block. So we have to track
// which branch we're currently rendering. Ideally we would model this using
// a stack.
if (current === null) {
// Initial mount
// If we're currently hydrating, try to hydrate this boundary.
// But only if this has a fallback.
if (nextProps.fallback !== undefined) {
tryToClaimNextHydratableInstance(workInProgress); // This could've been a dehydrated suspense component.
}
var nextPrimaryChildren = nextProps.children;
var nextFallbackChildren = nextProps.fallback;
if (showFallback) {
var fallbackFragment = mountSuspenseFallbackChildren(
workInProgress,
nextPrimaryChildren,
nextFallbackChildren,
renderLanes,
);
var primaryChildFragment = workInProgress.child;
primaryChildFragment.memoizedState =
mountSuspenseOffscreenState(renderLanes);
workInProgress.memoizedState = SUSPENDED_MARKER;
return fallbackFragment;
} else if (typeof nextProps.unstable_expectedLoadTime === "number") {
// This is a CPU-bound tree. Skip this tree and show a placeholder to
// unblock the surrounding content. Then immediately retry after the
// initial commit.
var _fallbackFragment = mountSuspenseFallbackChildren(
workInProgress,
nextPrimaryChildren,
nextFallbackChildren,
renderLanes,
);
var _primaryChildFragment = workInProgress.child;
_primaryChildFragment.memoizedState =
mountSuspenseOffscreenState(renderLanes);
workInProgress.memoizedState = SUSPENDED_MARKER; // Since nothing actually suspended, there will nothing to ping this to
// get it started back up to attempt the next item. While in terms of
// priority this work has the same priority as this current render, it's
// not part of the same transition once the transition has committed. If
// it's sync, we still want to yield so that it can be painted.
// Conceptually, this is really the same as pinging. We can use any
// RetryLane even if it's the one currently rendering since we're leaving
// it behind on this node.
workInProgress.lanes = SomeRetryLane;
{
markSpawnedWork(SomeRetryLane);
}
return _fallbackFragment;
} else {
return mountSuspensePrimaryChildren(
workInProgress,
nextPrimaryChildren,
renderLanes,
);
}
} else {
// This is an update.
// If the current fiber has a SuspenseState, that means it's already showing
// a fallback.
var prevState = current.memoizedState;
if (prevState !== null) {
if (showFallback) {
var _nextFallbackChildren2 = nextProps.fallback;
var _nextPrimaryChildren2 = nextProps.children;
var _fallbackChildFragment = updateSuspenseFallbackChildren(
current,
workInProgress,
_nextPrimaryChildren2,
_nextFallbackChildren2,
renderLanes,
);
var _primaryChildFragment3 = workInProgress.child;
var prevOffscreenState = current.child.memoizedState;
_primaryChildFragment3.memoizedState =
prevOffscreenState === null
? mountSuspenseOffscreenState(renderLanes)
: updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
_primaryChildFragment3.childLanes = getRemainingWorkInPrimaryTree(
current,
renderLanes,
);
workInProgress.memoizedState = SUSPENDED_MARKER;
return _fallbackChildFragment;
} else {
var _nextPrimaryChildren3 = nextProps.children;
var _primaryChildFragment4 = updateSuspensePrimaryChildren(
current,
workInProgress,
_nextPrimaryChildren3,
renderLanes,
);
workInProgress.memoizedState = null;
return _primaryChildFragment4;
}
} else {
// The current tree is not already showing a fallback.
if (showFallback) {
// Timed out.
var _nextFallbackChildren3 = nextProps.fallback;
var _nextPrimaryChildren4 = nextProps.children;
var _fallbackChildFragment2 = updateSuspenseFallbackChildren(
current,
workInProgress,
_nextPrimaryChildren4,
_nextFallbackChildren3,
renderLanes,
);
var _primaryChildFragment5 = workInProgress.child;
var _prevOffscreenState = current.child.memoizedState;
_primaryChildFragment5.memoizedState =
_prevOffscreenState === null
? mountSuspenseOffscreenState(renderLanes)
: updateSuspenseOffscreenState(_prevOffscreenState, renderLanes);
_primaryChildFragment5.childLanes = getRemainingWorkInPrimaryTree(
current,
renderLanes,
); // Skip the primary children, and continue working on the
// fallback children.
workInProgress.memoizedState = SUSPENDED_MARKER;
return _fallbackChildFragment2;
} else {
// Still haven't timed out. Continue rendering the children, like we
// normally do.
var _nextPrimaryChildren5 = nextProps.children;
var _primaryChildFragment6 = updateSuspensePrimaryChildren(
current,
workInProgress,
_nextPrimaryChildren5,
renderLanes,
);
workInProgress.memoizedState = null;
return _primaryChildFragment6;
}
}
}
}
function mountSuspensePrimaryChildren(
workInProgress,
primaryChildren,
renderLanes,
) {
var mode = workInProgress.mode;
var primaryChildProps = {
mode: "visible",
children: primaryChildren,
};
var primaryChildFragment = createFiberFromOffscreen(
primaryChildProps,
mode,
renderLanes,
null,
);
primaryChildFragment.return = workInProgress;
workInProgress.child = primaryChildFragment;
return primaryChildFragment;
}
function mountSuspenseFallbackChildren(
workInProgress,
primaryChildren,
fallbackChildren,
renderLanes,
) {
var mode = workInProgress.mode;
var progressedPrimaryFragment = workInProgress.child;
var primaryChildProps = {
mode: "hidden",
children: primaryChildren,
};
var primaryChildFragment;
var fallbackChildFragment;
if (
(mode & BlockingMode) === NoMode &&
progressedPrimaryFragment !== null
) {
// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
primaryChildFragment = progressedPrimaryFragment;
primaryChildFragment.childLanes = NoLanes;
primaryChildFragment.pendingProps = primaryChildProps;
if (workInProgress.mode & ProfileMode) {
// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration = 0;
primaryChildFragment.actualStartTime = -1;
primaryChildFragment.selfBaseDuration = 0;
primaryChildFragment.treeBaseDuration = 0;
}
fallbackChildFragment = createFiberFromFragment(
fallbackChildren,
mode,
renderLanes,
null,
);
} else {
primaryChildFragment = createFiberFromOffscreen(
primaryChildProps,
mode,
NoLanes,
null,
);
fallbackChildFragment = createFiberFromFragment(
fallbackChildren,
mode,
renderLanes,
null,
);
}
primaryChildFragment.return = workInProgress;
fallbackChildFragment.return = workInProgress;
primaryChildFragment.sibling = fallbackChildFragment;
workInProgress.child = primaryChildFragment;
return fallbackChildFragment;
}
function createWorkInProgressOffscreenFiber(current, offscreenProps) {
// The props argument to `createWorkInProgress` is `any` typed, so we use this
// wrapper function to constrain it.
return createWorkInProgress(current, offscreenProps);
}
function updateSuspensePrimaryChildren(
current,
workInProgress,
primaryChildren,
renderLanes,
) {
var currentPrimaryChildFragment = current.child;
var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
var primaryChildFragment = createWorkInProgressOffscreenFiber(
currentPrimaryChildFragment,
{
mode: "visible",
children: primaryChildren,
},
);
if ((workInProgress.mode & BlockingMode) === NoMode) {
primaryChildFragment.lanes = renderLanes;
}
primaryChildFragment.return = workInProgress;
primaryChildFragment.sibling = null;
if (currentFallbackChildFragment !== null) {
// Delete the fallback child fragment
currentFallbackChildFragment.nextEffect = null;
currentFallbackChildFragment.flags = Deletion;
workInProgress.firstEffect = workInProgress.lastEffect =
currentFallbackChildFragment;
}
workInProgress.child = primaryChildFragment;
return primaryChildFragment;
}
function updateSuspenseFallbackChildren(
current,
workInProgress,
primaryChildren,
fallbackChildren,
renderLanes,
) {
var mode = workInProgress.mode;
var currentPrimaryChildFragment = current.child;
var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
var primaryChildProps = {
mode: "hidden",
children: primaryChildren,
};
var primaryChildFragment;
if (
// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
(mode & BlockingMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
// already cloned. In legacy mode, the only case where this isn't true is
// when DevTools forces us to display a fallback; we skip the first render
// pass entirely and go straight to rendering the fallback. (In Concurrent
// Mode, SuspenseList can also trigger this scenario, but this is a legacy-
// only codepath.)
workInProgress.child !== currentPrimaryChildFragment
) {
var progressedPrimaryFragment = workInProgress.child;
primaryChildFragment = progressedPrimaryFragment;
primaryChildFragment.childLanes = NoLanes;
primaryChildFragment.pendingProps = primaryChildProps;
if (workInProgress.mode & ProfileMode) {
// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration = 0;
primaryChildFragment.actualStartTime = -1;
primaryChildFragment.selfBaseDuration =
currentPrimaryChildFragment.selfBaseDuration;
primaryChildFragment.treeBaseDuration =
currentPrimaryChildFragment.treeBaseDuration;
} // The fallback fiber was added as a deletion effect during the first pass.
// However, since we're going to remain on the fallback, we no longer want
// to delete it. So we need to remove it from the list. Deletions are stored
// on the same list as effects. We want to keep the effects from the primary
// tree. So we copy the primary child fragment's effect list, which does not
// include the fallback deletion effect.
var progressedLastEffect = primaryChildFragment.lastEffect;
if (progressedLastEffect !== null) {
workInProgress.firstEffect = primaryChildFragment.firstEffect;
workInProgress.lastEffect = progressedLastEffect;
progressedLastEffect.nextEffect = null;
} else {
// TODO: Reset this somewhere else? Lol legacy mode is so weird.
workInProgress.firstEffect = workInProgress.lastEffect = null;
}
} else {
primaryChildFragment = createWorkInProgressOffscreenFiber(
currentPrimaryChildFragment,
primaryChildProps,
);
}
var fallbackChildFragment;
if (currentFallbackChildFragment !== null) {
fallbackChildFragment = createWorkInProgress(
currentFallbackChildFragment,
fallbackChildren,
);
} else {
fallbackChildFragment = createFiberFromFragment(
fallbackChildren,
mode,
renderLanes,
null,
); // Needs a placement effect because the parent (the Suspense boundary) already
// mounted but this is a new fiber.
fallbackChildFragment.flags |= Placement;
}
fallbackChildFragment.return = workInProgress;
primaryChildFragment.return = workInProgress;
primaryChildFragment.sibling = fallbackChildFragment;
workInProgress.child = primaryChildFragment;
return fallbackChildFragment;
}
function scheduleWorkOnFiber(fiber, renderLanes) {
fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
var alternate = fiber.alternate;
if (alternate !== null) {
alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
}
scheduleWorkOnParentPath(fiber.return, renderLanes);
}
function propagateSuspenseContextChange(
workInProgress,
firstChild,
renderLanes,
) {
// Mark any Suspense boundaries with fallbacks as having work to do.
// If they were previously forced into fallbacks, they may now be able
// to unblock.
var node = firstChild;
while (node !== null) {
if (node.tag === SuspenseComponent) {
var state = node.memoizedState;
if (state !== null) {
scheduleWorkOnFiber(node, renderLanes);
}
} else if (node.tag === SuspenseListComponent) {
// If the tail is hidden there might not be an Suspense boundaries
// to schedule work on. In this case we have to schedule it on the
// list itself.
// We don't have to traverse to the children of the list since
// the list will propagate the change when it rerenders.
scheduleWorkOnFiber(node, renderLanes);
} else if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
if (node === workInProgress) {
return;
}
while (node.sibling === null) {
if (node.return === null || node.return === workInProgress) {
return;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
}
function findLastContentRow(firstChild) {
// This is going to find the last row among these children that is already
// showing content on the screen, as opposed to being in fallback state or
// new. If a row has multiple Suspense boundaries, any of them being in the
// fallback state, counts as the whole row being in a fallback state.
// Note that the "rows" will be workInProgress, but any nested children
// will still be current since we haven't rendered them yet. The mounted
// order may not be the same as the new order. We use the new order.
var row = firstChild;
var lastContentRow = null;
while (row !== null) {
var currentRow = row.alternate; // New rows can't be content rows.
if (currentRow !== null && findFirstSuspended(currentRow) === null) {
lastContentRow = row;
}
row = row.sibling;
}
return lastContentRow;
}
function validateRevealOrder(revealOrder) {
{
if (
revealOrder !== undefined &&
revealOrder !== "forwards" &&
revealOrder !== "backwards" &&
revealOrder !== "together" &&
!didWarnAboutRevealOrder[revealOrder]
) {
didWarnAboutRevealOrder[revealOrder] = true;
if (typeof revealOrder === "string") {
switch (revealOrder.toLowerCase()) {
case "together":
case "forwards":
case "backwards": {
error(
'"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
'Use lowercase "%s" instead.',
revealOrder,
revealOrder.toLowerCase(),
);
break;
}
case "forward":
case "backward": {
error(
'"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
'React uses the -s suffix in the spelling. Use "%ss" instead.',
revealOrder,
revealOrder.toLowerCase(),
);
break;
}
default:
error(
'"%s" is not a supported revealOrder on <SuspenseList />. ' +
'Did you mean "together", "forwards" or "backwards"?',
revealOrder,
);
break;
}
} else {
error(
"%s is not a supported value for revealOrder on <SuspenseList />. " +
'Did you mean "together", "forwards" or "backwards"?',
revealOrder,
);
}
}
}
}
function validateTailOptions(tailMode, revealOrder) {
{
if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
if (tailMode !== "collapsed" && tailMode !== "hidden") {
didWarnAboutTailOptions[tailMode] = true;
error(
'"%s" is not a supported value for tail on <SuspenseList />. ' +
'Did you mean "collapsed" or "hidden"?',
tailMode,
);
} else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
didWarnAboutTailOptions[tailMode] = true;
error(
'<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
'"forwards" or "backwards". ' +
'Did you mean to specify revealOrder="forwards"?',
tailMode,
);
}
}
}
}
function validateSuspenseListNestedChild(childSlot, index) {
{
var isArray = Array.isArray(childSlot);
var isIterable =
!isArray && typeof getIteratorFn(childSlot) === "function";
if (isArray || isIterable) {
var type = isArray ? "array" : "iterable";
error(
"A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
"an additional SuspenseList to configure its revealOrder: " +
"<SuspenseList revealOrder=...> ... " +
"<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
"</SuspenseList>",
type,
index,
type,
);
return false;
}
}
return true;
}
function validateSuspenseListChildren(children, revealOrder) {
{
if (
(revealOrder === "forwards" || revealOrder === "backwards") &&
children !== undefined &&
children !== null &&
children !== false
) {
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
if (!validateSuspenseListNestedChild(children[i], i)) {
return;
}
}
} else {
var iteratorFn = getIteratorFn(children);
if (typeof iteratorFn === "function") {
var childrenIterator = iteratorFn.call(children);
if (childrenIterator) {
var step = childrenIterator.next();
var _i = 0;
for (; !step.done; step = childrenIterator.next()) {
if (!validateSuspenseListNestedChild(step.value, _i)) {
return;
}
_i++;
}
}
} else {
error(
'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
"This is not useful since it needs multiple rows. " +
"Did you mean to pass multiple children or an array?",
revealOrder,
);
}
}
}
}
}
function initSuspenseListRenderState(
workInProgress,
isBackwards,
tail,
lastContentRow,
tailMode,
lastEffectBeforeRendering,
) {
var renderState = workInProgress.memoizedState;
if (renderState === null) {
workInProgress.memoizedState = {
isBackwards: isBackwards,
rendering: null,
renderingStartTime: 0,
last: lastContentRow,
tail: tail,
tailMode: tailMode,
lastEffect: lastEffectBeforeRendering,
};
} else {
// We can reuse the existing object from previous renders.
renderState.isBackwards = isBackwards;
renderState.rendering = null;
renderState.renderingStartTime = 0;
renderState.last = lastContentRow;
renderState.tail = tail;
renderState.tailMode = tailMode;
renderState.lastEffect = lastEffectBeforeRendering;
}
} // This can end up rendering this component multiple passes.
// The first pass splits the children fibers into two sets. A head and tail.
// We first render the head. If anything is in fallback state, we do another
// pass through beginWork to rerender all children (including the tail) with
// the force suspend context. If the first render didn't have anything in
// in fallback state. Then we render each row in the tail one-by-one.
// That happens in the completeWork phase without going back to beginWork.
function updateSuspenseListComponent(current, workInProgress, renderLanes) {
var nextProps = workInProgress.pendingProps;
var revealOrder = nextProps.revealOrder;
var tailMode = nextProps.tail;
var newChildren = nextProps.children;
validateRevealOrder(revealOrder);
validateTailOptions(tailMode, revealOrder);
validateSuspenseListChildren(newChildren, revealOrder);
reconcileChildren(current, workInProgress, newChildren, renderLanes);
var suspenseContext = suspenseStackCursor.current;
var shouldForceFallback = hasSuspenseContext(
suspenseContext,
ForceSuspenseFallback,
);
if (shouldForceFallback) {
suspenseContext = setShallowSuspenseContext(
suspenseContext,
ForceSuspenseFallback,
);
workInProgress.flags |= DidCapture;
} else {
var didSuspendBefore =
current !== null && (current.flags & DidCapture) !== NoFlags;
if (didSuspendBefore) {
// If we previously forced a fallback, we need to schedule work
// on any nested boundaries to let them know to try to render
// again. This is the same as context updating.
propagateSuspenseContextChange(
workInProgress,
workInProgress.child,
renderLanes,
);
}
suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
}
pushSuspenseContext(workInProgress, suspenseContext);
if ((workInProgress.mode & BlockingMode) === NoMode) {
// In legacy mode, SuspenseList doesn't work so we just
// use make it a noop by treating it as the default revealOrder.
workInProgress.memoizedState = null;
} else {
switch (revealOrder) {
case "forwards": {
var lastContentRow = findLastContentRow(workInProgress.child);
var tail;
if (lastContentRow === null) {
// The whole list is part of the tail.
// TODO: We could fast path by just rendering the tail now.
tail = workInProgress.child;
workInProgress.child = null;
} else {
// Disconnect the tail rows after the content row.
// We're going to render them separately later.
tail = lastContentRow.sibling;
lastContentRow.sibling = null;
}
initSuspenseListRenderState(
workInProgress,
false, // isBackwards
tail,
lastContentRow,
tailMode,
workInProgress.lastEffect,
);
break;
}
case "backwards": {
// We're going to find the first row that has existing content.
// At the same time we're going to reverse the list of everything
// we pass in the meantime. That's going to be our tail in reverse
// order.
var _tail = null;
var row = workInProgress.child;
workInProgress.child = null;
while (row !== null) {
var currentRow = row.alternate; // New rows can't be content rows.
if (
currentRow !== null &&
findFirstSuspended(currentRow) === null
) {
// This is the beginning of the main content.
workInProgress.child = row;
break;
}
var nextRow = row.sibling;
row.sibling = _tail;
_tail = row;
row = nextRow;
} // TODO: If workInProgress.child is null, we can continue on the tail immediately.
initSuspenseListRenderState(
workInProgress,
true, // isBackwards
_tail,
null, // last
tailMode,
workInProgress.lastEffect,
);
break;
}
case "together": {
initSuspenseListRenderState(
workInProgress,
false, // isBackwards
null, // tail
null, // last
undefined,
workInProgress.lastEffect,
);
break;
}
default: {
// The default reveal order is the same as not having
// a boundary.
workInProgress.memoizedState = null;
}
}
}
return workInProgress.child;
}
function updatePortalComponent(current, workInProgress, renderLanes) {
pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
var nextChildren = workInProgress.pendingProps;
if (current === null) {
// Portals are special because we don't append the children during mount
// but at commit. Therefore we need to track insertions which the normal
// flow doesn't do during mount. This doesn't happen at the root because
// the root always starts with a "current" with a null child.
// TODO: Consider unifying this with how the root works.
workInProgress.child = reconcileChildFibers(
workInProgress,
null,
nextChildren,
renderLanes,
);
} else {
reconcileChildren(current, workInProgress, nextChildren, renderLanes);
}
return workInProgress.child;
}
var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
function updateContextProvider(current, workInProgress, renderLanes) {
var providerType = workInProgress.type;
var context = providerType._context;
var newProps = workInProgress.pendingProps;
var oldProps = workInProgress.memoizedProps;
var newValue = newProps.value;
{
if (!("value" in newProps)) {
if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
hasWarnedAboutUsingNoValuePropOnContextProvider = true;
error(
"The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?",
);
}
}
var providerPropTypes = workInProgress.type.propTypes;
if (providerPropTypes) {
checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
}
}
pushProvider(workInProgress, newValue);
if (oldProps !== null) {
var oldValue = oldProps.value;
var changedBits = calculateChangedBits(context, newValue, oldValue);
if (changedBits === 0) {
// No change. Bailout early if children are the same.
if (oldProps.children === newProps.children && !hasContextChanged()) {
return bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
}
} else {
// The context value changed. Search for matching consumers and schedule
// them to update.
propagateContextChange(
workInProgress,
context,
changedBits,
renderLanes,
);
}
}
var newChildren = newProps.children;
reconcileChildren(current, workInProgress, newChildren, renderLanes);
return workInProgress.child;
}
var hasWarnedAboutUsingContextAsConsumer = false;
function updateContextConsumer(current, workInProgress, renderLanes) {
var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
// DEV mode, we create a separate object for Context.Consumer that acts
// like a proxy to Context. This proxy object adds unnecessary code in PROD
// so we use the old behaviour (Context.Consumer references Context) to
// reduce size and overhead. The separate object references context via
// a property called "_context", which also gives us the ability to check
// in DEV mode if this property exists or not and warn if it does not.
{
if (context._context === undefined) {
// This may be because it's a Context (rather than a Consumer).
// Or it may be because it's older React where they're the same thing.
// We only want to warn if we're sure it's a new React.
if (context !== context.Consumer) {
if (!hasWarnedAboutUsingContextAsConsumer) {
hasWarnedAboutUsingContextAsConsumer = true;
error(
"Rendering <Context> directly is not supported and will be removed in " +
"a future major release. Did you mean to render <Context.Consumer> instead?",
);
}
}
} else {
context = context._context;
}
}
var newProps = workInProgress.pendingProps;
var render = newProps.children;
{
if (typeof render !== "function") {
error(
"A context consumer was rendered with multiple children, or a child " +
"that isn't a function. A context consumer expects a single child " +
"that is a function. If you did pass a function, make sure there " +
"is no trailing or leading whitespace around it.",
);
}
}
prepareToReadContext(workInProgress, renderLanes);
var newValue = readContext(context, newProps.unstable_observedBits);
var newChildren;
{
ReactCurrentOwner$1.current = workInProgress;
setIsRendering(true);
newChildren = render(newValue);
setIsRendering(false);
} // React DevTools reads this flag.
workInProgress.flags |= PerformedWork;
reconcileChildren(current, workInProgress, newChildren, renderLanes);
return workInProgress.child;
}
function markWorkInProgressReceivedUpdate() {
didReceiveUpdate = true;
}
function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
if (current !== null) {
// Reuse previous dependencies
workInProgress.dependencies = current.dependencies;
}
{
// Don't update "base" render times for bailouts.
stopProfilerTimerIfRunning();
}
markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
// The children don't have any work either. We can skip them.
// TODO: Once we add back resuming, we should check if the children are
// a work-in-progress set. If so, we need to transfer their effects.
return null;
} else {
// This fiber doesn't have work, but its subtree does. Clone the child
// fibers and continue.
cloneChildFibers(current, workInProgress);
return workInProgress.child;
}
}
function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
{
var returnFiber = oldWorkInProgress.return;
if (returnFiber === null) {
throw new Error("Cannot swap the root fiber.");
} // Disconnect from the old current.
// It will get deleted.
current.alternate = null;
oldWorkInProgress.alternate = null; // Connect to the new tree.
newWorkInProgress.index = oldWorkInProgress.index;
newWorkInProgress.sibling = oldWorkInProgress.sibling;
newWorkInProgress.return = oldWorkInProgress.return;
newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
if (oldWorkInProgress === returnFiber.child) {
returnFiber.child = newWorkInProgress;
} else {
var prevSibling = returnFiber.child;
if (prevSibling === null) {
throw new Error("Expected parent to have a child.");
}
while (prevSibling.sibling !== oldWorkInProgress) {
prevSibling = prevSibling.sibling;
if (prevSibling === null) {
throw new Error("Expected to find the previous sibling.");
}
}
prevSibling.sibling = newWorkInProgress;
} // Delete the old fiber and place the new one.
// Since the old fiber is disconnected, we have to schedule it manually.
var last = returnFiber.lastEffect;
if (last !== null) {
last.nextEffect = current;
returnFiber.lastEffect = current;
} else {
returnFiber.firstEffect = returnFiber.lastEffect = current;
}
current.nextEffect = null;
current.flags = Deletion;
newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
return newWorkInProgress;
}
}
function beginWork(current, workInProgress, renderLanes) {
var updateLanes = workInProgress.lanes;
{
if (workInProgress._debugNeedsRemount && current !== null) {
// This will restart the begin phase with a new fiber.
return remountFiber(
current,
workInProgress,
createFiberFromTypeAndProps(
workInProgress.type,
workInProgress.key,
workInProgress.pendingProps,
workInProgress._debugOwner || null,
workInProgress.mode,
workInProgress.lanes,
),
);
}
}
if (current !== null) {
var oldProps = current.memoizedProps;
var newProps = workInProgress.pendingProps;
if (
oldProps !== newProps ||
hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
workInProgress.type !== current.type
) {
// If props or context changed, mark the fiber as having performed work.
// This may be unset if the props are determined to be equal later (memo).
didReceiveUpdate = true;
} else if (!includesSomeLane(renderLanes, updateLanes)) {
didReceiveUpdate = false; // This fiber does not have any pending work. Bailout without entering
// the begin phase. There's still some bookkeeping we that needs to be done
// in this optimized path, mostly pushing stuff onto the stack.
switch (workInProgress.tag) {
case HostRoot:
pushHostRootContext(workInProgress);
resetHydrationState();
break;
case HostComponent:
pushHostContext(workInProgress);
break;
case ClassComponent: {
var Component = workInProgress.type;
if (isContextProvider(Component)) {
pushContextProvider(workInProgress);
}
break;
}
case HostPortal:
pushHostContainer(
workInProgress,
workInProgress.stateNode.containerInfo,
);
break;
case ContextProvider: {
var newValue = workInProgress.memoizedProps.value;
pushProvider(workInProgress, newValue);
break;
}
case Profiler:
{
// Profiler should only call onRender when one of its descendants actually rendered.
var hasChildWork = includesSomeLane(
renderLanes,
workInProgress.childLanes,
);
if (hasChildWork) {
workInProgress.flags |= Update;
} // Reset effect durations for the next eventual effect phase.
// These are reset during render to allow the DevTools commit hook a chance to read them,
var stateNode = workInProgress.stateNode;
stateNode.effectDuration = 0;
stateNode.passiveEffectDuration = 0;
}
break;
case SuspenseComponent: {
var state = workInProgress.memoizedState;
if (state !== null) {
// whether to retry the primary children, or to skip over it and
// go straight to the fallback. Check the priority of the primary
// child fragment.
var primaryChildFragment = workInProgress.child;
var primaryChildLanes = primaryChildFragment.childLanes;
if (includesSomeLane(renderLanes, primaryChildLanes)) {
// The primary children have pending work. Use the normal path
// to attempt to render the primary children again.
return updateSuspenseComponent(
current,
workInProgress,
renderLanes,
);
} else {
// The primary child fragment does not have pending work marked
// on it
pushSuspenseContext(
workInProgress,
setDefaultShallowSuspenseContext(suspenseStackCursor.current),
); // The primary children do not have pending work with sufficient
// priority. Bailout.
var child = bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
if (child !== null) {
// The fallback children have pending work. Skip over the
// primary children and work on the fallback.
return child.sibling;
} else {
return null;
}
}
} else {
pushSuspenseContext(
workInProgress,
setDefaultShallowSuspenseContext(suspenseStackCursor.current),
);
}
break;
}
case SuspenseListComponent: {
var didSuspendBefore = (current.flags & DidCapture) !== NoFlags;
var _hasChildWork = includesSomeLane(
renderLanes,
workInProgress.childLanes,
);
if (didSuspendBefore) {
if (_hasChildWork) {
// If something was in fallback state last time, and we have all the
// same children then we're still in progressive loading state.
// Something might get unblocked by state updates or retries in the
// tree which will affect the tail. So we need to use the normal
// path to compute the correct tail.
return updateSuspenseListComponent(
current,
workInProgress,
renderLanes,
);
} // If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
workInProgress.flags |= DidCapture;
} // If nothing suspended before and we're rendering the same children,
// then the tail doesn't matter. Anything new that suspends will work
// in the "together" mode, so we can continue from the state we had.
var renderState = workInProgress.memoizedState;
if (renderState !== null) {
// Reset to the "together" mode in case we've started a different
// update in the past but didn't complete it.
renderState.rendering = null;
renderState.tail = null;
renderState.lastEffect = null;
}
pushSuspenseContext(workInProgress, suspenseStackCursor.current);
if (_hasChildWork) {
break;
} else {
// If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
return null;
}
}
case OffscreenComponent:
case LegacyHiddenComponent: {
// Need to check if the tree still needs to be deferred. This is
// almost identical to the logic used in the normal update path,
// so we'll just enter that. The only difference is we'll bail out
// at the next level instead of this one, because the child props
// have not changed. Which is fine.
// TODO: Probably should refactor `beginWork` to split the bailout
// path from the normal path. I'm tempted to do a labeled break here
// but I won't :)
workInProgress.lanes = NoLanes;
return updateOffscreenComponent(
current,
workInProgress,
renderLanes,
);
}
}
return bailoutOnAlreadyFinishedWork(
current,
workInProgress,
renderLanes,
);
} else {
if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags) {
// This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
didReceiveUpdate = true;
} else {
// An update was scheduled on this fiber, but there are no new props
// nor legacy context. Set this to false. If an update queue or context
// consumer produces a changed value, it will set this to true. Otherwise,
// the component will assume the children have not changed and bail out.
didReceiveUpdate = false;
}
}
} else {
didReceiveUpdate = false;
} // Before entering the begin phase, clear pending update priority.
// TODO: This assumes that we're about to evaluate the component and process
// the update queue. However, there's an exception: SimpleMemoComponent
// sometimes bails out later in the begin phase. This indicates that we should
// move this assignment out of the common path and into each branch.
workInProgress.lanes = NoLanes;
switch (workInProgress.tag) {
case IndeterminateComponent: {
return mountIndeterminateComponent(
current,
workInProgress,
workInProgress.type,
renderLanes,
);
}
case LazyComponent: {
var elementType = workInProgress.elementType;
return mountLazyComponent(
current,
workInProgress,
elementType,
updateLanes,
renderLanes,
);
}
case FunctionComponent: {
var _Component = workInProgress.type;
var unresolvedProps = workInProgress.pendingProps;
var resolvedProps =
workInProgress.elementType === _Component
? unresolvedProps
: resolveDefaultProps(_Component, unresolvedProps);
return updateFunctionComponent(
current,
workInProgress,
_Component,
resolvedProps,
renderLanes,
);
}
case ClassComponent: {
var _Component2 = workInProgress.type;
var _unresolvedProps = workInProgress.pendingProps;
var _resolvedProps =
workInProgress.elementType === _Component2
? _unresolvedProps
: resolveDefaultProps(_Component2, _unresolvedProps);
return updateClassComponent(
current,
workInProgress,
_Component2,
_resolvedProps,
renderLanes,
);
}
case HostRoot:
return updateHostRoot(current, workInProgress, renderLanes);
case HostComponent:
return updateHostComponent(current, workInProgress, renderLanes);
case HostText:
return updateHostText(current, workInProgress);
case SuspenseComponent:
return updateSuspenseComponent(current, workInProgress, renderLanes);
case HostPortal:
return updatePortalComponent(current, workInProgress, renderLanes);
case ForwardRef: {
var type = workInProgress.type;
var _unresolvedProps2 = workInProgress.pendingProps;
var _resolvedProps2 =
workInProgress.elementType === type
? _unresolvedProps2
: resolveDefaultProps(type, _unresolvedProps2);
return updateForwardRef(
current,
workInProgress,
type,
_resolvedProps2,
renderLanes,
);
}
case Fragment:
return updateFragment(current, workInProgress, renderLanes);
case Mode:
return updateMode(current, workInProgress, renderLanes);
case Profiler:
return updateProfiler(current, workInProgress, renderLanes);
case ContextProvider:
return updateContextProvider(current, workInProgress, renderLanes);
case ContextConsumer:
return updateContextConsumer(current, workInProgress, renderLanes);
case MemoComponent: {
var _type2 = workInProgress.type;
var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
{
if (workInProgress.type !== workInProgress.elementType) {
var outerPropTypes = _type2.propTypes;
if (outerPropTypes) {
checkPropTypes(
outerPropTypes,
_resolvedProps3, // Resolved for outer only
"prop",
getComponentName(_type2),
);
}
}
}
_resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
return updateMemoComponent(
current,
workInProgress,
_type2,
_resolvedProps3,
updateLanes,
renderLanes,
);
}
case SimpleMemoComponent: {
return updateSimpleMemoComponent(
current,
workInProgress,
workInProgress.type,
workInProgress.pendingProps,
updateLanes,
renderLanes,
);
}
case IncompleteClassComponent: {
var _Component3 = workInProgress.type;
var _unresolvedProps4 = workInProgress.pendingProps;
var _resolvedProps4 =
workInProgress.elementType === _Component3
? _unresolvedProps4
: resolveDefaultProps(_Component3, _unresolvedProps4);
return mountIncompleteClassComponent(
current,
workInProgress,
_Component3,
_resolvedProps4,
renderLanes,
);
}
case SuspenseListComponent: {
return updateSuspenseListComponent(
current,
workInProgress,
renderLanes,
);
}
case FundamentalComponent: {
break;
}
case ScopeComponent: {
break;
}
case Block: {
break;
}
case OffscreenComponent: {
return updateOffscreenComponent(current, workInProgress, renderLanes);
}
case LegacyHiddenComponent: {
return updateLegacyHiddenComponent(
current,
workInProgress,
renderLanes,
);
}
}
{
{
throw Error(
"Unknown unit of work tag (" +
workInProgress.tag +
"). This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function markUpdate(workInProgress) {
// Tag the fiber with an update effect. This turns a Placement into
// a PlacementAndUpdate.
workInProgress.flags |= Update;
}
function markRef$1(workInProgress) {
workInProgress.flags |= Ref;
}
var appendAllChildren;
var updateHostContainer;
var updateHostComponent$1;
var updateHostText$1;
{
// Mutation mode
appendAllChildren = function (
parent,
workInProgress,
needsVisibilityToggle,
isHidden,
) {
// We only have the top Fiber that was created but we need recurse down its
// children to find all the terminal nodes.
var node = workInProgress.child;
while (node !== null) {
if (node.tag === HostComponent || node.tag === HostText) {
appendInitialChild(parent, node.stateNode);
} else if (node.tag === HostPortal);
else if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
if (node === workInProgress) {
return;
}
while (node.sibling === null) {
if (node.return === null || node.return === workInProgress) {
return;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
};
updateHostContainer = function (workInProgress) {
// Noop
};
updateHostComponent$1 = function (
current,
workInProgress,
type,
newProps,
rootContainerInstance,
) {
// If we have an alternate, that means this is an update and we need to
// schedule a side-effect to do the updates.
var oldProps = current.memoizedProps;
if (oldProps === newProps) {
// In mutation mode, this is sufficient for a bailout because
// we won't touch this node even if children changed.
return;
} // If we get updated because one of our children updated, we don't
// have newProps so we'll have to reuse them.
// TODO: Split the update API as separate for the props vs. children.
// Even better would be if children weren't special cased at all tho.
var instance = workInProgress.stateNode;
var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
// component is hitting the resume path. Figure out why. Possibly
// related to `hidden`.
var updatePayload = prepareUpdate(
instance,
type,
oldProps,
newProps,
rootContainerInstance,
currentHostContext,
); // TODO: Type this specific to this type of component.
workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
// is a new ref we mark this as an update. All the work is done in commitWork.
if (updatePayload) {
markUpdate(workInProgress);
}
};
updateHostText$1 = function (current, workInProgress, oldText, newText) {
// If the text differs, mark it as an update. All the work in done in commitWork.
if (oldText !== newText) {
markUpdate(workInProgress);
}
};
}
function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
if (getIsHydrating()) {
// If we're hydrating, we should consume as many items as we can
// so we don't leave any behind.
return;
}
switch (renderState.tailMode) {
case "hidden": {
// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
var tailNode = renderState.tail;
var lastTailNode = null;
while (tailNode !== null) {
if (tailNode.alternate !== null) {
lastTailNode = tailNode;
}
tailNode = tailNode.sibling;
} // Next we're simply going to delete all insertions after the
// last rendered item.
if (lastTailNode === null) {
// All remaining items in the tail are insertions.
renderState.tail = null;
} else {
// Detach the insertion after the last node that was already
// inserted.
lastTailNode.sibling = null;
}
break;
}
case "collapsed": {
// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
var _tailNode = renderState.tail;
var _lastTailNode = null;
while (_tailNode !== null) {
if (_tailNode.alternate !== null) {
_lastTailNode = _tailNode;
}
_tailNode = _tailNode.sibling;
} // Next we're simply going to delete all insertions after the
// last rendered item.
if (_lastTailNode === null) {
// All remaining items in the tail are insertions.
if (!hasRenderedATailFallback && renderState.tail !== null) {
// We suspended during the head. We want to show at least one
// row at the tail. So we'll keep on and cut off the rest.
renderState.tail.sibling = null;
} else {
renderState.tail = null;
}
} else {
// Detach the insertion after the last node that was already
// inserted.
_lastTailNode.sibling = null;
}
break;
}
}
}
function completeWork(current, workInProgress, renderLanes) {
var newProps = workInProgress.pendingProps;
switch (workInProgress.tag) {
case IndeterminateComponent:
case LazyComponent:
case SimpleMemoComponent:
case FunctionComponent:
case ForwardRef:
case Fragment:
case Mode:
case Profiler:
case ContextConsumer:
case MemoComponent:
return null;
case ClassComponent: {
var Component = workInProgress.type;
if (isContextProvider(Component)) {
popContext(workInProgress);
}
return null;
}
case HostRoot: {
popHostContainer(workInProgress);
popTopLevelContextObject(workInProgress);
resetWorkInProgressVersions();
var fiberRoot = workInProgress.stateNode;
if (fiberRoot.pendingContext) {
fiberRoot.context = fiberRoot.pendingContext;
fiberRoot.pendingContext = null;
}
if (current === null || current.child === null) {
// If we hydrated, pop so that we can delete any remaining children
// that weren't hydrated.
var wasHydrated = popHydrationState(workInProgress);
if (wasHydrated) {
// If we hydrated, then we'll need to schedule an update for
// the commit side-effects on the root.
markUpdate(workInProgress);
} else if (!fiberRoot.hydrate) {
// Schedule an effect to clear this container at the start of the next commit.
// This handles the case of React rendering into a container with previous children.
// It's also safe to do for updates too, because current.child would only be null
// if the previous render was null (so the the container would already be empty).
workInProgress.flags |= Snapshot;
}
}
updateHostContainer(workInProgress);
return null;
}
case HostComponent: {
popHostContext(workInProgress);
var rootContainerInstance = getRootHostContainer();
var type = workInProgress.type;
if (current !== null && workInProgress.stateNode != null) {
updateHostComponent$1(
current,
workInProgress,
type,
newProps,
rootContainerInstance,
);
if (current.ref !== workInProgress.ref) {
markRef$1(workInProgress);
}
} else {
if (!newProps) {
if (!(workInProgress.stateNode !== null)) {
{
throw Error(
"We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.",
);
}
} // This can happen when we abort work.
return null;
}
var currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
// "stack" as the parent. Then append children as we go in beginWork
// or completeWork depending on whether we want to add them top->down or
// bottom->up. Top->down is faster in IE11.
var _wasHydrated = popHydrationState(workInProgress);
if (_wasHydrated) {
// TODO: Move this and createInstance step into the beginPhase
// to consolidate.
if (
prepareToHydrateHostInstance(
workInProgress,
rootContainerInstance,
currentHostContext,
)
) {
// If changes to the hydrated node need to be applied at the
// commit-phase we mark this as such.
markUpdate(workInProgress);
}
} else {
var instance = createInstance(
type,
newProps,
rootContainerInstance,
currentHostContext,
workInProgress,
);
appendAllChildren(instance, workInProgress, false, false);
workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
// (eg DOM renderer supports auto-focus for certain elements).
// Make sure such renderers get scheduled for later work.
if (
finalizeInitialChildren(
instance,
type,
newProps,
rootContainerInstance,
)
) {
markUpdate(workInProgress);
}
}
if (workInProgress.ref !== null) {
// If there is a ref on a host node we need to schedule a callback
markRef$1(workInProgress);
}
}
return null;
}
case HostText: {
var newText = newProps;
if (current && workInProgress.stateNode != null) {
var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
// to schedule a side-effect to do the updates.
updateHostText$1(current, workInProgress, oldText, newText);
} else {
if (typeof newText !== "string") {
if (!(workInProgress.stateNode !== null)) {
{
throw Error(
"We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.",
);
}
} // This can happen when we abort work.
}
var _rootContainerInstance = getRootHostContainer();
var _currentHostContext = getHostContext();
var _wasHydrated2 = popHydrationState(workInProgress);
if (_wasHydrated2) {
if (prepareToHydrateHostTextInstance(workInProgress)) {
markUpdate(workInProgress);
}
} else {
workInProgress.stateNode = createTextInstance(
newText,
_rootContainerInstance,
_currentHostContext,
workInProgress,
);
}
}
return null;
}
case SuspenseComponent: {
popSuspenseContext(workInProgress);
var nextState = workInProgress.memoizedState;
if ((workInProgress.flags & DidCapture) !== NoFlags) {
// Something suspended. Re-render with the fallback children.
workInProgress.lanes = renderLanes; // Do not reset the effect list.
if ((workInProgress.mode & ProfileMode) !== NoMode) {
transferActualDuration(workInProgress);
}
return workInProgress;
}
var nextDidTimeout = nextState !== null;
var prevDidTimeout = false;
if (current === null) {
if (workInProgress.memoizedProps.fallback !== undefined) {
popHydrationState(workInProgress);
}
} else {
var prevState = current.memoizedState;
prevDidTimeout = prevState !== null;
}
if (nextDidTimeout && !prevDidTimeout) {
// If this subtreee is running in blocking mode we can suspend,
// otherwise we won't suspend.
// TODO: This will still suspend a synchronous tree if anything
// in the concurrent tree already suspended during this render.
// This is a known bug.
if ((workInProgress.mode & BlockingMode) !== NoMode) {
// TODO: Move this back to throwException because this is too late
// if this is a large tree which is common for initial loads. We
// don't know if we should restart a render or not until we get
// this marker, and this is too late.
// If this render already had a ping or lower pri updates,
// and this is the first time we know we're going to suspend we
// should be able to immediately restart from within throwException.
var hasInvisibleChildContext =
current === null &&
workInProgress.memoizedProps.unstable_avoidThisFallback !== true;
if (
hasInvisibleChildContext ||
hasSuspenseContext(
suspenseStackCursor.current,
InvisibleParentSuspenseContext,
)
) {
// If this was in an invisible tree or a new render, then showing
// this boundary is ok.
renderDidSuspend();
} else {
// Otherwise, we're going to have to hide content so we should
// suspend for longer if possible.
renderDidSuspendDelayIfPossible();
}
}
}
{
// TODO: Only schedule updates if these values are non equal, i.e. it changed.
if (nextDidTimeout || prevDidTimeout) {
// If this boundary just timed out, schedule an effect to attach a
// retry listener to the promise. This flag is also used to hide the
// primary children. In mutation mode, we also need the flag to
// *unhide* children that were previously hidden, so check if this
// is currently timed out, too.
workInProgress.flags |= Update;
}
}
return null;
}
case HostPortal:
popHostContainer(workInProgress);
updateHostContainer(workInProgress);
if (current === null) {
preparePortalMount(workInProgress.stateNode.containerInfo);
}
return null;
case ContextProvider:
// Pop provider fiber
popProvider(workInProgress);
return null;
case IncompleteClassComponent: {
// Same as class component case. I put it down here so that the tags are
// sequential to ensure this switch is compiled to a jump table.
var _Component = workInProgress.type;
if (isContextProvider(_Component)) {
popContext(workInProgress);
}
return null;
}
case SuspenseListComponent: {
popSuspenseContext(workInProgress);
var renderState = workInProgress.memoizedState;
if (renderState === null) {
// We're running in the default, "independent" mode.
// We don't do anything in this mode.
return null;
}
var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags;
var renderedTail = renderState.rendering;
if (renderedTail === null) {
// We just rendered the head.
if (!didSuspendAlready) {
// This is the first pass. We need to figure out if anything is still
// suspended in the rendered set.
// If new content unsuspended, but there's still some content that
// didn't. Then we need to do a second pass that forces everything
// to keep showing their fallbacks.
// We might be suspended if something in this render pass suspended, or
// something in the previous committed pass suspended. Otherwise,
// there's no chance so we can skip the expensive call to
// findFirstSuspended.
var cannotBeSuspended =
renderHasNotSuspendedYet() &&
(current === null || (current.flags & DidCapture) === NoFlags);
if (!cannotBeSuspended) {
var row = workInProgress.child;
while (row !== null) {
var suspended = findFirstSuspended(row);
if (suspended !== null) {
didSuspendAlready = true;
workInProgress.flags |= DidCapture;
cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
// part of the second pass. In that case nothing will subscribe to
// its thennables. Instead, we'll transfer its thennables to the
// SuspenseList so that it can retry if they resolve.
// There might be multiple of these in the list but since we're
// going to wait for all of them anyway, it doesn't really matter
// which ones gets to ping. In theory we could get clever and keep
// track of how many dependencies remain but it gets tricky because
// in the meantime, we can add/remove/change items and dependencies.
// We might bail out of the loop before finding any but that
// doesn't matter since that means that the other boundaries that
// we did find already has their listeners attached.
var newThennables = suspended.updateQueue;
if (newThennables !== null) {
workInProgress.updateQueue = newThennables;
workInProgress.flags |= Update;
} // Rerender the whole list, but this time, we'll force fallbacks
// to stay in place.
// Reset the effect list before doing the second pass since that's now invalid.
if (renderState.lastEffect === null) {
workInProgress.firstEffect = null;
}
workInProgress.lastEffect = renderState.lastEffect; // Reset the child fibers to their original state.
resetChildFibers(workInProgress, renderLanes); // Set up the Suspense Context to force suspense and immediately
// rerender the children.
pushSuspenseContext(
workInProgress,
setShallowSuspenseContext(
suspenseStackCursor.current,
ForceSuspenseFallback,
),
);
return workInProgress.child;
}
row = row.sibling;
}
}
if (renderState.tail !== null && now() > getRenderTargetTime()) {
// We have already passed our CPU deadline but we still have rows
// left in the tail. We'll just give up further attempts to render
// the main content and only render fallbacks.
workInProgress.flags |= DidCapture;
didSuspendAlready = true;
cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
// to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes = SomeRetryLane;
{
markSpawnedWork(SomeRetryLane);
}
}
} else {
cutOffTailIfNeeded(renderState, false);
} // Next we're going to render the tail.
} else {
// Append the rendered row to the child list.
if (!didSuspendAlready) {
var _suspended = findFirstSuspended(renderedTail);
if (_suspended !== null) {
workInProgress.flags |= DidCapture;
didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
// get lost if this row ends up dropped during a second pass.
var _newThennables = _suspended.updateQueue;
if (_newThennables !== null) {
workInProgress.updateQueue = _newThennables;
workInProgress.flags |= Update;
}
cutOffTailIfNeeded(renderState, true); // This might have been modified.
if (
renderState.tail === null &&
renderState.tailMode === "hidden" &&
!renderedTail.alternate &&
!getIsHydrating() // We don't cut it if we're hydrating.
) {
// We need to delete the row we just rendered.
// Reset the effect list to what it was before we rendered this
// child. The nested children have already appended themselves.
var lastEffect = (workInProgress.lastEffect =
renderState.lastEffect); // Remove any effects that were appended after this point.
if (lastEffect !== null) {
lastEffect.nextEffect = null;
} // We're done.
return null;
}
} else if (
// The time it took to render last row is greater than the remaining
// time we have to render. So rendering one more row would likely
// exceed it.
now() * 2 - renderState.renderingStartTime >
getRenderTargetTime() &&
renderLanes !== OffscreenLane
) {
// We have now passed our CPU deadline and we'll just give up further
// attempts to render the main content and only render fallbacks.
// The assumption is that this is usually faster.
workInProgress.flags |= DidCapture;
didSuspendAlready = true;
cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
// to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes = SomeRetryLane;
{
markSpawnedWork(SomeRetryLane);
}
}
}
if (renderState.isBackwards) {
// The effect list of the backwards tail will have been added
// to the end. This breaks the guarantee that life-cycles fire in
// sibling order but that isn't a strong guarantee promised by React.
// Especially since these might also just pop in during future commits.
// Append to the beginning of the list.
renderedTail.sibling = workInProgress.child;
workInProgress.child = renderedTail;
} else {
var previousSibling = renderState.last;
if (previousSibling !== null) {
previousSibling.sibling = renderedTail;
} else {
workInProgress.child = renderedTail;
}
renderState.last = renderedTail;
}
}
if (renderState.tail !== null) {
// We still have tail rows to render.
// Pop a row.
var next = renderState.tail;
renderState.rendering = next;
renderState.tail = next.sibling;
renderState.lastEffect = workInProgress.lastEffect;
renderState.renderingStartTime = now();
next.sibling = null; // Restore the context.
// TODO: We can probably just avoid popping it instead and only
// setting it the first time we go from not suspended to suspended.
var suspenseContext = suspenseStackCursor.current;
if (didSuspendAlready) {
suspenseContext = setShallowSuspenseContext(
suspenseContext,
ForceSuspenseFallback,
);
} else {
suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
}
pushSuspenseContext(workInProgress, suspenseContext); // Do a pass over the next row.
return next;
}
return null;
}
case FundamentalComponent: {
break;
}
case ScopeComponent: {
break;
}
case Block:
break;
case OffscreenComponent:
case LegacyHiddenComponent: {
popRenderLanes(workInProgress);
if (current !== null) {
var _nextState = workInProgress.memoizedState;
var _prevState = current.memoizedState;
var prevIsHidden = _prevState !== null;
var nextIsHidden = _nextState !== null;
if (
prevIsHidden !== nextIsHidden &&
newProps.mode !== "unstable-defer-without-hiding"
) {
workInProgress.flags |= Update;
}
}
return null;
}
}
{
{
throw Error(
"Unknown unit of work tag (" +
workInProgress.tag +
"). This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function unwindWork(workInProgress, renderLanes) {
switch (workInProgress.tag) {
case ClassComponent: {
var Component = workInProgress.type;
if (isContextProvider(Component)) {
popContext(workInProgress);
}
var flags = workInProgress.flags;
if (flags & ShouldCapture) {
workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
if ((workInProgress.mode & ProfileMode) !== NoMode) {
transferActualDuration(workInProgress);
}
return workInProgress;
}
return null;
}
case HostRoot: {
popHostContainer(workInProgress);
popTopLevelContextObject(workInProgress);
resetWorkInProgressVersions();
var _flags = workInProgress.flags;
if (!((_flags & DidCapture) === NoFlags)) {
{
throw Error(
"The root failed to unmount after an error. This is likely a bug in React. Please file an issue.",
);
}
}
workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
return workInProgress;
}
case HostComponent: {
// TODO: popHydrationState
popHostContext(workInProgress);
return null;
}
case SuspenseComponent: {
popSuspenseContext(workInProgress);
var _flags2 = workInProgress.flags;
if (_flags2 & ShouldCapture) {
workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
if ((workInProgress.mode & ProfileMode) !== NoMode) {
transferActualDuration(workInProgress);
}
return workInProgress;
}
return null;
}
case SuspenseListComponent: {
popSuspenseContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
// caught by a nested boundary. If not, it should bubble through.
return null;
}
case HostPortal:
popHostContainer(workInProgress);
return null;
case ContextProvider:
popProvider(workInProgress);
return null;
case OffscreenComponent:
case LegacyHiddenComponent:
popRenderLanes(workInProgress);
return null;
default:
return null;
}
}
function unwindInterruptedWork(interruptedWork) {
switch (interruptedWork.tag) {
case ClassComponent: {
var childContextTypes = interruptedWork.type.childContextTypes;
if (childContextTypes !== null && childContextTypes !== undefined) {
popContext(interruptedWork);
}
break;
}
case HostRoot: {
popHostContainer(interruptedWork);
popTopLevelContextObject(interruptedWork);
resetWorkInProgressVersions();
break;
}
case HostComponent: {
popHostContext(interruptedWork);
break;
}
case HostPortal:
popHostContainer(interruptedWork);
break;
case SuspenseComponent:
popSuspenseContext(interruptedWork);
break;
case SuspenseListComponent:
popSuspenseContext(interruptedWork);
break;
case ContextProvider:
popProvider(interruptedWork);
break;
case OffscreenComponent:
case LegacyHiddenComponent:
popRenderLanes(interruptedWork);
break;
}
}
function createCapturedValue(value, source) {
// If the value is an error, call this function immediately after it is thrown
// so the stack is accurate.
return {
value: value,
source: source,
stack: getStackByFiberInDevAndProd(source),
};
}
// This module is forked in different environments.
// By default, return `true` to log errors to the console.
// Forks can return `false` if this isn't desirable.
function showErrorDialog(boundary, errorInfo) {
return true;
}
function logCapturedError(boundary, errorInfo) {
try {
var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
// This enables renderers like ReactNative to better manage redbox behavior.
if (logError === false) {
return;
}
var error = errorInfo.value;
if (true) {
var source = errorInfo.source;
var stack = errorInfo.stack;
var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
// `preventDefault()` in window `error` handler.
// We record this information as an expando on the error.
if (error != null && error._suppressLogging) {
if (boundary.tag === ClassComponent) {
// The error is recoverable and was silenced.
// Ignore it and don't print the stack addendum.
// This is handy for testing error boundaries without noise.
return;
} // The error is fatal. Since the silencing might have
// been accidental, we'll surface it anyway.
// However, the browser would have silenced the original error
// so we'll print it first, and then print the stack addendum.
console["error"](error); // Don't transform to our wrapper
// For a more detailed description of this block, see:
// https://github.com/facebook/react/pull/13384
}
var componentName = source ? getComponentName(source.type) : null;
var componentNameMessage = componentName
? "The above error occurred in the <" + componentName + "> component:"
: "The above error occurred in one of your React components:";
var errorBoundaryMessage;
var errorBoundaryName = getComponentName(boundary.type);
if (errorBoundaryName) {
errorBoundaryMessage =
"React will try to recreate this component tree from scratch " +
("using the error boundary you provided, " +
errorBoundaryName +
".");
} else {
errorBoundaryMessage =
"Consider adding an error boundary to your tree to customize error handling behavior.\n" +
"Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
}
var combinedMessage =
componentNameMessage +
"\n" +
componentStack +
"\n\n" +
("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
// We don't include the original error message and JS stack because the browser
// has already printed it. Even if the application swallows the error, it is still
// displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
console["error"](combinedMessage); // Don't transform to our wrapper
} else {
// In production, we print the error directly.
// This will include the message, the JS stack, and anything the browser wants to show.
// We pass the error object instead of custom message so that the browser displays the error natively.
console["error"](error); // Don't transform to our wrapper
}
} catch (e) {
// This method must not throw, or React internal state will get messed up.
// If console.error is overridden, or logCapturedError() shows a dialog that throws,
// we want to report this error outside of the normal stack as a last resort.
// https://github.com/facebook/react/issues/13188
setTimeout(function () {
throw e;
});
}
}
var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
function createRootErrorUpdate(fiber, errorInfo, lane) {
var update = createUpdate(NoTimestamp, lane); // Unmount the root by rendering null.
update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
// being called "element".
update.payload = {
element: null,
};
var error = errorInfo.value;
update.callback = function () {
onUncaughtError(error);
logCapturedError(fiber, errorInfo);
};
return update;
}
function createClassErrorUpdate(fiber, errorInfo, lane) {
var update = createUpdate(NoTimestamp, lane);
update.tag = CaptureUpdate;
var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
if (typeof getDerivedStateFromError === "function") {
var error$1 = errorInfo.value;
update.payload = function () {
logCapturedError(fiber, errorInfo);
return getDerivedStateFromError(error$1);
};
}
var inst = fiber.stateNode;
if (inst !== null && typeof inst.componentDidCatch === "function") {
update.callback = function callback() {
{
markFailedErrorBoundaryForHotReloading(fiber);
}
if (typeof getDerivedStateFromError !== "function") {
// To preserve the preexisting retry behavior of error boundaries,
// we keep track of which ones already failed during this batch.
// This gets reset before we yield back to the browser.
// TODO: Warn in strict mode if getDerivedStateFromError is
// not defined.
markLegacyErrorBoundaryAsFailed(this); // Only log here if componentDidCatch is the only error boundary method defined
logCapturedError(fiber, errorInfo);
}
var error$1 = errorInfo.value;
var stack = errorInfo.stack;
this.componentDidCatch(error$1, {
componentStack: stack !== null ? stack : "",
});
{
if (typeof getDerivedStateFromError !== "function") {
// If componentDidCatch is the only error boundary method defined,
// then it needs to call setState to recover from errors.
// If no state update is scheduled then the boundary will swallow the error.
if (!includesSomeLane(fiber.lanes, SyncLane)) {
error(
"%s: Error boundaries should implement getDerivedStateFromError(). " +
"In that method, return a state update to display an error message or fallback UI.",
getComponentName(fiber.type) || "Unknown",
);
}
}
}
};
} else {
update.callback = function () {
markFailedErrorBoundaryForHotReloading(fiber);
};
}
return update;
}
function attachPingListener(root, wakeable, lanes) {
// Attach a listener to the promise to "ping" the root and retry. But only if
// one does not already exist for the lanes we're currently rendering (which
// acts like a "thread ID" here).
var pingCache = root.pingCache;
var threadIDs;
if (pingCache === null) {
pingCache = root.pingCache = new PossiblyWeakMap$1();
threadIDs = new Set();
pingCache.set(wakeable, threadIDs);
} else {
threadIDs = pingCache.get(wakeable);
if (threadIDs === undefined) {
threadIDs = new Set();
pingCache.set(wakeable, threadIDs);
}
}
if (!threadIDs.has(lanes)) {
// Memoize using the thread ID to prevent redundant listeners.
threadIDs.add(lanes);
var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
wakeable.then(ping, ping);
}
}
function throwException(
root,
returnFiber,
sourceFiber,
value,
rootRenderLanes,
) {
// The source fiber did not complete.
sourceFiber.flags |= Incomplete; // Its effect list is no longer valid.
sourceFiber.firstEffect = sourceFiber.lastEffect = null;
if (
value !== null &&
typeof value === "object" &&
typeof value.then === "function"
) {
// This is a wakeable.
var wakeable = value;
if ((sourceFiber.mode & BlockingMode) === NoMode) {
// Reset the memoizedState to what it was before we attempted
// to render it.
var currentSource = sourceFiber.alternate;
if (currentSource) {
sourceFiber.updateQueue = currentSource.updateQueue;
sourceFiber.memoizedState = currentSource.memoizedState;
sourceFiber.lanes = currentSource.lanes;
} else {
sourceFiber.updateQueue = null;
sourceFiber.memoizedState = null;
}
}
var hasInvisibleParentBoundary = hasSuspenseContext(
suspenseStackCursor.current,
InvisibleParentSuspenseContext,
); // Schedule the nearest Suspense to re-render the timed out view.
var _workInProgress = returnFiber;
do {
if (
_workInProgress.tag === SuspenseComponent &&
shouldCaptureSuspense(_workInProgress, hasInvisibleParentBoundary)
) {
// Found the nearest boundary.
// Stash the promise on the boundary fiber. If the boundary times out, we'll
// attach another listener to flip the boundary back to its normal state.
var wakeables = _workInProgress.updateQueue;
if (wakeables === null) {
var updateQueue = new Set();
updateQueue.add(wakeable);
_workInProgress.updateQueue = updateQueue;
} else {
wakeables.add(wakeable);
} // If the boundary is outside of blocking mode, we should *not*
// suspend the commit. Pretend as if the suspended component rendered
// null and keep rendering. In the commit phase, we'll schedule a
// subsequent synchronous update to re-render the Suspense.
//
// Note: It doesn't matter whether the component that suspended was
// inside a blocking mode tree. If the Suspense is outside of it, we
// should *not* suspend the commit.
if ((_workInProgress.mode & BlockingMode) === NoMode) {
_workInProgress.flags |= DidCapture;
sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.
// But we shouldn't call any lifecycle methods or callbacks. Remove
// all lifecycle effect tags.
sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
if (sourceFiber.tag === ClassComponent) {
var currentSourceFiber = sourceFiber.alternate;
if (currentSourceFiber === null) {
// This is a new mount. Change the tag so it's not mistaken for a
// completed class component. For example, we should not call
// componentWillUnmount if it is deleted.
sourceFiber.tag = IncompleteClassComponent;
} else {
// When we try rendering again, we should not reuse the current fiber,
// since it's known to be in an inconsistent state. Use a force update to
// prevent a bail out.
var update = createUpdate(NoTimestamp, SyncLane);
update.tag = ForceUpdate;
enqueueUpdate(sourceFiber, update);
}
} // The source fiber did not complete. Mark it with Sync priority to
// indicate that it still has pending work.
sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane); // Exit without suspending.
return;
} // Confirmed that the boundary is in a concurrent mode tree. Continue
// with the normal suspend path.
//
// After this we'll use a set of heuristics to determine whether this
// render pass will run to completion or restart or "suspend" the commit.
// The actual logic for this is spread out in different places.
//
// This first principle is that if we're going to suspend when we complete
// a root, then we should also restart if we get an update or ping that
// might unsuspend it, and vice versa. The only reason to suspend is
// because you think you might want to restart before committing. However,
// it doesn't make sense to restart only while in the period we're suspended.
//
// Restarting too aggressively is also not good because it starves out any
// intermediate loading state. So we use heuristics to determine when.
// Suspense Heuristics
//
// If nothing threw a Promise or all the same fallbacks are already showing,
// then don't suspend/restart.
//
// If this is an initial render of a new tree of Suspense boundaries and
// those trigger a fallback, then don't suspend/restart. We want to ensure
// that we can show the initial loading state as quickly as possible.
//
// If we hit a "Delayed" case, such as when we'd switch from content back into
// a fallback, then we should always suspend/restart. Transitions apply
// to this case. If none is defined, JND is used instead.
//
// If we're already showing a fallback and it gets "retried", allowing us to show
// another level, but there's still an inner boundary that would show a fallback,
// then we suspend/restart for 500ms since the last time we showed a fallback
// anywhere in the tree. This effectively throttles progressive loading into a
// consistent train of commits. This also gives us an opportunity to restart to
// get to the completed state slightly earlier.
//
// If there's ambiguity due to batching it's resolved in preference of:
// 1) "delayed", 2) "initial render", 3) "retry".
//
// We want to ensure that a "busy" state doesn't get force committed. We want to
// ensure that new initial loading states can commit as soon as possible.
attachPingListener(root, wakeable, rootRenderLanes);
_workInProgress.flags |= ShouldCapture;
_workInProgress.lanes = rootRenderLanes;
return;
} // This boundary already captured during this render. Continue to the next
// boundary.
_workInProgress = _workInProgress.return;
} while (_workInProgress !== null); // No boundary was found. Fallthrough to error mode.
// TODO: Use invariant so the message is stripped in prod?
value = new Error(
(getComponentName(sourceFiber.type) || "A React component") +
" suspended while rendering, but no fallback UI was specified.\n" +
"\n" +
"Add a <Suspense fallback=...> component higher in the tree to " +
"provide a loading indicator or placeholder to display.",
);
} // We didn't find a boundary that could handle this type of exception. Start
// over and traverse parent path again, this time treating the exception
// as an error.
renderDidError();
value = createCapturedValue(value, sourceFiber);
var workInProgress = returnFiber;
do {
switch (workInProgress.tag) {
case HostRoot: {
var _errorInfo = value;
workInProgress.flags |= ShouldCapture;
var lane = pickArbitraryLane(rootRenderLanes);
workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
var _update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
enqueueCapturedUpdate(workInProgress, _update);
return;
}
case ClassComponent:
// Capture and retry
var errorInfo = value;
var ctor = workInProgress.type;
var instance = workInProgress.stateNode;
if (
(workInProgress.flags & DidCapture) === NoFlags &&
(typeof ctor.getDerivedStateFromError === "function" ||
(instance !== null &&
typeof instance.componentDidCatch === "function" &&
!isAlreadyFailedLegacyErrorBoundary(instance)))
) {
workInProgress.flags |= ShouldCapture;
var _lane = pickArbitraryLane(rootRenderLanes);
workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
var _update2 = createClassErrorUpdate(
workInProgress,
errorInfo,
_lane,
);
enqueueCapturedUpdate(workInProgress, _update2);
return;
}
break;
}
workInProgress = workInProgress.return;
} while (workInProgress !== null);
}
var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
{
didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
}
var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
var callComponentWillUnmountWithTimer = function (current, instance) {
instance.props = current.memoizedProps;
instance.state = current.memoizedState;
{
instance.componentWillUnmount();
}
}; // Capture errors so they don't interrupt unmounting.
function safelyCallComponentWillUnmount(current, instance) {
{
invokeGuardedCallback(
null,
callComponentWillUnmountWithTimer,
null,
current,
instance,
);
if (hasCaughtError()) {
var unmountError = clearCaughtError();
captureCommitPhaseError(current, unmountError);
}
}
}
function safelyDetachRef(current) {
var ref = current.ref;
if (ref !== null) {
if (typeof ref === "function") {
{
invokeGuardedCallback(null, ref, null, null);
if (hasCaughtError()) {
var refError = clearCaughtError();
captureCommitPhaseError(current, refError);
}
}
} else {
ref.current = null;
}
}
}
function safelyCallDestroy(current, destroy) {
{
invokeGuardedCallback(null, destroy, null);
if (hasCaughtError()) {
var error = clearCaughtError();
captureCommitPhaseError(current, error);
}
}
}
function commitBeforeMutationLifeCycles(current, finishedWork) {
switch (finishedWork.tag) {
case FunctionComponent:
case ForwardRef:
case SimpleMemoComponent:
case Block: {
return;
}
case ClassComponent: {
if (finishedWork.flags & Snapshot) {
if (current !== null) {
var prevProps = current.memoizedProps;
var prevState = current.memoizedState;
var instance = finishedWork.stateNode; // We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{
if (
finishedWork.type === finishedWork.elementType &&
!didWarnAboutReassigningProps
) {
if (instance.props !== finishedWork.memoizedProps) {
error(
"Expected %s props to match memoized props before " +
"getSnapshotBeforeUpdate. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.props`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
if (instance.state !== finishedWork.memoizedState) {
error(
"Expected %s state to match memoized state before " +
"getSnapshotBeforeUpdate. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.state`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
}
}
var snapshot = instance.getSnapshotBeforeUpdate(
finishedWork.elementType === finishedWork.type
? prevProps
: resolveDefaultProps(finishedWork.type, prevProps),
prevState,
);
{
var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
if (
snapshot === undefined &&
!didWarnSet.has(finishedWork.type)
) {
didWarnSet.add(finishedWork.type);
error(
"%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
"must be returned. You have returned undefined.",
getComponentName(finishedWork.type),
);
}
}
instance.__reactInternalSnapshotBeforeUpdate = snapshot;
}
}
return;
}
case HostRoot: {
{
if (finishedWork.flags & Snapshot) {
var root = finishedWork.stateNode;
clearContainer(root.containerInfo);
}
}
return;
}
case HostComponent:
case HostText:
case HostPortal:
case IncompleteClassComponent:
// Nothing to do for these component types
return;
}
{
{
throw Error(
"This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function commitHookEffectListUnmount(tag, finishedWork) {
var updateQueue = finishedWork.updateQueue;
var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
if (lastEffect !== null) {
var firstEffect = lastEffect.next;
var effect = firstEffect;
do {
if ((effect.tag & tag) === tag) {
// Unmount
var destroy = effect.destroy;
effect.destroy = undefined;
if (destroy !== undefined) {
destroy();
}
}
effect = effect.next;
} while (effect !== firstEffect);
}
}
function commitHookEffectListMount(tag, finishedWork) {
var updateQueue = finishedWork.updateQueue;
var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
if (lastEffect !== null) {
var firstEffect = lastEffect.next;
var effect = firstEffect;
do {
if ((effect.tag & tag) === tag) {
// Mount
var create = effect.create;
effect.destroy = create();
{
var destroy = effect.destroy;
if (destroy !== undefined && typeof destroy !== "function") {
var addendum = void 0;
if (destroy === null) {
addendum =
" You returned null. If your effect does not require clean " +
"up, return undefined (or nothing).";
} else if (typeof destroy.then === "function") {
addendum =
"\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " +
"Instead, write the async function inside your effect " +
"and call it immediately:\n\n" +
"useEffect(() => {\n" +
" async function fetchData() {\n" +
" // You can await here\n" +
" const response = await MyAPI.getData(someId);\n" +
" // ...\n" +
" }\n" +
" fetchData();\n" +
"}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
"Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
} else {
addendum = " You returned: " + destroy;
}
error(
"An effect function must not return anything besides a function, " +
"which is used for clean-up.%s",
addendum,
);
}
}
}
effect = effect.next;
} while (effect !== firstEffect);
}
}
function schedulePassiveEffects(finishedWork) {
var updateQueue = finishedWork.updateQueue;
var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
if (lastEffect !== null) {
var firstEffect = lastEffect.next;
var effect = firstEffect;
do {
var _effect = effect,
next = _effect.next,
tag = _effect.tag;
if (
(tag & Passive$1) !== NoFlags$1 &&
(tag & HasEffect) !== NoFlags$1
) {
enqueuePendingPassiveHookEffectUnmount(finishedWork, effect);
enqueuePendingPassiveHookEffectMount(finishedWork, effect);
}
effect = next;
} while (effect !== firstEffect);
}
}
function commitLifeCycles(
finishedRoot,
current,
finishedWork,
committedLanes,
) {
switch (finishedWork.tag) {
case FunctionComponent:
case ForwardRef:
case SimpleMemoComponent:
case Block: {
// At this point layout effects have already been destroyed (during mutation phase).
// This is done to prevent sibling component effects from interfering with each other,
// e.g. a destroy function in one component should never override a ref set
// by a create function in another component during the same commit.
{
commitHookEffectListMount(Layout | HasEffect, finishedWork);
}
schedulePassiveEffects(finishedWork);
return;
}
case ClassComponent: {
var instance = finishedWork.stateNode;
if (finishedWork.flags & Update) {
if (current === null) {
// We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{
if (
finishedWork.type === finishedWork.elementType &&
!didWarnAboutReassigningProps
) {
if (instance.props !== finishedWork.memoizedProps) {
error(
"Expected %s props to match memoized props before " +
"componentDidMount. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.props`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
if (instance.state !== finishedWork.memoizedState) {
error(
"Expected %s state to match memoized state before " +
"componentDidMount. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.state`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
}
}
{
instance.componentDidMount();
}
} else {
var prevProps =
finishedWork.elementType === finishedWork.type
? current.memoizedProps
: resolveDefaultProps(finishedWork.type, current.memoizedProps);
var prevState = current.memoizedState; // We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
{
if (
finishedWork.type === finishedWork.elementType &&
!didWarnAboutReassigningProps
) {
if (instance.props !== finishedWork.memoizedProps) {
error(
"Expected %s props to match memoized props before " +
"componentDidUpdate. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.props`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
if (instance.state !== finishedWork.memoizedState) {
error(
"Expected %s state to match memoized state before " +
"componentDidUpdate. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.state`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
}
}
{
instance.componentDidUpdate(
prevProps,
prevState,
instance.__reactInternalSnapshotBeforeUpdate,
);
}
}
} // TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
var updateQueue = finishedWork.updateQueue;
if (updateQueue !== null) {
{
if (
finishedWork.type === finishedWork.elementType &&
!didWarnAboutReassigningProps
) {
if (instance.props !== finishedWork.memoizedProps) {
error(
"Expected %s props to match memoized props before " +
"processing the update queue. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.props`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
if (instance.state !== finishedWork.memoizedState) {
error(
"Expected %s state to match memoized state before " +
"processing the update queue. " +
"This might either be because of a bug in React, or because " +
"a component reassigns its own `this.state`. " +
"Please file an issue.",
getComponentName(finishedWork.type) || "instance",
);
}
}
} // We could update instance props and state here,
// but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
commitUpdateQueue(finishedWork, updateQueue, instance);
}
return;
}
case HostRoot: {
// TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
var _updateQueue = finishedWork.updateQueue;
if (_updateQueue !== null) {
var _instance = null;
if (finishedWork.child !== null) {
switch (finishedWork.child.tag) {
case HostComponent:
_instance = getPublicInstance(finishedWork.child.stateNode);
break;
case ClassComponent:
_instance = finishedWork.child.stateNode;
break;
}
}
commitUpdateQueue(finishedWork, _updateQueue, _instance);
}
return;
}
case HostComponent: {
var _instance2 = finishedWork.stateNode; // Renderers may schedule work to be done after host components are mounted
// (eg DOM renderer may schedule auto-focus for inputs and form controls).
// These effects should only be committed when components are first mounted,
// aka when there is no current/alternate.
if (current === null && finishedWork.flags & Update) {
var type = finishedWork.type;
var props = finishedWork.memoizedProps;
commitMount(_instance2, type, props);
}
return;
}
case HostText: {
// We have no life-cycles associated with text.
return;
}
case HostPortal: {
// We have no life-cycles associated with portals.
return;
}
case Profiler: {
{
var _finishedWork$memoize2 = finishedWork.memoizedProps,
onCommit = _finishedWork$memoize2.onCommit,
onRender = _finishedWork$memoize2.onRender;
var effectDuration = finishedWork.stateNode.effectDuration;
var commitTime = getCommitTime();
if (typeof onRender === "function") {
{
onRender(
finishedWork.memoizedProps.id,
current === null ? "mount" : "update",
finishedWork.actualDuration,
finishedWork.treeBaseDuration,
finishedWork.actualStartTime,
commitTime,
finishedRoot.memoizedInteractions,
);
}
}
}
return;
}
case SuspenseComponent: {
commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
return;
}
case SuspenseListComponent:
case IncompleteClassComponent:
case FundamentalComponent:
case ScopeComponent:
case OffscreenComponent:
case LegacyHiddenComponent:
return;
}
{
{
throw Error(
"This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function hideOrUnhideAllChildren(finishedWork, isHidden) {
{
// We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
var node = finishedWork;
while (true) {
if (node.tag === HostComponent) {
var instance = node.stateNode;
if (isHidden) {
hideInstance(instance);
} else {
unhideInstance(node.stateNode, node.memoizedProps);
}
} else if (node.tag === HostText) {
var _instance3 = node.stateNode;
if (isHidden) {
hideTextInstance(_instance3);
} else {
unhideTextInstance(_instance3, node.memoizedProps);
}
} else if (
(node.tag === OffscreenComponent ||
node.tag === LegacyHiddenComponent) &&
node.memoizedState !== null &&
node !== finishedWork
);
else if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
if (node === finishedWork) {
return;
}
while (node.sibling === null) {
if (node.return === null || node.return === finishedWork) {
return;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
}
}
function commitAttachRef(finishedWork) {
var ref = finishedWork.ref;
if (ref !== null) {
var instance = finishedWork.stateNode;
var instanceToUse;
switch (finishedWork.tag) {
case HostComponent:
instanceToUse = getPublicInstance(instance);
break;
default:
instanceToUse = instance;
} // Moved outside to ensure DCE works with this flag
if (typeof ref === "function") {
ref(instanceToUse);
} else {
{
if (!ref.hasOwnProperty("current")) {
error(
"Unexpected ref object provided for %s. " +
"Use either a ref-setter function or React.createRef().",
getComponentName(finishedWork.type),
);
}
}
ref.current = instanceToUse;
}
}
}
function commitDetachRef(current) {
var currentRef = current.ref;
if (currentRef !== null) {
if (typeof currentRef === "function") {
currentRef(null);
} else {
currentRef.current = null;
}
}
} // User-originating errors (lifecycles and refs) should not interrupt
// deletion, so don't let them throw. Host-originating errors should
// interrupt deletion, so it's okay
function commitUnmount(finishedRoot, current, renderPriorityLevel) {
onCommitUnmount(current);
switch (current.tag) {
case FunctionComponent:
case ForwardRef:
case MemoComponent:
case SimpleMemoComponent:
case Block: {
var updateQueue = current.updateQueue;
if (updateQueue !== null) {
var lastEffect = updateQueue.lastEffect;
if (lastEffect !== null) {
var firstEffect = lastEffect.next;
var effect = firstEffect;
do {
var _effect2 = effect,
destroy = _effect2.destroy,
tag = _effect2.tag;
if (destroy !== undefined) {
if ((tag & Passive$1) !== NoFlags$1) {
enqueuePendingPassiveHookEffectUnmount(current, effect);
} else {
{
safelyCallDestroy(current, destroy);
}
}
}
effect = effect.next;
} while (effect !== firstEffect);
}
}
return;
}
case ClassComponent: {
safelyDetachRef(current);
var instance = current.stateNode;
if (typeof instance.componentWillUnmount === "function") {
safelyCallComponentWillUnmount(current, instance);
}
return;
}
case HostComponent: {
safelyDetachRef(current);
return;
}
case HostPortal: {
// TODO: this is recursive.
// We are also not using this parent because
// the portal will get pushed immediately.
{
unmountHostComponents(finishedRoot, current);
}
return;
}
case FundamentalComponent: {
return;
}
case DehydratedFragment: {
return;
}
case ScopeComponent: {
return;
}
}
}
function commitNestedUnmounts(finishedRoot, root, renderPriorityLevel) {
// While we're inside a removed host node we don't want to call
// removeChild on the inner nodes because they're removed by the top
// call anyway. We also want to call componentWillUnmount on all
// composites before this host node is removed from the tree. Therefore
// we do an inner loop while we're still inside the host node.
var node = root;
while (true) {
commitUnmount(finishedRoot, node); // Visit children because they may contain more composite or host nodes.
// Skip portals because commitUnmount() currently visits them recursively.
if (
node.child !== null && // If we use mutation we drill down into portals using commitUnmount above.
// If we don't use mutation we drill down into portals here instead.
node.tag !== HostPortal
) {
node.child.return = node;
node = node.child;
continue;
}
if (node === root) {
return;
}
while (node.sibling === null) {
if (node.return === null || node.return === root) {
return;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
}
function detachFiberMutation(fiber) {
// Cut off the return pointers to disconnect it from the tree. Ideally, we
// should clear the child pointer of the parent alternate to let this
// get GC:ed but we don't know which for sure which parent is the current
// one so we'll settle for GC:ing the subtree of this child. This child
// itself will be GC:ed when the parent updates the next time.
// Note: we cannot null out sibling here, otherwise it can cause issues
// with findDOMNode and how it requires the sibling field to carry out
// traversal in a later effect. See PR #16820. We now clear the sibling
// field after effects, see: detachFiberAfterEffects.
//
// Don't disconnect stateNode now; it will be detached in detachFiberAfterEffects.
// It may be required if the current component is an error boundary,
// and one of its descendants throws while unmounting a passive effect.
fiber.alternate = null;
fiber.child = null;
fiber.dependencies = null;
fiber.firstEffect = null;
fiber.lastEffect = null;
fiber.memoizedProps = null;
fiber.memoizedState = null;
fiber.pendingProps = null;
fiber.return = null;
fiber.updateQueue = null;
{
fiber._debugOwner = null;
}
}
function getHostParentFiber(fiber) {
var parent = fiber.return;
while (parent !== null) {
if (isHostParent(parent)) {
return parent;
}
parent = parent.return;
}
{
{
throw Error(
"Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function isHostParent(fiber) {
return (
fiber.tag === HostComponent ||
fiber.tag === HostRoot ||
fiber.tag === HostPortal
);
}
function getHostSibling(fiber) {
// We're going to search forward into the tree until we find a sibling host
// node. Unfortunately, if multiple insertions are done in a row we have to
// search past them. This leads to exponential search for the next sibling.
// TODO: Find a more efficient way to do this.
var node = fiber;
siblings: while (true) {
// If we didn't find anything, let's try the next sibling.
while (node.sibling === null) {
if (node.return === null || isHostParent(node.return)) {
// If we pop out of the root or hit the parent the fiber we are the
// last sibling.
return null;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
while (
node.tag !== HostComponent &&
node.tag !== HostText &&
node.tag !== DehydratedFragment
) {
// If it is not host node and, we might have a host node inside it.
// Try to search down until we find one.
if (node.flags & Placement) {
// If we don't have a child, try the siblings instead.
continue siblings;
} // If we don't have a child, try the siblings instead.
// We also skip portals because they are not part of this host tree.
if (node.child === null || node.tag === HostPortal) {
continue siblings;
} else {
node.child.return = node;
node = node.child;
}
} // Check if this host node is stable or about to be placed.
if (!(node.flags & Placement)) {
// Found it!
return node.stateNode;
}
}
}
function commitPlacement(finishedWork) {
var parentFiber = getHostParentFiber(finishedWork); // Note: these two variables *must* always be updated together.
var parent;
var isContainer;
var parentStateNode = parentFiber.stateNode;
switch (parentFiber.tag) {
case HostComponent:
parent = parentStateNode;
isContainer = false;
break;
case HostRoot:
parent = parentStateNode.containerInfo;
isContainer = true;
break;
case HostPortal:
parent = parentStateNode.containerInfo;
isContainer = true;
break;
case FundamentalComponent:
// eslint-disable-next-line-no-fallthrough
default: {
{
throw Error(
"Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
if (parentFiber.flags & ContentReset) {
// Reset the text content of the parent before doing any insertions
resetTextContent(parent); // Clear ContentReset from the effect tag
parentFiber.flags &= ~ContentReset;
}
var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
if (isContainer) {
insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);
} else {
insertOrAppendPlacementNode(finishedWork, before, parent);
}
}
function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
var tag = node.tag;
var isHost = tag === HostComponent || tag === HostText;
if (isHost || enableFundamentalAPI) {
var stateNode = isHost ? node.stateNode : node.stateNode.instance;
if (before) {
insertInContainerBefore(parent, stateNode, before);
} else {
appendChildToContainer(parent, stateNode);
}
} else if (tag === HostPortal);
else {
var child = node.child;
if (child !== null) {
insertOrAppendPlacementNodeIntoContainer(child, before, parent);
var sibling = child.sibling;
while (sibling !== null) {
insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
sibling = sibling.sibling;
}
}
}
}
function insertOrAppendPlacementNode(node, before, parent) {
var tag = node.tag;
var isHost = tag === HostComponent || tag === HostText;
if (isHost || enableFundamentalAPI) {
var stateNode = isHost ? node.stateNode : node.stateNode.instance;
if (before) {
insertBefore(parent, stateNode, before);
} else {
appendChild(parent, stateNode);
}
} else if (tag === HostPortal);
else {
var child = node.child;
if (child !== null) {
insertOrAppendPlacementNode(child, before, parent);
var sibling = child.sibling;
while (sibling !== null) {
insertOrAppendPlacementNode(sibling, before, parent);
sibling = sibling.sibling;
}
}
}
}
function unmountHostComponents(finishedRoot, current, renderPriorityLevel) {
// We only have the top Fiber that was deleted but we need to recurse down its
// children to find all the terminal nodes.
var node = current; // Each iteration, currentParent is populated with node's host parent if not
// currentParentIsValid.
var currentParentIsValid = false; // Note: these two variables *must* always be updated together.
var currentParent;
var currentParentIsContainer;
while (true) {
if (!currentParentIsValid) {
var parent = node.return;
findParent: while (true) {
if (!(parent !== null)) {
{
throw Error(
"Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var parentStateNode = parent.stateNode;
switch (parent.tag) {
case HostComponent:
currentParent = parentStateNode;
currentParentIsContainer = false;
break findParent;
case HostRoot:
currentParent = parentStateNode.containerInfo;
currentParentIsContainer = true;
break findParent;
case HostPortal:
currentParent = parentStateNode.containerInfo;
currentParentIsContainer = true;
break findParent;
}
parent = parent.return;
}
currentParentIsValid = true;
}
if (node.tag === HostComponent || node.tag === HostText) {
commitNestedUnmounts(finishedRoot, node); // After all the children have unmounted, it is now safe to remove the
// node from the tree.
if (currentParentIsContainer) {
removeChildFromContainer(currentParent, node.stateNode);
} else {
removeChild(currentParent, node.stateNode);
} // Don't visit children because we already visited them.
} else if (node.tag === HostPortal) {
if (node.child !== null) {
// When we go into a portal, it becomes the parent to remove from.
// We will reassign it back when we pop the portal on the way up.
currentParent = node.stateNode.containerInfo;
currentParentIsContainer = true; // Visit children because portals might contain host components.
node.child.return = node;
node = node.child;
continue;
}
} else {
commitUnmount(finishedRoot, node); // Visit children because we may find more host components below.
if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
}
if (node === current) {
return;
}
while (node.sibling === null) {
if (node.return === null || node.return === current) {
return;
}
node = node.return;
if (node.tag === HostPortal) {
// When we go out of the portal, we need to restore the parent.
// Since we don't keep a stack of them, we will search for it.
currentParentIsValid = false;
}
}
node.sibling.return = node.return;
node = node.sibling;
}
}
function commitDeletion(finishedRoot, current, renderPriorityLevel) {
{
// Recursively delete all host nodes from the parent.
// Detach refs and call componentWillUnmount() on the whole subtree.
unmountHostComponents(finishedRoot, current);
}
var alternate = current.alternate;
detachFiberMutation(current);
if (alternate !== null) {
detachFiberMutation(alternate);
}
}
function commitWork(current, finishedWork) {
switch (finishedWork.tag) {
case FunctionComponent:
case ForwardRef:
case MemoComponent:
case SimpleMemoComponent:
case Block: {
// Layout effects are destroyed during the mutation phase so that all
// destroy functions for all fibers are called before any create functions.
// This prevents sibling component effects from interfering with each other,
// e.g. a destroy function in one component should never override a ref set
// by a create function in another component during the same commit.
{
commitHookEffectListUnmount(Layout | HasEffect, finishedWork);
}
return;
}
case ClassComponent: {
return;
}
case HostComponent: {
var instance = finishedWork.stateNode;
if (instance != null) {
// Commit the work prepared earlier.
var newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
// as the newProps. The updatePayload will contain the real change in
// this case.
var oldProps = current !== null ? current.memoizedProps : newProps;
var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
var updatePayload = finishedWork.updateQueue;
finishedWork.updateQueue = null;
if (updatePayload !== null) {
commitUpdate(instance, updatePayload, type, oldProps, newProps);
}
}
return;
}
case HostText: {
if (!(finishedWork.stateNode !== null)) {
{
throw Error(
"This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
var textInstance = finishedWork.stateNode;
var newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps
// as the newProps. The updatePayload will contain the real change in
// this case.
var oldText = current !== null ? current.memoizedProps : newText;
commitTextUpdate(textInstance, oldText, newText);
return;
}
case HostRoot: {
{
var _root = finishedWork.stateNode;
if (_root.hydrate) {
// We've just hydrated. No need to hydrate again.
_root.hydrate = false;
commitHydratedContainer(_root.containerInfo);
}
}
return;
}
case Profiler: {
return;
}
case SuspenseComponent: {
commitSuspenseComponent(finishedWork);
attachSuspenseRetryListeners(finishedWork);
return;
}
case SuspenseListComponent: {
attachSuspenseRetryListeners(finishedWork);
return;
}
case IncompleteClassComponent: {
return;
}
case FundamentalComponent: {
break;
}
case ScopeComponent: {
break;
}
case OffscreenComponent:
case LegacyHiddenComponent: {
var newState = finishedWork.memoizedState;
var isHidden = newState !== null;
hideOrUnhideAllChildren(finishedWork, isHidden);
return;
}
}
{
{
throw Error(
"This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
function commitSuspenseComponent(finishedWork) {
var newState = finishedWork.memoizedState;
if (newState !== null) {
markCommitTimeOfFallback();
{
// Hide the Offscreen component that contains the primary children. TODO:
// Ideally, this effect would have been scheduled on the Offscreen fiber
// itself. That's how unhiding works: the Offscreen component schedules an
// effect on itself. However, in this case, the component didn't complete,
// so the fiber was never added to the effect list in the normal path. We
// could have appended it to the effect list in the Suspense component's
// second pass, but doing it this way is less complicated. This would be
// simpler if we got rid of the effect list and traversed the tree, like
// we're planning to do.
var primaryChildParent = finishedWork.child;
hideOrUnhideAllChildren(primaryChildParent, true);
}
}
}
function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
var newState = finishedWork.memoizedState;
if (newState === null) {
var current = finishedWork.alternate;
if (current !== null) {
var prevState = current.memoizedState;
if (prevState !== null) {
var suspenseInstance = prevState.dehydrated;
if (suspenseInstance !== null) {
commitHydratedSuspenseInstance(suspenseInstance);
}
}
}
}
}
function attachSuspenseRetryListeners(finishedWork) {
// If this boundary just timed out, then it will have a set of wakeables.
// For each wakeable, attach a listener so that when it resolves, React
// attempts to re-render the boundary in the primary (pre-timeout) state.
var wakeables = finishedWork.updateQueue;
if (wakeables !== null) {
finishedWork.updateQueue = null;
var retryCache = finishedWork.stateNode;
if (retryCache === null) {
retryCache = finishedWork.stateNode = new PossiblyWeakSet();
}
wakeables.forEach(function (wakeable) {
// Memoize using the boundary fiber to prevent redundant listeners.
var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
if (!retryCache.has(wakeable)) {
{
if (wakeable.__reactDoNotTraceInteractions !== true) {
retry = unstable_wrap(retry);
}
}
retryCache.add(wakeable);
wakeable.then(retry, retry);
}
});
}
} // This function detects when a Suspense boundary goes from visible to hidden.
// It returns false if the boundary is already hidden.
// TODO: Use an effect tag.
function isSuspenseBoundaryBeingHidden(current, finishedWork) {
if (current !== null) {
var oldState = current.memoizedState;
if (oldState === null || oldState.dehydrated !== null) {
var newState = finishedWork.memoizedState;
return newState !== null && newState.dehydrated === null;
}
}
return false;
}
function commitResetTextContent(current) {
resetTextContent(current.stateNode);
}
var COMPONENT_TYPE = 0;
var HAS_PSEUDO_CLASS_TYPE = 1;
var ROLE_TYPE = 2;
var TEST_NAME_TYPE = 3;
var TEXT_TYPE = 4;
if (typeof Symbol === "function" && Symbol.for) {
var symbolFor$1 = Symbol.for;
COMPONENT_TYPE = symbolFor$1("selector.component");
HAS_PSEUDO_CLASS_TYPE = symbolFor$1("selector.has_pseudo_class");
ROLE_TYPE = symbolFor$1("selector.role");
TEST_NAME_TYPE = symbolFor$1("selector.test_id");
TEXT_TYPE = symbolFor$1("selector.text");
}
var commitHooks = [];
function onCommitRoot$1() {
{
commitHooks.forEach(function (commitHook) {
return commitHook();
});
}
}
var ceil = Math.ceil;
var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher,
ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing;
var NoContext =
/* */
0;
var BatchedContext =
/* */
1;
var EventContext =
/* */
2;
var DiscreteEventContext =
/* */
4;
var LegacyUnbatchedContext =
/* */
8;
var RenderContext =
/* */
16;
var CommitContext =
/* */
32;
var RetryAfterError =
/* */
64;
var RootIncomplete = 0;
var RootFatalErrored = 1;
var RootErrored = 2;
var RootSuspended = 3;
var RootSuspendedWithDelay = 4;
var RootCompleted = 5; // Describes where we are in the React execution stack
var executionContext = NoContext; // The root we're working on
var workInProgressRoot = null; // The fiber we're working on
var workInProgress = null; // The lanes we're rendering
var workInProgressRootRenderLanes = NoLanes; // Stack that allows components to change the render lanes for its subtree
// This is a superset of the lanes we started working on at the root. The only
// case where it's different from `workInProgressRootRenderLanes` is when we
// enter a subtree that is hidden and needs to be unhidden: Suspense and
// Offscreen component.
//
// Most things in the work loop should deal with workInProgressRootRenderLanes.
// Most things in begin/complete phases should deal with subtreeRenderLanes.
var subtreeRenderLanes = NoLanes;
var subtreeRenderLanesCursor = createCursor(NoLanes); // Whether to root completed, errored, suspended, etc.
var workInProgressRootExitStatus = RootIncomplete; // A fatal error, if one is thrown
var workInProgressRootFatalError = null; // "Included" lanes refer to lanes that were worked on during this render. It's
// slightly different than `renderLanes` because `renderLanes` can change as you
// enter and exit an Offscreen tree. This value is the combination of all render
// lanes for the entire render phase.
var workInProgressRootIncludedLanes = NoLanes; // The work left over by components that were visited during this render. Only
// includes unprocessed updates, not work in bailed out children.
var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
var workInProgressRootUpdatedLanes = NoLanes; // Lanes that were pinged (in an interleaved event) during this render.
var workInProgressRootPingedLanes = NoLanes;
var mostRecentlyUpdatedRoot = null; // The most recent time we committed a fallback. This lets us ensure a train
// model where we don't commit new loading states in too quick succession.
var globalMostRecentFallbackTime = 0;
var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
// more and prefer CPU suspense heuristics instead.
var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
// suspense heuristics and opt out of rendering more content.
var RENDER_TIMEOUT_MS = 500;
function resetRenderTimer() {
workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
}
function getRenderTargetTime() {
return workInProgressRootRenderTargetTime;
}
var nextEffect = null;
var hasUncaughtError = false;
var firstUncaughtError = null;
var legacyErrorBoundariesThatAlreadyFailed = null;
var rootDoesHavePassiveEffects = false;
var rootWithPendingPassiveEffects = null;
var pendingPassiveEffectsRenderPriority = NoPriority$1;
var pendingPassiveEffectsLanes = NoLanes;
var pendingPassiveHookEffectsMount = [];
var pendingPassiveHookEffectsUnmount = [];
var rootsWithPendingDiscreteUpdates = null; // Use these to prevent an infinite loop of nested updates
var NESTED_UPDATE_LIMIT = 50;
var nestedUpdateCount = 0;
var rootWithNestedUpdates = null;
var NESTED_PASSIVE_UPDATE_LIMIT = 50;
var nestedPassiveUpdateCount = 0; // Marks the need to reschedule pending interactions at these lanes
// during the commit phase. This enables them to be traced across components
// that spawn new work during render. E.g. hidden boundaries, suspended SSR
// hydration or SuspenseList.
// TODO: Can use a bitmask instead of an array
var spawnedWorkDuringRender = null; // If two updates are scheduled within the same event, we should treat their
// event times as simultaneous, even if the actual clock time has advanced
// between the first and second call.
var currentEventTime = NoTimestamp;
var currentEventWipLanes = NoLanes;
var currentEventPendingLanes = NoLanes; // Dev only flag that tracks if passive effects are currently being flushed.
// We warn about state updates for unmounted components differently in this case.
var isFlushingPassiveEffects = false;
var focusedInstanceHandle = null;
var shouldFireAfterActiveInstanceBlur = false;
function getWorkInProgressRoot() {
return workInProgressRoot;
}
function requestEventTime() {
if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
// We're inside React, so it's fine to read the actual time.
return now();
} // We're not inside React, so we may be in the middle of a browser event.
if (currentEventTime !== NoTimestamp) {
// Use the same start time for all updates until we enter React again.
return currentEventTime;
} // This is the first update since React yielded. Compute a new start time.
currentEventTime = now();
return currentEventTime;
}
function requestUpdateLane(fiber) {
// Special cases
var mode = fiber.mode;
if ((mode & BlockingMode) === NoMode) {
return SyncLane;
} else if ((mode & ConcurrentMode) === NoMode) {
return getCurrentPriorityLevel() === ImmediatePriority$1
? SyncLane
: SyncBatchedLane;
} // The algorithm for assigning an update to a lane should be stable for all
// updates at the same priority within the same event. To do this, the inputs
// to the algorithm must be the same. For example, we use the `renderLanes`
// to avoid choosing a lane that is already in the middle of rendering.
//
// However, the "included" lanes could be mutated in between updates in the
// same event, like if you perform an update inside `flushSync`. Or any other
// code path that might call `prepareFreshStack`.
//
// The trick we use is to cache the first of each of these inputs within an
// event. Then reset the cached values once we can be sure the event is over.
// Our heuristic for that is whenever we enter a concurrent work loop.
//
// We'll do the same for `currentEventPendingLanes` below.
if (currentEventWipLanes === NoLanes) {
currentEventWipLanes = workInProgressRootIncludedLanes;
}
var isTransition = requestCurrentTransition() !== NoTransition;
if (isTransition) {
if (currentEventPendingLanes !== NoLanes) {
currentEventPendingLanes =
mostRecentlyUpdatedRoot !== null
? mostRecentlyUpdatedRoot.pendingLanes
: NoLanes;
}
return findTransitionLane(currentEventWipLanes, currentEventPendingLanes);
} // TODO: Remove this dependency on the Scheduler priority.
// To do that, we're replacing it with an update lane priority.
var schedulerPriority = getCurrentPriorityLevel(); // The old behavior was using the priority level of the Scheduler.
// This couples React to the Scheduler internals, so we're replacing it
// with the currentUpdateLanePriority above. As an example of how this
// could be problematic, if we're not inside `Scheduler.runWithPriority`,
// then we'll get the priority of the current running Scheduler task,
// which is probably not what we want.
var lane;
if (
// TODO: Temporary. We're removing the concept of discrete updates.
(executionContext & DiscreteEventContext) !== NoContext &&
schedulerPriority === UserBlockingPriority$2
) {
lane = findUpdateLane(InputDiscreteLanePriority, currentEventWipLanes);
} else {
var schedulerLanePriority =
schedulerPriorityToLanePriority(schedulerPriority);
lane = findUpdateLane(schedulerLanePriority, currentEventWipLanes);
}
return lane;
}
function requestRetryLane(fiber) {
// This is a fork of `requestUpdateLane` designed specifically for Suspense
// "retries" — a special update that attempts to flip a Suspense boundary
// from its placeholder state to its primary/resolved state.
// Special cases
var mode = fiber.mode;
if ((mode & BlockingMode) === NoMode) {
return SyncLane;
} else if ((mode & ConcurrentMode) === NoMode) {
return getCurrentPriorityLevel() === ImmediatePriority$1
? SyncLane
: SyncBatchedLane;
} // See `requestUpdateLane` for explanation of `currentEventWipLanes`
if (currentEventWipLanes === NoLanes) {
currentEventWipLanes = workInProgressRootIncludedLanes;
}
return findRetryLane(currentEventWipLanes);
}
function scheduleUpdateOnFiber(fiber, lane, eventTime) {
checkForNestedUpdates();
warnAboutRenderPhaseUpdatesInDEV(fiber);
var root = markUpdateLaneFromFiberToRoot(fiber, lane);
if (root === null) {
warnAboutUpdateOnUnmountedFiberInDEV(fiber);
return null;
} // Mark that the root has a pending update.
markRootUpdated(root, lane, eventTime);
if (root === workInProgressRoot) {
// Received an update to a tree that's in the middle of rendering. Mark
// that there was an interleaved update work on this root. Unless the
// `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
// phase update. In that case, we don't treat render phase updates as if
// they were interleaved, for backwards compat reasons.
{
workInProgressRootUpdatedLanes = mergeLanes(
workInProgressRootUpdatedLanes,
lane,
);
}
if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
// The root already suspended with a delay, which means this render
// definitely won't finish. Since we have a new update, let's mark it as
// suspended now, right before marking the incoming update. This has the
// effect of interrupting the current render and switching to the update.
// TODO: Make sure this doesn't override pings that happen while we've
// already started rendering.
markRootSuspended$1(root, workInProgressRootRenderLanes);
}
} // TODO: requestUpdateLanePriority also reads the priority. Pass the
// priority as an argument to that function and this one.
var priorityLevel = getCurrentPriorityLevel();
if (lane === SyncLane) {
if (
// Check if we're inside unbatchedUpdates
(executionContext & LegacyUnbatchedContext) !== NoContext && // Check if we're not already rendering
(executionContext & (RenderContext | CommitContext)) === NoContext
) {
// Register pending interactions on the root to avoid losing traced interaction data.
schedulePendingInteractions(root, lane); // This is a legacy edge case. The initial mount of a ReactDOM.render-ed
// root inside of batchedUpdates should be synchronous, but layout updates
// should be deferred until the end of the batch.
performSyncWorkOnRoot(root);
} else {
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, lane);
if (executionContext === NoContext) {
// Flush the synchronous work now, unless we're already working or inside
// a batch. This is intentionally inside scheduleUpdateOnFiber instead of
// scheduleCallbackForFiber to preserve the ability to schedule a callback
// without immediately flushing it. We only do this for user-initiated
// updates, to preserve historical behavior of legacy mode.
resetRenderTimer();
flushSyncCallbackQueue();
}
}
} else {
// Schedule a discrete update but only if it's not Sync.
if (
(executionContext & DiscreteEventContext) !== NoContext && // Only updates at user-blocking priority or greater are considered
// discrete, even inside a discrete event.
(priorityLevel === UserBlockingPriority$2 ||
priorityLevel === ImmediatePriority$1)
) {
// This is the result of a discrete event. Track the lowest priority
// discrete update per root so we can flush them early, if needed.
if (rootsWithPendingDiscreteUpdates === null) {
rootsWithPendingDiscreteUpdates = new Set([root]);
} else {
rootsWithPendingDiscreteUpdates.add(root);
}
} // Schedule other updates after in case the callback is sync.
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, lane);
} // We use this when assigning a lane for a transition inside
// `requestUpdateLane`. We assume it's the same as the root being updated,
// since in the common case of a single root app it probably is. If it's not
// the same root, then it's not a huge deal, we just might batch more stuff
// together more than necessary.
mostRecentlyUpdatedRoot = root;
} // This is split into a separate function so we can mark a fiber with pending
// work without treating it as a typical update that originates from an event;
// e.g. retrying a Suspense boundary isn't an update, but it does schedule work
// on a fiber.
function markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
// Update the source fiber's lanes
sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
var alternate = sourceFiber.alternate;
if (alternate !== null) {
alternate.lanes = mergeLanes(alternate.lanes, lane);
}
{
if (
alternate === null &&
(sourceFiber.flags & (Placement | Hydrating)) !== NoFlags
) {
warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
}
} // Walk the parent path to the root and update the child expiration time.
var node = sourceFiber;
var parent = sourceFiber.return;
while (parent !== null) {
parent.childLanes = mergeLanes(parent.childLanes, lane);
alternate = parent.alternate;
if (alternate !== null) {
alternate.childLanes = mergeLanes(alternate.childLanes, lane);
} else {
{
if ((parent.flags & (Placement | Hydrating)) !== NoFlags) {
warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
}
}
}
node = parent;
parent = parent.return;
}
if (node.tag === HostRoot) {
var root = node.stateNode;
return root;
} else {
return null;
}
} // Use this function to schedule a task for a root. There's only one task per
// root; if a task was already scheduled, we'll check to make sure the priority
// of the existing task is the same as the priority of the next level that the
// root has work on. This function is called on every update, and right before
// exiting a task.
function ensureRootIsScheduled(root, currentTime) {
var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
// expired so we know to work on those next.
markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
var nextLanes = getNextLanes(
root,
root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes,
); // This returns the priority level computed during the `getNextLanes` call.
var newCallbackPriority = returnNextLanesPriority();
if (nextLanes === NoLanes) {
// Special case: There's nothing to work on.
if (existingCallbackNode !== null) {
cancelCallback(existingCallbackNode);
root.callbackNode = null;
root.callbackPriority = NoLanePriority;
}
return;
} // Check if there's an existing task. We may be able to reuse it.
if (existingCallbackNode !== null) {
var existingCallbackPriority = root.callbackPriority;
if (existingCallbackPriority === newCallbackPriority) {
// The priority hasn't changed. We can reuse the existing task. Exit.
return;
} // The priority changed. Cancel the existing callback. We'll schedule a new
// one below.
cancelCallback(existingCallbackNode);
} // Schedule a new callback.
var newCallbackNode;
if (newCallbackPriority === SyncLanePriority) {
// Special case: Sync React callbacks are scheduled on a special
// internal queue
newCallbackNode = scheduleSyncCallback(
performSyncWorkOnRoot.bind(null, root),
);
} else if (newCallbackPriority === SyncBatchedLanePriority) {
newCallbackNode = scheduleCallback(
ImmediatePriority$1,
performSyncWorkOnRoot.bind(null, root),
);
} else {
var schedulerPriorityLevel =
lanePriorityToSchedulerPriority(newCallbackPriority);
newCallbackNode = scheduleCallback(
schedulerPriorityLevel,
performConcurrentWorkOnRoot.bind(null, root),
);
}
root.callbackPriority = newCallbackPriority;
root.callbackNode = newCallbackNode;
} // This is the entry point for every concurrent task, i.e. anything that
// goes through Scheduler.
function performConcurrentWorkOnRoot(root) {
// Since we know we're in a React event, we can clear the current
// event time. The next update will compute a new event time.
currentEventTime = NoTimestamp;
currentEventWipLanes = NoLanes;
currentEventPendingLanes = NoLanes;
if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
{
throw Error("Should not already be working.");
}
} // Flush any pending passive effects before deciding which lanes to work on,
// in case they schedule additional work.
var originalCallbackNode = root.callbackNode;
var didFlushPassiveEffects = flushPassiveEffects();
if (didFlushPassiveEffects) {
// Something in the passive effect phase may have canceled the current task.
// Check if the task node for this root was changed.
if (root.callbackNode !== originalCallbackNode) {
// The current task was canceled. Exit. We don't need to call
// `ensureRootIsScheduled` because the check above implies either that
// there's a new task, or that there's no remaining work on this root.
return null;
}
} // Determine the next expiration time to work on, using the fields stored
// on the root.
var lanes = getNextLanes(
root,
root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes,
);
if (lanes === NoLanes) {
// Defensive coding. This is never expected to happen.
return null;
}
var exitStatus = renderRootConcurrent(root, lanes);
if (
includesSomeLane(
workInProgressRootIncludedLanes,
workInProgressRootUpdatedLanes,
)
) {
// The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// So we'll throw out the current work and restart.
prepareFreshStack(root, NoLanes);
} else if (exitStatus !== RootIncomplete) {
if (exitStatus === RootErrored) {
executionContext |= RetryAfterError; // If an error occurred during hydration,
// discard server response and fall back to client side render.
if (root.hydrate) {
root.hydrate = false;
clearContainer(root.containerInfo);
} // If something threw an error, try rendering one more time. We'll render
// synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
lanes = getLanesToRetrySynchronouslyOnError(root);
if (lanes !== NoLanes) {
exitStatus = renderRootSync(root, lanes);
}
}
if (exitStatus === RootFatalErrored) {
var fatalError = workInProgressRootFatalError;
prepareFreshStack(root, NoLanes);
markRootSuspended$1(root, lanes);
ensureRootIsScheduled(root, now());
throw fatalError;
} // We now have a consistent tree. The next step is either to commit it,
// or, if something suspended, wait to commit it after a timeout.
var finishedWork = root.current.alternate;
root.finishedWork = finishedWork;
root.finishedLanes = lanes;
finishConcurrentRender(root, exitStatus, lanes);
}
ensureRootIsScheduled(root, now());
if (root.callbackNode === originalCallbackNode) {
// The task node scheduled for this root is the same one that's
// currently executed. Need to return a continuation.
return performConcurrentWorkOnRoot.bind(null, root);
}
return null;
}
function finishConcurrentRender(root, exitStatus, lanes) {
switch (exitStatus) {
case RootIncomplete:
case RootFatalErrored: {
{
{
throw Error("Root did not complete. This is a bug in React.");
}
}
}
// Flow knows about invariant, so it complains if I add a break
// statement, but eslint doesn't know about invariant, so it complains
// if I do. eslint-disable-next-line no-fallthrough
case RootErrored: {
// We should have already attempted to retry this tree. If we reached
// this point, it errored again. Commit it.
commitRoot(root);
break;
}
case RootSuspended: {
markRootSuspended$1(root, lanes); // We have an acceptable loading state. We need to figure out if we
// should immediately commit it or wait a bit.
if (
includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
!shouldForceFlushFallbacksInDEV()
) {
// This render only included retries, no updates. Throttle committing
// retries so that we don't show too many loading states too quickly.
var msUntilTimeout =
globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.
if (msUntilTimeout > 10) {
var nextLanes = getNextLanes(root, NoLanes);
if (nextLanes !== NoLanes) {
// There's additional work on this root.
break;
}
var suspendedLanes = root.suspendedLanes;
if (!isSubsetOfLanes(suspendedLanes, lanes)) {
// We should prefer to render the fallback of at the last
// suspended level. Ping the last suspended level to try
// rendering it again.
// FIXME: What if the suspended lanes are Idle? Should not restart.
var eventTime = requestEventTime();
markRootPinged(root, suspendedLanes);
break;
} // The render is suspended, it hasn't timed out, and there's no
// lower priority work to do. Instead of committing the fallback
// immediately, wait for more data to arrive.
root.timeoutHandle = scheduleTimeout(
commitRoot.bind(null, root),
msUntilTimeout,
);
break;
}
} // The work expired. Commit immediately.
commitRoot(root);
break;
}
case RootSuspendedWithDelay: {
markRootSuspended$1(root, lanes);
if (includesOnlyTransitions(lanes)) {
// This is a transition, so we should exit without committing a
// placeholder and without scheduling a timeout. Delay indefinitely
// until we receive more data.
break;
}
if (!shouldForceFlushFallbacksInDEV()) {
// This is not a transition, but we did trigger an avoided state.
// Schedule a placeholder to display after a short delay, using the Just
// Noticeable Difference.
// TODO: Is the JND optimization worth the added complexity? If this is
// the only reason we track the event time, then probably not.
// Consider removing.
var mostRecentEventTime = getMostRecentEventTime(root, lanes);
var eventTimeMs = mostRecentEventTime;
var timeElapsedMs = now() - eventTimeMs;
var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
if (_msUntilTimeout > 10) {
// Instead of committing the fallback immediately, wait for more data
// to arrive.
root.timeoutHandle = scheduleTimeout(
commitRoot.bind(null, root),
_msUntilTimeout,
);
break;
}
} // Commit the placeholder.
commitRoot(root);
break;
}
case RootCompleted: {
// The work completed. Ready to commit.
commitRoot(root);
break;
}
default: {
{
{
throw Error("Unknown root exit status.");
}
}
}
}
}
function markRootSuspended$1(root, suspendedLanes) {
// When suspending, we should always exclude lanes that were pinged or (more
// rarely, since we try to avoid it) updated during the render phase.
// TODO: Lol maybe there's a better way to factor this besides this
// obnoxiously named function :)
suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
suspendedLanes = removeLanes(
suspendedLanes,
workInProgressRootUpdatedLanes,
);
markRootSuspended(root, suspendedLanes);
} // This is the entry point for synchronous tasks that don't go
// through Scheduler
function performSyncWorkOnRoot(root) {
if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
{
throw Error("Should not already be working.");
}
}
flushPassiveEffects();
var lanes;
var exitStatus;
if (
root === workInProgressRoot &&
includesSomeLane(root.expiredLanes, workInProgressRootRenderLanes)
) {
// There's a partial tree, and at least one of its lanes has expired. Finish
// rendering it before rendering the rest of the expired work.
lanes = workInProgressRootRenderLanes;
exitStatus = renderRootSync(root, lanes);
if (
includesSomeLane(
workInProgressRootIncludedLanes,
workInProgressRootUpdatedLanes,
)
) {
// The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// Note that this only happens when part of the tree is rendered
// concurrently. If the whole tree is rendered synchronously, then there
// are no interleaved events.
lanes = getNextLanes(root, lanes);
exitStatus = renderRootSync(root, lanes);
}
} else {
lanes = getNextLanes(root, NoLanes);
exitStatus = renderRootSync(root, lanes);
}
if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
executionContext |= RetryAfterError; // If an error occurred during hydration,
// discard server response and fall back to client side render.
if (root.hydrate) {
root.hydrate = false;
clearContainer(root.containerInfo);
} // If something threw an error, try rendering one more time. We'll render
// synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
lanes = getLanesToRetrySynchronouslyOnError(root);
if (lanes !== NoLanes) {
exitStatus = renderRootSync(root, lanes);
}
}
if (exitStatus === RootFatalErrored) {
var fatalError = workInProgressRootFatalError;
prepareFreshStack(root, NoLanes);
markRootSuspended$1(root, lanes);
ensureRootIsScheduled(root, now());
throw fatalError;
} // We now have a consistent tree. Because this is a sync render, we
// will commit it even if something suspended.
var finishedWork = root.current.alternate;
root.finishedWork = finishedWork;
root.finishedLanes = lanes;
commitRoot(root); // Before exiting, make sure there's a callback scheduled for the next
// pending level.
ensureRootIsScheduled(root, now());
return null;
}
function flushDiscreteUpdates() {
// TODO: Should be able to flush inside batchedUpdates, but not inside `act`.
// However, `act` uses `batchedUpdates`, so there's no way to distinguish
// those two cases. Need to fix this before exposing flushDiscreteUpdates
// as a public API.
if (
(executionContext & (BatchedContext | RenderContext | CommitContext)) !==
NoContext
) {
{
if ((executionContext & RenderContext) !== NoContext) {
error(
"unstable_flushDiscreteUpdates: Cannot flush updates when React is " +
"already rendering.",
);
}
} // We're already rendering, so we can't synchronously flush pending work.
// This is probably a nested event dispatch triggered by a lifecycle/effect,
// like `el.focus()`. Exit.
return;
}
flushPendingDiscreteUpdates(); // If the discrete updates scheduled passive effects, flush them now so that
// they fire before the next serial event.
flushPassiveEffects();
}
function flushPendingDiscreteUpdates() {
if (rootsWithPendingDiscreteUpdates !== null) {
// For each root with pending discrete updates, schedule a callback to
// immediately flush them.
var roots = rootsWithPendingDiscreteUpdates;
rootsWithPendingDiscreteUpdates = null;
roots.forEach(function (root) {
markDiscreteUpdatesExpired(root);
ensureRootIsScheduled(root, now());
});
} // Now flush the immediate queue.
flushSyncCallbackQueue();
}
function batchedUpdates$1(fn, a) {
var prevExecutionContext = executionContext;
executionContext |= BatchedContext;
try {
return fn(a);
} finally {
executionContext = prevExecutionContext;
if (executionContext === NoContext) {
// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();
flushSyncCallbackQueue();
}
}
}
function batchedEventUpdates$1(fn, a) {
var prevExecutionContext = executionContext;
executionContext |= EventContext;
try {
return fn(a);
} finally {
executionContext = prevExecutionContext;
if (executionContext === NoContext) {
// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();
flushSyncCallbackQueue();
}
}
}
function discreteUpdates$1(fn, a, b, c, d) {
var prevExecutionContext = executionContext;
executionContext |= DiscreteEventContext;
{
try {
return runWithPriority$1(
UserBlockingPriority$2,
fn.bind(null, a, b, c, d),
);
} finally {
executionContext = prevExecutionContext;
if (executionContext === NoContext) {
// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();
flushSyncCallbackQueue();
}
}
}
}
function unbatchedUpdates(fn, a) {
var prevExecutionContext = executionContext;
executionContext &= ~BatchedContext;
executionContext |= LegacyUnbatchedContext;
try {
return fn(a);
} finally {
executionContext = prevExecutionContext;
if (executionContext === NoContext) {
// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer();
flushSyncCallbackQueue();
}
}
}
function flushSync(fn, a) {
var prevExecutionContext = executionContext;
if (
(prevExecutionContext & (RenderContext | CommitContext)) !==
NoContext
) {
{
error(
"flushSync was called from inside a lifecycle method. React cannot " +
"flush when React is already rendering. Consider moving this call to " +
"a scheduler task or micro task.",
);
}
return fn(a);
}
executionContext |= BatchedContext;
{
try {
if (fn) {
return runWithPriority$1(ImmediatePriority$1, fn.bind(null, a));
} else {
return undefined;
}
} finally {
executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
// Note that this will happen even if batchedUpdates is higher up
// the stack.
flushSyncCallbackQueue();
}
}
}
function pushRenderLanes(fiber, lanes) {
push(subtreeRenderLanesCursor, subtreeRenderLanes, fiber);
subtreeRenderLanes = mergeLanes(subtreeRenderLanes, lanes);
workInProgressRootIncludedLanes = mergeLanes(
workInProgressRootIncludedLanes,
lanes,
);
}
function popRenderLanes(fiber) {
subtreeRenderLanes = subtreeRenderLanesCursor.current;
pop(subtreeRenderLanesCursor, fiber);
}
function prepareFreshStack(root, lanes) {
root.finishedWork = null;
root.finishedLanes = NoLanes;
var timeoutHandle = root.timeoutHandle;
if (timeoutHandle !== noTimeout) {
// The root previous suspended and scheduled a timeout to commit a fallback
// state. Now that we have additional work, cancel the timeout.
root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
cancelTimeout(timeoutHandle);
}
if (workInProgress !== null) {
var interruptedWork = workInProgress.return;
while (interruptedWork !== null) {
unwindInterruptedWork(interruptedWork);
interruptedWork = interruptedWork.return;
}
}
workInProgressRoot = root;
workInProgress = createWorkInProgress(root.current, null);
workInProgressRootRenderLanes =
subtreeRenderLanes =
workInProgressRootIncludedLanes =
lanes;
workInProgressRootExitStatus = RootIncomplete;
workInProgressRootFatalError = null;
workInProgressRootSkippedLanes = NoLanes;
workInProgressRootUpdatedLanes = NoLanes;
workInProgressRootPingedLanes = NoLanes;
{
spawnedWorkDuringRender = null;
}
{
ReactStrictModeWarnings.discardPendingWarnings();
}
}
function handleError(root, thrownValue) {
do {
var erroredWork = workInProgress;
try {
// Reset module-level state that was set during the render phase.
resetContextDependencies();
resetHooksAfterThrow();
resetCurrentFiber(); // TODO: I found and added this missing line while investigating a
// separate issue. Write a regression test using string refs.
ReactCurrentOwner$2.current = null;
if (erroredWork === null || erroredWork.return === null) {
// Expected to be working on a non-root fiber. This is a fatal error
// because there's no ancestor that can handle it; the root is
// supposed to capture all errors that weren't caught by an error
// boundary.
workInProgressRootExitStatus = RootFatalErrored;
workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
// sibling, or the parent if there are no siblings. But since the root
// has no siblings nor a parent, we set it to null. Usually this is
// handled by `completeUnitOfWork` or `unwindWork`, but since we're
// intentionally not calling those, we need set it here.
// TODO: Consider calling `unwindWork` to pop the contexts.
workInProgress = null;
return;
}
if (enableProfilerTimer && erroredWork.mode & ProfileMode) {
// Record the time spent rendering before an error was thrown. This
// avoids inaccurate Profiler durations in the case of a
// suspended render.
stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
}
throwException(
root,
erroredWork.return,
erroredWork,
thrownValue,
workInProgressRootRenderLanes,
);
completeUnitOfWork(erroredWork);
} catch (yetAnotherThrownValue) {
// Something in the return path also threw.
thrownValue = yetAnotherThrownValue;
if (workInProgress === erroredWork && erroredWork !== null) {
// If this boundary has already errored, then we had trouble processing
// the error. Bubble it to the next boundary.
erroredWork = erroredWork.return;
workInProgress = erroredWork;
} else {
erroredWork = workInProgress;
}
continue;
} // Return to the normal work loop.
return;
} while (true);
}
function pushDispatcher() {
var prevDispatcher = ReactCurrentDispatcher$2.current;
ReactCurrentDispatcher$2.current = ContextOnlyDispatcher;
if (prevDispatcher === null) {
// The React isomorphic package does not include a default dispatcher.
// Instead the first renderer will lazily attach one, in order to give
// nicer error messages.
return ContextOnlyDispatcher;
} else {
return prevDispatcher;
}
}
function popDispatcher(prevDispatcher) {
ReactCurrentDispatcher$2.current = prevDispatcher;
}
function pushInteractions(root) {
{
var prevInteractions = __interactionsRef.current;
__interactionsRef.current = root.memoizedInteractions;
return prevInteractions;
}
}
function popInteractions(prevInteractions) {
{
__interactionsRef.current = prevInteractions;
}
}
function markCommitTimeOfFallback() {
globalMostRecentFallbackTime = now();
}
function markSkippedUpdateLanes(lane) {
workInProgressRootSkippedLanes = mergeLanes(
lane,
workInProgressRootSkippedLanes,
);
}
function renderDidSuspend() {
if (workInProgressRootExitStatus === RootIncomplete) {
workInProgressRootExitStatus = RootSuspended;
}
}
function renderDidSuspendDelayIfPossible() {
if (
workInProgressRootExitStatus === RootIncomplete ||
workInProgressRootExitStatus === RootSuspended
) {
workInProgressRootExitStatus = RootSuspendedWithDelay;
} // Check if there are updates that we skipped tree that might have unblocked
// this render.
if (
workInProgressRoot !== null &&
(includesNonIdleWork(workInProgressRootSkippedLanes) ||
includesNonIdleWork(workInProgressRootUpdatedLanes))
) {
// Mark the current render as suspended so that we switch to working on
// the updates that were skipped. Usually we only suspend at the end of
// the render phase.
// TODO: We should probably always mark the root as suspended immediately
// (inside this function), since by suspending at the end of the render
// phase introduces a potential mistake where we suspend lanes that were
// pinged or updated while we were rendering.
markRootSuspended$1(workInProgressRoot, workInProgressRootRenderLanes);
}
}
function renderDidError() {
if (workInProgressRootExitStatus !== RootCompleted) {
workInProgressRootExitStatus = RootErrored;
}
} // Called during render to determine if anything has suspended.
// Returns false if we're not sure.
function renderHasNotSuspendedYet() {
// If something errored or completed, we can't really be sure,
// so those are false.
return workInProgressRootExitStatus === RootIncomplete;
}
function renderRootSync(root, lanes) {
var prevExecutionContext = executionContext;
executionContext |= RenderContext;
var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
// and prepare a fresh one. Otherwise we'll continue where we left off.
if (
workInProgressRoot !== root ||
workInProgressRootRenderLanes !== lanes
) {
prepareFreshStack(root, lanes);
startWorkOnPendingInteractions(root, lanes);
}
var prevInteractions = pushInteractions(root);
do {
try {
workLoopSync();
break;
} catch (thrownValue) {
handleError(root, thrownValue);
}
} while (true);
resetContextDependencies();
{
popInteractions(prevInteractions);
}
executionContext = prevExecutionContext;
popDispatcher(prevDispatcher);
if (workInProgress !== null) {
// This is a sync render, so we should have finished the whole tree.
{
{
throw Error(
"Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.",
);
}
}
}
workInProgressRoot = null;
workInProgressRootRenderLanes = NoLanes;
return workInProgressRootExitStatus;
} // The work loop is an extremely hot path. Tell Closure not to inline it.
/** @noinline */
function workLoopSync() {
// Already timed out, so perform work without checking if we need to yield.
while (workInProgress !== null) {
performUnitOfWork(workInProgress);
}
}
function renderRootConcurrent(root, lanes) {
var prevExecutionContext = executionContext;
executionContext |= RenderContext;
var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
// and prepare a fresh one. Otherwise we'll continue where we left off.
if (
workInProgressRoot !== root ||
workInProgressRootRenderLanes !== lanes
) {
resetRenderTimer();
prepareFreshStack(root, lanes);
startWorkOnPendingInteractions(root, lanes);
}
var prevInteractions = pushInteractions(root);
do {
try {
workLoopConcurrent();
break;
} catch (thrownValue) {
handleError(root, thrownValue);
}
} while (true);
resetContextDependencies();
{
popInteractions(prevInteractions);
}
popDispatcher(prevDispatcher);
executionContext = prevExecutionContext;
if (workInProgress !== null) {
return RootIncomplete;
} else {
workInProgressRoot = null;
workInProgressRootRenderLanes = NoLanes; // Return the final exit status.
return workInProgressRootExitStatus;
}
}
/** @noinline */
function workLoopConcurrent() {
// Perform work until Scheduler asks us to yield
while (workInProgress !== null && !shouldYield()) {
performUnitOfWork(workInProgress);
}
}
function performUnitOfWork(unitOfWork) {
// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
var current = unitOfWork.alternate;
setCurrentFiber(unitOfWork);
var next;
if ((unitOfWork.mode & ProfileMode) !== NoMode) {
startProfilerTimer(unitOfWork);
next = beginWork$1(current, unitOfWork, subtreeRenderLanes);
stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
} else {
next = beginWork$1(current, unitOfWork, subtreeRenderLanes);
}
resetCurrentFiber();
unitOfWork.memoizedProps = unitOfWork.pendingProps;
if (next === null) {
// If this doesn't spawn new work, complete the current work.
completeUnitOfWork(unitOfWork);
} else {
workInProgress = next;
}
ReactCurrentOwner$2.current = null;
}
function completeUnitOfWork(unitOfWork) {
// Attempt to complete the current unit of work, then move to the next
// sibling. If there are no more siblings, return to the parent fiber.
var completedWork = unitOfWork;
do {
// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
var current = completedWork.alternate;
var returnFiber = completedWork.return; // Check if the work completed or if something threw.
if ((completedWork.flags & Incomplete) === NoFlags) {
setCurrentFiber(completedWork);
var next = void 0;
if ((completedWork.mode & ProfileMode) === NoMode) {
next = completeWork(current, completedWork, subtreeRenderLanes);
} else {
startProfilerTimer(completedWork);
next = completeWork(current, completedWork, subtreeRenderLanes); // Update render duration assuming we didn't error.
stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
}
resetCurrentFiber();
if (next !== null) {
// Completing this fiber spawned new work. Work on that next.
workInProgress = next;
return;
}
resetChildLanes(completedWork);
if (
returnFiber !== null && // Do not append effects to parents if a sibling failed to complete
(returnFiber.flags & Incomplete) === NoFlags
) {
// Append all the effects of the subtree and this fiber onto the effect
// list of the parent. The completion order of the children affects the
// side-effect order.
if (returnFiber.firstEffect === null) {
returnFiber.firstEffect = completedWork.firstEffect;
}
if (completedWork.lastEffect !== null) {
if (returnFiber.lastEffect !== null) {
returnFiber.lastEffect.nextEffect = completedWork.firstEffect;
}
returnFiber.lastEffect = completedWork.lastEffect;
} // If this fiber had side-effects, we append it AFTER the children's
// side-effects. We can perform certain side-effects earlier if needed,
// by doing multiple passes over the effect list. We don't want to
// schedule our own side-effect on our own list because if end up
// reusing children we'll schedule this effect onto itself since we're
// at the end.
var flags = completedWork.flags; // Skip both NoWork and PerformedWork tags when creating the effect
// list. PerformedWork effect is read by React DevTools but shouldn't be
// committed.
if (flags > PerformedWork) {
if (returnFiber.lastEffect !== null) {
returnFiber.lastEffect.nextEffect = completedWork;
} else {
returnFiber.firstEffect = completedWork;
}
returnFiber.lastEffect = completedWork;
}
}
} else {
// This fiber did not complete because something threw. Pop values off
// the stack without entering the complete phase. If this is a boundary,
// capture values if possible.
var _next = unwindWork(completedWork); // Because this fiber did not complete, don't reset its expiration time.
if (_next !== null) {
// If completing this work spawned new work, do that next. We'll come
// back here again.
// Since we're restarting, remove anything that is not a host effect
// from the effect tag.
_next.flags &= HostEffectMask;
workInProgress = _next;
return;
}
if ((completedWork.mode & ProfileMode) !== NoMode) {
// Record the render duration for the fiber that errored.
stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
var actualDuration = completedWork.actualDuration;
var child = completedWork.child;
while (child !== null) {
actualDuration += child.actualDuration;
child = child.sibling;
}
completedWork.actualDuration = actualDuration;
}
if (returnFiber !== null) {
// Mark the parent fiber as incomplete and clear its effect list.
returnFiber.firstEffect = returnFiber.lastEffect = null;
returnFiber.flags |= Incomplete;
}
}
var siblingFiber = completedWork.sibling;
if (siblingFiber !== null) {
// If there is more work to do in this returnFiber, do that next.
workInProgress = siblingFiber;
return;
} // Otherwise, return to the parent
completedWork = returnFiber; // Update the next thing we're working on in case something throws.
workInProgress = completedWork;
} while (completedWork !== null); // We've reached the root.
if (workInProgressRootExitStatus === RootIncomplete) {
workInProgressRootExitStatus = RootCompleted;
}
}
function resetChildLanes(completedWork) {
if (
// TODO: Move this check out of the hot path by moving `resetChildLanes`
// to switch statement in `completeWork`.
(completedWork.tag === LegacyHiddenComponent ||
completedWork.tag === OffscreenComponent) &&
completedWork.memoizedState !== null &&
!includesSomeLane(subtreeRenderLanes, OffscreenLane) &&
(completedWork.mode & ConcurrentMode) !== NoLanes
) {
// The children of this component are hidden. Don't bubble their
// expiration times.
return;
}
var newChildLanes = NoLanes; // Bubble up the earliest expiration time.
if ((completedWork.mode & ProfileMode) !== NoMode) {
// In profiling mode, resetChildExpirationTime is also used to reset
// profiler durations.
var actualDuration = completedWork.actualDuration;
var treeBaseDuration = completedWork.selfBaseDuration; // When a fiber is cloned, its actualDuration is reset to 0. This value will
// only be updated if work is done on the fiber (i.e. it doesn't bailout).
// When work is done, it should bubble to the parent's actualDuration. If
// the fiber has not been cloned though, (meaning no work was done), then
// this value will reflect the amount of time spent working on a previous
// render. In that case it should not bubble. We determine whether it was
// cloned by comparing the child pointer.
var shouldBubbleActualDurations =
completedWork.alternate === null ||
completedWork.child !== completedWork.alternate.child;
var child = completedWork.child;
while (child !== null) {
newChildLanes = mergeLanes(
newChildLanes,
mergeLanes(child.lanes, child.childLanes),
);
if (shouldBubbleActualDurations) {
actualDuration += child.actualDuration;
}
treeBaseDuration += child.treeBaseDuration;
child = child.sibling;
}
var isTimedOutSuspense =
completedWork.tag === SuspenseComponent &&
completedWork.memoizedState !== null;
if (isTimedOutSuspense) {
// Don't count time spent in a timed out Suspense subtree as part of the base duration.
var primaryChildFragment = completedWork.child;
if (primaryChildFragment !== null) {
treeBaseDuration -= primaryChildFragment.treeBaseDuration;
}
}
completedWork.actualDuration = actualDuration;
completedWork.treeBaseDuration = treeBaseDuration;
} else {
var _child = completedWork.child;
while (_child !== null) {
newChildLanes = mergeLanes(
newChildLanes,
mergeLanes(_child.lanes, _child.childLanes),
);
_child = _child.sibling;
}
}
completedWork.childLanes = newChildLanes;
}
function commitRoot(root) {
var renderPriorityLevel = getCurrentPriorityLevel();
runWithPriority$1(
ImmediatePriority$1,
commitRootImpl.bind(null, root, renderPriorityLevel),
);
return null;
}
function commitRootImpl(root, renderPriorityLevel) {
do {
// `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
// means `flushPassiveEffects` will sometimes result in additional
// passive effects. So we need to keep flushing in a loop until there are
// no more pending effects.
// TODO: Might be better if `flushPassiveEffects` did not automatically
// flush synchronous work at the end, to avoid factoring hazards like this.
flushPassiveEffects();
} while (rootWithPendingPassiveEffects !== null);
flushRenderPhaseStrictModeWarningsInDEV();
if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
{
throw Error("Should not already be working.");
}
}
var finishedWork = root.finishedWork;
var lanes = root.finishedLanes;
if (finishedWork === null) {
return null;
}
root.finishedWork = null;
root.finishedLanes = NoLanes;
if (!(finishedWork !== root.current)) {
{
throw Error(
"Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.",
);
}
} // commitRoot never returns a continuation; it always finishes synchronously.
// So we can clear these now to allow a new callback to be scheduled.
root.callbackNode = null; // Update the first and last pending times on this root. The new first
// pending time is whatever is left on the root fiber.
var remainingLanes = mergeLanes(
finishedWork.lanes,
finishedWork.childLanes,
);
markRootFinished(root, remainingLanes); // Clear already finished discrete updates in case that a later call of
// `flushDiscreteUpdates` starts a useless render pass which may cancels
// a scheduled timeout.
if (rootsWithPendingDiscreteUpdates !== null) {
if (
!hasDiscreteLanes(remainingLanes) &&
rootsWithPendingDiscreteUpdates.has(root)
) {
rootsWithPendingDiscreteUpdates.delete(root);
}
}
if (root === workInProgressRoot) {
// We can reset these now that they are finished.
workInProgressRoot = null;
workInProgress = null;
workInProgressRootRenderLanes = NoLanes;
} // Get the list of effects.
var firstEffect;
if (finishedWork.flags > PerformedWork) {
// A fiber's effect list consists only of its children, not itself. So if
// the root has an effect, we need to add it to the end of the list. The
// resulting list is the set that would belong to the root's parent, if it
// had one; that is, all the effects in the tree including the root.
if (finishedWork.lastEffect !== null) {
finishedWork.lastEffect.nextEffect = finishedWork;
firstEffect = finishedWork.firstEffect;
} else {
firstEffect = finishedWork;
}
} else {
// There is no effect on the root.
firstEffect = finishedWork.firstEffect;
}
if (firstEffect !== null) {
var prevExecutionContext = executionContext;
executionContext |= CommitContext;
var prevInteractions = pushInteractions(root); // Reset this to null before calling lifecycles
ReactCurrentOwner$2.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
// of the effect list for each phase: all mutation effects come before all
// layout effects, and so on.
// The first phase a "before mutation" phase. We use this phase to read the
// state of the host tree right before we mutate it. This is where
// getSnapshotBeforeUpdate is called.
focusedInstanceHandle = prepareForCommit(root.containerInfo);
shouldFireAfterActiveInstanceBlur = false;
nextEffect = firstEffect;
do {
{
invokeGuardedCallback(null, commitBeforeMutationEffects, null);
if (hasCaughtError()) {
if (!(nextEffect !== null)) {
{
throw Error("Should be working on an effect.");
}
}
var error = clearCaughtError();
captureCommitPhaseError(nextEffect, error);
nextEffect = nextEffect.nextEffect;
}
}
} while (nextEffect !== null); // We no longer need to track the active instance fiber
focusedInstanceHandle = null;
{
// Mark the current commit time to be shared by all Profilers in this
// batch. This enables them to be grouped later.
recordCommitTime();
} // The next phase is the mutation phase, where we mutate the host tree.
nextEffect = firstEffect;
do {
{
invokeGuardedCallback(
null,
commitMutationEffects,
null,
root,
renderPriorityLevel,
);
if (hasCaughtError()) {
if (!(nextEffect !== null)) {
{
throw Error("Should be working on an effect.");
}
}
var _error = clearCaughtError();
captureCommitPhaseError(nextEffect, _error);
nextEffect = nextEffect.nextEffect;
}
}
} while (nextEffect !== null);
resetAfterCommit(root.containerInfo); // The work-in-progress tree is now the current tree. This must come after
// the mutation phase, so that the previous tree is still current during
// componentWillUnmount, but before the layout phase, so that the finished
// work is current during componentDidMount/Update.
root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
// the host tree after it's been mutated. The idiomatic use case for this is
// layout, but class component lifecycles also fire here for legacy reasons.
nextEffect = firstEffect;
do {
{
invokeGuardedCallback(null, commitLayoutEffects, null, root, lanes);
if (hasCaughtError()) {
if (!(nextEffect !== null)) {
{
throw Error("Should be working on an effect.");
}
}
var _error2 = clearCaughtError();
captureCommitPhaseError(nextEffect, _error2);
nextEffect = nextEffect.nextEffect;
}
}
} while (nextEffect !== null);
nextEffect = null; // Tell Scheduler to yield at the end of the frame, so the browser has an
// opportunity to paint.
requestPaint();
{
popInteractions(prevInteractions);
}
executionContext = prevExecutionContext;
} else {
// No effects.
root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
// no effects.
// TODO: Maybe there's a better way to report this.
{
recordCommitTime();
}
}
var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
if (rootDoesHavePassiveEffects) {
// This commit has passive effects. Stash a reference to them. But don't
// schedule a callback until after flushing layout work.
rootDoesHavePassiveEffects = false;
rootWithPendingPassiveEffects = root;
pendingPassiveEffectsLanes = lanes;
pendingPassiveEffectsRenderPriority = renderPriorityLevel;
} else {
// We are done with the effect chain at this point so let's clear the
// nextEffect pointers to assist with GC. If we have passive effects, we'll
// clear this in flushPassiveEffects.
nextEffect = firstEffect;
while (nextEffect !== null) {
var nextNextEffect = nextEffect.nextEffect;
nextEffect.nextEffect = null;
if (nextEffect.flags & Deletion) {
detachFiberAfterEffects(nextEffect);
}
nextEffect = nextNextEffect;
}
} // Read this again, since an effect might have updated it
remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
if (remainingLanes !== NoLanes) {
{
if (spawnedWorkDuringRender !== null) {
var expirationTimes = spawnedWorkDuringRender;
spawnedWorkDuringRender = null;
for (var i = 0; i < expirationTimes.length; i++) {
scheduleInteractions(
root,
expirationTimes[i],
root.memoizedInteractions,
);
}
}
schedulePendingInteractions(root, remainingLanes);
}
} else {
// If there's no remaining work, we can clear the set of already failed
// error boundaries.
legacyErrorBoundariesThatAlreadyFailed = null;
}
{
if (!rootDidHavePassiveEffects) {
// If there are no passive effects, then we can complete the pending interactions.
// Otherwise, we'll wait until after the passive effects are flushed.
// Wait to do this until after remaining work has been scheduled,
// so that we don't prematurely signal complete for interactions when there's e.g. hidden work.
finishPendingInteractions(root, lanes);
}
}
if (remainingLanes === SyncLane) {
// Count the number of times the root synchronously re-renders without
// finishing. If there are too many, it indicates an infinite update loop.
if (root === rootWithNestedUpdates) {
nestedUpdateCount++;
} else {
nestedUpdateCount = 0;
rootWithNestedUpdates = root;
}
} else {
nestedUpdateCount = 0;
}
onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
{
onCommitRoot$1();
} // Always call this before exiting `commitRoot`, to ensure that any
// additional work on this root is scheduled.
ensureRootIsScheduled(root, now());
if (hasUncaughtError) {
hasUncaughtError = false;
var _error3 = firstUncaughtError;
firstUncaughtError = null;
throw _error3;
}
if ((executionContext & LegacyUnbatchedContext) !== NoContext) {
// a ReactDOM.render-ed root inside of batchedUpdates. The commit fired
// synchronously, but layout updates should be deferred until the end
// of the batch.
return null;
} // If layout work was scheduled, flush it now.
flushSyncCallbackQueue();
return null;
}
function commitBeforeMutationEffects() {
while (nextEffect !== null) {
var current = nextEffect.alternate;
if (
!shouldFireAfterActiveInstanceBlur &&
focusedInstanceHandle !== null
) {
if ((nextEffect.flags & Deletion) !== NoFlags) {
if (doesFiberContain(nextEffect, focusedInstanceHandle)) {
shouldFireAfterActiveInstanceBlur = true;
}
} else {
// TODO: Move this out of the hot path using a dedicated effect tag.
if (
nextEffect.tag === SuspenseComponent &&
isSuspenseBoundaryBeingHidden(current, nextEffect) &&
doesFiberContain(nextEffect, focusedInstanceHandle)
) {
shouldFireAfterActiveInstanceBlur = true;
}
}
}
var flags = nextEffect.flags;
if ((flags & Snapshot) !== NoFlags) {
setCurrentFiber(nextEffect);
commitBeforeMutationLifeCycles(current, nextEffect);
resetCurrentFiber();
}
if ((flags & Passive) !== NoFlags) {
// If there are passive effects, schedule a callback to flush at
// the earliest opportunity.
if (!rootDoesHavePassiveEffects) {
rootDoesHavePassiveEffects = true;
scheduleCallback(NormalPriority$1, function () {
flushPassiveEffects();
return null;
});
}
}
nextEffect = nextEffect.nextEffect;
}
}
function commitMutationEffects(root, renderPriorityLevel) {
// TODO: Should probably move the bulk of this function to commitWork.
while (nextEffect !== null) {
setCurrentFiber(nextEffect);
var flags = nextEffect.flags;
if (flags & ContentReset) {
commitResetTextContent(nextEffect);
}
if (flags & Ref) {
var current = nextEffect.alternate;
if (current !== null) {
commitDetachRef(current);
}
} // The following switch statement is only concerned about placement,
// updates, and deletions. To avoid needing to add a case for every possible
// bitmap value, we remove the secondary effects from the effect tag and
// switch on that value.
var primaryFlags = flags & (Placement | Update | Deletion | Hydrating);
switch (primaryFlags) {
case Placement: {
commitPlacement(nextEffect); // Clear the "placement" from effect tag so that we know that this is
// inserted, before any life-cycles like componentDidMount gets called.
// TODO: findDOMNode doesn't rely on this any more but isMounted does
// and isMounted is deprecated anyway so we should be able to kill this.
nextEffect.flags &= ~Placement;
break;
}
case PlacementAndUpdate: {
// Placement
commitPlacement(nextEffect); // Clear the "placement" from effect tag so that we know that this is
// inserted, before any life-cycles like componentDidMount gets called.
nextEffect.flags &= ~Placement; // Update
var _current = nextEffect.alternate;
commitWork(_current, nextEffect);
break;
}
case Hydrating: {
nextEffect.flags &= ~Hydrating;
break;
}
case HydratingAndUpdate: {
nextEffect.flags &= ~Hydrating; // Update
var _current2 = nextEffect.alternate;
commitWork(_current2, nextEffect);
break;
}
case Update: {
var _current3 = nextEffect.alternate;
commitWork(_current3, nextEffect);
break;
}
case Deletion: {
commitDeletion(root, nextEffect);
break;
}
}
resetCurrentFiber();
nextEffect = nextEffect.nextEffect;
}
}
function commitLayoutEffects(root, committedLanes) {
while (nextEffect !== null) {
setCurrentFiber(nextEffect);
var flags = nextEffect.flags;
if (flags & (Update | Callback)) {
var current = nextEffect.alternate;
commitLifeCycles(root, current, nextEffect);
}
{
if (flags & Ref) {
commitAttachRef(nextEffect);
}
}
resetCurrentFiber();
nextEffect = nextEffect.nextEffect;
}
}
function flushPassiveEffects() {
// Returns whether passive effects were flushed.
if (pendingPassiveEffectsRenderPriority !== NoPriority$1) {
var priorityLevel =
pendingPassiveEffectsRenderPriority > NormalPriority$1
? NormalPriority$1
: pendingPassiveEffectsRenderPriority;
pendingPassiveEffectsRenderPriority = NoPriority$1;
{
return runWithPriority$1(priorityLevel, flushPassiveEffectsImpl);
}
}
return false;
}
function enqueuePendingPassiveHookEffectMount(fiber, effect) {
pendingPassiveHookEffectsMount.push(effect, fiber);
if (!rootDoesHavePassiveEffects) {
rootDoesHavePassiveEffects = true;
scheduleCallback(NormalPriority$1, function () {
flushPassiveEffects();
return null;
});
}
}
function enqueuePendingPassiveHookEffectUnmount(fiber, effect) {
pendingPassiveHookEffectsUnmount.push(effect, fiber);
{
fiber.flags |= PassiveUnmountPendingDev;
var alternate = fiber.alternate;
if (alternate !== null) {
alternate.flags |= PassiveUnmountPendingDev;
}
}
if (!rootDoesHavePassiveEffects) {
rootDoesHavePassiveEffects = true;
scheduleCallback(NormalPriority$1, function () {
flushPassiveEffects();
return null;
});
}
}
function invokePassiveEffectCreate(effect) {
var create = effect.create;
effect.destroy = create();
}
function flushPassiveEffectsImpl() {
if (rootWithPendingPassiveEffects === null) {
return false;
}
var root = rootWithPendingPassiveEffects;
var lanes = pendingPassiveEffectsLanes;
rootWithPendingPassiveEffects = null;
pendingPassiveEffectsLanes = NoLanes;
if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
{
throw Error("Cannot flush passive effects while already rendering.");
}
}
{
isFlushingPassiveEffects = true;
}
var prevExecutionContext = executionContext;
executionContext |= CommitContext;
var prevInteractions = pushInteractions(root); // It's important that ALL pending passive effect destroy functions are called
// before ANY passive effect create functions are called.
// Otherwise effects in sibling components might interfere with each other.
// e.g. a destroy function in one component may unintentionally override a ref
// value set by a create function in another component.
// Layout effects have the same constraint.
// First pass: Destroy stale passive effects.
var unmountEffects = pendingPassiveHookEffectsUnmount;
pendingPassiveHookEffectsUnmount = [];
for (var i = 0; i < unmountEffects.length; i += 2) {
var _effect = unmountEffects[i];
var fiber = unmountEffects[i + 1];
var destroy = _effect.destroy;
_effect.destroy = undefined;
{
fiber.flags &= ~PassiveUnmountPendingDev;
var alternate = fiber.alternate;
if (alternate !== null) {
alternate.flags &= ~PassiveUnmountPendingDev;
}
}
if (typeof destroy === "function") {
{
setCurrentFiber(fiber);
{
invokeGuardedCallback(null, destroy, null);
}
if (hasCaughtError()) {
if (!(fiber !== null)) {
{
throw Error("Should be working on an effect.");
}
}
var error = clearCaughtError();
captureCommitPhaseError(fiber, error);
}
resetCurrentFiber();
}
}
} // Second pass: Create new passive effects.
var mountEffects = pendingPassiveHookEffectsMount;
pendingPassiveHookEffectsMount = [];
for (var _i = 0; _i < mountEffects.length; _i += 2) {
var _effect2 = mountEffects[_i];
var _fiber = mountEffects[_i + 1];
{
setCurrentFiber(_fiber);
{
invokeGuardedCallback(
null,
invokePassiveEffectCreate,
null,
_effect2,
);
}
if (hasCaughtError()) {
if (!(_fiber !== null)) {
{
throw Error("Should be working on an effect.");
}
}
var _error4 = clearCaughtError();
captureCommitPhaseError(_fiber, _error4);
}
resetCurrentFiber();
}
} // Note: This currently assumes there are no passive effects on the root fiber
// because the root is not part of its own effect list.
// This could change in the future.
var effect = root.current.firstEffect;
while (effect !== null) {
var nextNextEffect = effect.nextEffect; // Remove nextEffect pointer to assist GC
effect.nextEffect = null;
if (effect.flags & Deletion) {
detachFiberAfterEffects(effect);
}
effect = nextNextEffect;
}
{
popInteractions(prevInteractions);
finishPendingInteractions(root, lanes);
}
{
isFlushingPassiveEffects = false;
}
executionContext = prevExecutionContext;
flushSyncCallbackQueue(); // If additional passive effects were scheduled, increment a counter. If this
// exceeds the limit, we'll fire a warning.
nestedPassiveUpdateCount =
rootWithPendingPassiveEffects === null ? 0 : nestedPassiveUpdateCount + 1;
return true;
}
function isAlreadyFailedLegacyErrorBoundary(instance) {
return (
legacyErrorBoundariesThatAlreadyFailed !== null &&
legacyErrorBoundariesThatAlreadyFailed.has(instance)
);
}
function markLegacyErrorBoundaryAsFailed(instance) {
if (legacyErrorBoundariesThatAlreadyFailed === null) {
legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
} else {
legacyErrorBoundariesThatAlreadyFailed.add(instance);
}
}
function prepareToThrowUncaughtError(error) {
if (!hasUncaughtError) {
hasUncaughtError = true;
firstUncaughtError = error;
}
}
var onUncaughtError = prepareToThrowUncaughtError;
function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
var errorInfo = createCapturedValue(error, sourceFiber);
var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
enqueueUpdate(rootFiber, update);
var eventTime = requestEventTime();
var root = markUpdateLaneFromFiberToRoot(rootFiber, SyncLane);
if (root !== null) {
markRootUpdated(root, SyncLane, eventTime);
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, SyncLane);
}
}
function captureCommitPhaseError(sourceFiber, error) {
if (sourceFiber.tag === HostRoot) {
// Error was thrown at the root. There is no parent, so the root
// itself should capture it.
captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
return;
}
var fiber = sourceFiber.return;
while (fiber !== null) {
if (fiber.tag === HostRoot) {
captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
return;
} else if (fiber.tag === ClassComponent) {
var ctor = fiber.type;
var instance = fiber.stateNode;
if (
typeof ctor.getDerivedStateFromError === "function" ||
(typeof instance.componentDidCatch === "function" &&
!isAlreadyFailedLegacyErrorBoundary(instance))
) {
var errorInfo = createCapturedValue(error, sourceFiber);
var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
enqueueUpdate(fiber, update);
var eventTime = requestEventTime();
var root = markUpdateLaneFromFiberToRoot(fiber, SyncLane);
if (root !== null) {
markRootUpdated(root, SyncLane, eventTime);
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, SyncLane);
} else {
// This component has already been unmounted.
// We can't schedule any follow up work for the root because the fiber is already unmounted,
// but we can still call the log-only boundary so the error isn't swallowed.
//
// TODO This is only a temporary bandaid for the old reconciler fork.
// We can delete this special case once the new fork is merged.
if (
typeof instance.componentDidCatch === "function" &&
!isAlreadyFailedLegacyErrorBoundary(instance)
) {
try {
instance.componentDidCatch(error, errorInfo);
} catch (errorToIgnore) {
// TODO Ignore this error? Rethrow it?
// This is kind of an edge case.
}
}
}
return;
}
}
fiber = fiber.return;
}
}
function pingSuspendedRoot(root, wakeable, pingedLanes) {
var pingCache = root.pingCache;
if (pingCache !== null) {
// The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
pingCache.delete(wakeable);
}
var eventTime = requestEventTime();
markRootPinged(root, pingedLanes);
if (
workInProgressRoot === root &&
isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
) {
// Received a ping at the same priority level at which we're currently
// rendering. We might want to restart this render. This should mirror
// the logic of whether or not a root suspends once it completes.
// TODO: If we're rendering sync either due to Sync, Batched or expired,
// we should probably never restart.
// If we're suspended with delay, or if it's a retry, we'll always suspend
// so we can always restart.
if (
workInProgressRootExitStatus === RootSuspendedWithDelay ||
(workInProgressRootExitStatus === RootSuspended &&
includesOnlyRetries(workInProgressRootRenderLanes) &&
now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
) {
// Restart from the root.
prepareFreshStack(root, NoLanes);
} else {
// Even though we can't restart right now, we might get an
// opportunity later. So we mark this render as having a ping.
workInProgressRootPingedLanes = mergeLanes(
workInProgressRootPingedLanes,
pingedLanes,
);
}
}
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, pingedLanes);
}
function retryTimedOutBoundary(boundaryFiber, retryLane) {
// The boundary fiber (a Suspense component or SuspenseList component)
// previously was rendered in its fallback state. One of the promises that
// suspended it has resolved, which means at least part of the tree was
// likely unblocked. Try rendering again, at a new expiration time.
if (retryLane === NoLane) {
retryLane = requestRetryLane(boundaryFiber);
} // TODO: Special case idle priority?
var eventTime = requestEventTime();
var root = markUpdateLaneFromFiberToRoot(boundaryFiber, retryLane);
if (root !== null) {
markRootUpdated(root, retryLane, eventTime);
ensureRootIsScheduled(root, eventTime);
schedulePendingInteractions(root, retryLane);
}
}
function resolveRetryWakeable(boundaryFiber, wakeable) {
var retryLane = NoLane; // Default
var retryCache;
{
retryCache = boundaryFiber.stateNode;
}
if (retryCache !== null) {
// The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
retryCache.delete(wakeable);
}
retryTimedOutBoundary(boundaryFiber, retryLane);
} // Computes the next Just Noticeable Difference (JND) boundary.
// The theory is that a person can't tell the difference between small differences in time.
// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
// difference in the experience. However, waiting for longer might mean that we can avoid
// showing an intermediate loading state. The longer we have already waited, the harder it
// is to tell small differences in time. Therefore, the longer we've already waited,
// the longer we can wait additionally. At some point we have to give up though.
// We pick a train model where the next boundary commits at a consistent schedule.
// These particular numbers are vague estimates. We expect to adjust them based on research.
function jnd(timeElapsed) {
return timeElapsed < 120
? 120
: timeElapsed < 480
? 480
: timeElapsed < 1080
? 1080
: timeElapsed < 1920
? 1920
: timeElapsed < 3000
? 3000
: timeElapsed < 4320
? 4320
: ceil(timeElapsed / 1960) * 1960;
}
function checkForNestedUpdates() {
if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
nestedUpdateCount = 0;
rootWithNestedUpdates = null;
{
{
throw Error(
"Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.",
);
}
}
}
{
if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
nestedPassiveUpdateCount = 0;
error(
"Maximum update depth exceeded. This can happen when a component " +
"calls setState inside useEffect, but useEffect either doesn't " +
"have a dependency array, or one of the dependencies changes on " +
"every render.",
);
}
}
}
function flushRenderPhaseStrictModeWarningsInDEV() {
{
ReactStrictModeWarnings.flushLegacyContextWarning();
{
ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
}
}
}
var didWarnStateUpdateForNotYetMountedComponent = null;
function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
{
if ((executionContext & RenderContext) !== NoContext) {
// We let the other warning about render phase updates deal with this one.
return;
}
if (!(fiber.mode & (BlockingMode | ConcurrentMode))) {
return;
}
var tag = fiber.tag;
if (
tag !== IndeterminateComponent &&
tag !== HostRoot &&
tag !== ClassComponent &&
tag !== FunctionComponent &&
tag !== ForwardRef &&
tag !== MemoComponent &&
tag !== SimpleMemoComponent &&
tag !== Block
) {
// Only warn for user-defined components, not internal ones like Suspense.
return;
} // We show the whole stack but dedupe on the top component's name because
// the problematic code almost always lies inside that component.
var componentName = getComponentName(fiber.type) || "ReactComponent";
if (didWarnStateUpdateForNotYetMountedComponent !== null) {
if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
return;
}
didWarnStateUpdateForNotYetMountedComponent.add(componentName);
} else {
didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
}
var previousFiber = current;
try {
setCurrentFiber(fiber);
error(
"Can't perform a React state update on a component that hasn't mounted yet. " +
"This indicates that you have a side-effect in your render function that " +
"asynchronously later calls tries to update the component. Move this work to " +
"useEffect instead.",
);
} finally {
if (previousFiber) {
setCurrentFiber(fiber);
} else {
resetCurrentFiber();
}
}
}
}
var didWarnStateUpdateForUnmountedComponent = null;
function warnAboutUpdateOnUnmountedFiberInDEV(fiber) {
{
var tag = fiber.tag;
if (
tag !== HostRoot &&
tag !== ClassComponent &&
tag !== FunctionComponent &&
tag !== ForwardRef &&
tag !== MemoComponent &&
tag !== SimpleMemoComponent &&
tag !== Block
) {
// Only warn for user-defined components, not internal ones like Suspense.
return;
} // If there are pending passive effects unmounts for this Fiber,
// we can assume that they would have prevented this update.
if ((fiber.flags & PassiveUnmountPendingDev) !== NoFlags) {
return;
} // We show the whole stack but dedupe on the top component's name because
// the problematic code almost always lies inside that component.
var componentName = getComponentName(fiber.type) || "ReactComponent";
if (didWarnStateUpdateForUnmountedComponent !== null) {
if (didWarnStateUpdateForUnmountedComponent.has(componentName)) {
return;
}
didWarnStateUpdateForUnmountedComponent.add(componentName);
} else {
didWarnStateUpdateForUnmountedComponent = new Set([componentName]);
}
if (isFlushingPassiveEffects);
else {
var previousFiber = current;
try {
setCurrentFiber(fiber);
error(
"Can't perform a React state update on an unmounted component. This " +
"is a no-op, but it indicates a memory leak in your application. To " +
"fix, cancel all subscriptions and asynchronous tasks in %s.",
tag === ClassComponent
? "the componentWillUnmount method"
: "a useEffect cleanup function",
);
} finally {
if (previousFiber) {
setCurrentFiber(fiber);
} else {
resetCurrentFiber();
}
}
}
}
}
var beginWork$1;
{
var dummyFiber = null;
beginWork$1 = function (current, unitOfWork, lanes) {
// If a component throws an error, we replay it again in a synchronously
// dispatched event, so that the debugger will treat it as an uncaught
// error See ReactErrorUtils for more information.
// Before entering the begin phase, copy the work-in-progress onto a dummy
// fiber. If beginWork throws, we'll use this to reset the state.
var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
dummyFiber,
unitOfWork,
);
try {
return beginWork(current, unitOfWork, lanes);
} catch (originalError) {
if (
originalError !== null &&
typeof originalError === "object" &&
typeof originalError.then === "function"
) {
// Don't replay promises. Treat everything else like an error.
throw originalError;
} // Keep this code in sync with handleError; any changes here must have
// corresponding changes there.
resetContextDependencies();
resetHooksAfterThrow(); // Don't reset current debug fiber, since we're about to work on the
// same fiber again.
// Unwind the failed stack frame
unwindInterruptedWork(unitOfWork); // Restore the original properties of the fiber.
assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
if (unitOfWork.mode & ProfileMode) {
// Reset the profiler timer.
startProfilerTimer(unitOfWork);
} // Run beginWork again.
invokeGuardedCallback(
null,
beginWork,
null,
current,
unitOfWork,
lanes,
);
if (hasCaughtError()) {
var replayError = clearCaughtError(); // `invokeGuardedCallback` sometimes sets an expando `_suppressLogging`.
// Rethrow this error instead of the original one.
throw replayError;
} else {
// This branch is reachable if the render phase is impure.
throw originalError;
}
}
};
}
var didWarnAboutUpdateInRender = false;
var didWarnAboutUpdateInRenderForAnotherComponent;
{
didWarnAboutUpdateInRenderForAnotherComponent = new Set();
}
function warnAboutRenderPhaseUpdatesInDEV(fiber) {
{
if (
isRendering &&
(executionContext & RenderContext) !== NoContext &&
!getIsUpdatingOpaqueValueInRenderPhaseInDEV()
) {
switch (fiber.tag) {
case FunctionComponent:
case ForwardRef:
case SimpleMemoComponent: {
var renderingComponentName =
(workInProgress && getComponentName(workInProgress.type)) ||
"Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
var dedupeKey = renderingComponentName;
if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
var setStateComponentName =
getComponentName(fiber.type) || "Unknown";
error(
"Cannot update a component (`%s`) while rendering a " +
"different component (`%s`). To locate the bad setState() call inside `%s`, " +
"follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
setStateComponentName,
renderingComponentName,
renderingComponentName,
);
}
break;
}
case ClassComponent: {
if (!didWarnAboutUpdateInRender) {
error(
"Cannot update during an existing state transition (such as " +
"within `render`). Render methods should be a pure " +
"function of props and state.",
);
didWarnAboutUpdateInRender = true;
}
break;
}
}
}
}
} // a 'shared' variable that changes when act() opens/closes in tests.
var IsThisRendererActing = {
current: false,
};
function warnIfNotScopedWithMatchingAct(fiber) {
{
if (
IsSomeRendererActing.current === true &&
IsThisRendererActing.current !== true
) {
var previousFiber = current;
try {
setCurrentFiber(fiber);
error(
"It looks like you're using the wrong act() around your test interactions.\n" +
"Be sure to use the matching version of act() corresponding to your renderer:\n\n" +
"// for react-dom:\n" + // Break up imports to avoid accidentally parsing them as dependencies.
"import {act} fr" +
"om 'react-dom/test-utils';\n" +
"// ...\n" +
"act(() => ...);\n\n" +
"// for react-test-renderer:\n" + // Break up imports to avoid accidentally parsing them as dependencies.
"import TestRenderer fr" +
"om react-test-renderer';\n" +
"const {act} = TestRenderer;\n" +
"// ...\n" +
"act(() => ...);",
);
} finally {
if (previousFiber) {
setCurrentFiber(fiber);
} else {
resetCurrentFiber();
}
}
}
}
}
function warnIfNotCurrentlyActingEffectsInDEV(fiber) {
{
if (
(fiber.mode & StrictMode) !== NoMode &&
IsSomeRendererActing.current === false &&
IsThisRendererActing.current === false
) {
error(
"An update to %s ran an effect, but was not wrapped in act(...).\n\n" +
"When testing, code that causes React state updates should be " +
"wrapped into act(...):\n\n" +
"act(() => {\n" +
" /* fire events that update state */\n" +
"});\n" +
"/* assert on the output */\n\n" +
"This ensures that you're testing the behavior the user would see " +
"in the browser." +
" Learn more at https://reactjs.org/link/wrap-tests-with-act",
getComponentName(fiber.type),
);
}
}
}
function warnIfNotCurrentlyActingUpdatesInDEV(fiber) {
{
if (
executionContext === NoContext &&
IsSomeRendererActing.current === false &&
IsThisRendererActing.current === false
) {
var previousFiber = current;
try {
setCurrentFiber(fiber);
error(
"An update to %s inside a test was not wrapped in act(...).\n\n" +
"When testing, code that causes React state updates should be " +
"wrapped into act(...):\n\n" +
"act(() => {\n" +
" /* fire events that update state */\n" +
"});\n" +
"/* assert on the output */\n\n" +
"This ensures that you're testing the behavior the user would see " +
"in the browser." +
" Learn more at https://reactjs.org/link/wrap-tests-with-act",
getComponentName(fiber.type),
);
} finally {
if (previousFiber) {
setCurrentFiber(fiber);
} else {
resetCurrentFiber();
}
}
}
}
}
var warnIfNotCurrentlyActingUpdatesInDev =
warnIfNotCurrentlyActingUpdatesInDEV; // In tests, we want to enforce a mocked scheduler.
var didWarnAboutUnmockedScheduler = false; // TODO Before we release concurrent mode, revisit this and decide whether a mocked
// scheduler is the actual recommendation. The alternative could be a testing build,
// a new lib, or whatever; we dunno just yet. This message is for early adopters
// to get their tests right.
function warnIfUnmockedScheduler(fiber) {
{
if (
didWarnAboutUnmockedScheduler === false &&
unstable_flushAllWithoutAsserting === undefined
) {
if (fiber.mode & BlockingMode || fiber.mode & ConcurrentMode) {
didWarnAboutUnmockedScheduler = true;
error(
'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' +
"to guarantee consistent behaviour across tests and browsers. " +
"For example, with jest: \n" + // Break up requires to avoid accidentally parsing them as dependencies.
"jest.mock('scheduler', () => require" +
"('scheduler/unstable_mock'));\n\n" +
"For more info, visit https://reactjs.org/link/mock-scheduler",
);
}
}
}
}
function computeThreadID(root, lane) {
// Interaction threads are unique per root and expiration time.
// NOTE: Intentionally unsound cast. All that matters is that it's a number
// and it represents a batch of work. Could make a helper function instead,
// but meh this is fine for now.
return lane * 1000 + root.interactionThreadID;
}
function markSpawnedWork(lane) {
if (spawnedWorkDuringRender === null) {
spawnedWorkDuringRender = [lane];
} else {
spawnedWorkDuringRender.push(lane);
}
}
function scheduleInteractions(root, lane, interactions) {
if (interactions.size > 0) {
var pendingInteractionMap = root.pendingInteractionMap;
var pendingInteractions = pendingInteractionMap.get(lane);
if (pendingInteractions != null) {
interactions.forEach(function (interaction) {
if (!pendingInteractions.has(interaction)) {
// Update the pending async work count for previously unscheduled interaction.
interaction.__count++;
}
pendingInteractions.add(interaction);
});
} else {
pendingInteractionMap.set(lane, new Set(interactions)); // Update the pending async work count for the current interactions.
interactions.forEach(function (interaction) {
interaction.__count++;
});
}
var subscriber = __subscriberRef.current;
if (subscriber !== null) {
var threadID = computeThreadID(root, lane);
subscriber.onWorkScheduled(interactions, threadID);
}
}
}
function schedulePendingInteractions(root, lane) {
scheduleInteractions(root, lane, __interactionsRef.current);
}
function startWorkOnPendingInteractions(root, lanes) {
// we can accurately attribute time spent working on it, And so that cascading
// work triggered during the render phase will be associated with it.
var interactions = new Set();
root.pendingInteractionMap.forEach(function (
scheduledInteractions,
scheduledLane,
) {
if (includesSomeLane(lanes, scheduledLane)) {
scheduledInteractions.forEach(function (interaction) {
return interactions.add(interaction);
});
}
}); // Store the current set of interactions on the FiberRoot for a few reasons:
// We can re-use it in hot functions like performConcurrentWorkOnRoot()
// without having to recalculate it. We will also use it in commitWork() to
// pass to any Profiler onRender() hooks. This also provides DevTools with a
// way to access it when the onCommitRoot() hook is called.
root.memoizedInteractions = interactions;
if (interactions.size > 0) {
var subscriber = __subscriberRef.current;
if (subscriber !== null) {
var threadID = computeThreadID(root, lanes);
try {
subscriber.onWorkStarted(interactions, threadID);
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1, function () {
throw error;
});
}
}
}
}
function finishPendingInteractions(root, committedLanes) {
var remainingLanesAfterCommit = root.pendingLanes;
var subscriber;
try {
subscriber = __subscriberRef.current;
if (subscriber !== null && root.memoizedInteractions.size > 0) {
// FIXME: More than one lane can finish in a single commit.
var threadID = computeThreadID(root, committedLanes);
subscriber.onWorkStopped(root.memoizedInteractions, threadID);
}
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1, function () {
throw error;
});
} finally {
// Clear completed interactions from the pending Map.
// Unless the render was suspended or cascading work was scheduled,
// In which case– leave pending interactions until the subsequent render.
var pendingInteractionMap = root.pendingInteractionMap;
pendingInteractionMap.forEach(function (scheduledInteractions, lane) {
// Only decrement the pending interaction count if we're done.
// If there's still work at the current priority,
// That indicates that we are waiting for suspense data.
if (!includesSomeLane(remainingLanesAfterCommit, lane)) {
pendingInteractionMap.delete(lane);
scheduledInteractions.forEach(function (interaction) {
interaction.__count--;
if (subscriber !== null && interaction.__count === 0) {
try {
subscriber.onInteractionScheduledWorkCompleted(interaction);
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(ImmediatePriority$1, function () {
throw error;
});
}
}
});
}
});
}
} // `act` testing API
function shouldForceFlushFallbacksInDEV() {
// Never force flush in production. This function should get stripped out.
return actingUpdatesScopeDepth > 0;
}
// so we can tell if any async act() calls try to run in parallel.
var actingUpdatesScopeDepth = 0;
function detachFiberAfterEffects(fiber) {
fiber.sibling = null;
fiber.stateNode = null;
}
var resolveFamily = null; // $FlowFixMe Flow gets confused by a WeakSet feature check below.
var failedBoundaries = null;
var setRefreshHandler = function (handler) {
{
resolveFamily = handler;
}
};
function resolveFunctionForHotReloading(type) {
{
if (resolveFamily === null) {
// Hot reloading is disabled.
return type;
}
var family = resolveFamily(type);
if (family === undefined) {
return type;
} // Use the latest known implementation.
return family.current;
}
}
function resolveClassForHotReloading(type) {
// No implementation differences.
return resolveFunctionForHotReloading(type);
}
function resolveForwardRefForHotReloading(type) {
{
if (resolveFamily === null) {
// Hot reloading is disabled.
return type;
}
var family = resolveFamily(type);
if (family === undefined) {
// Check if we're dealing with a real forwardRef. Don't want to crash early.
if (
type !== null &&
type !== undefined &&
typeof type.render === "function"
) {
// ForwardRef is special because its resolved .type is an object,
// but it's possible that we only have its inner render function in the map.
// If that inner render function is different, we'll build a new forwardRef type.
var currentRender = resolveFunctionForHotReloading(type.render);
if (type.render !== currentRender) {
var syntheticType = {
$$typeof: REACT_FORWARD_REF_TYPE,
render: currentRender,
};
if (type.displayName !== undefined) {
syntheticType.displayName = type.displayName;
}
return syntheticType;
}
}
return type;
} // Use the latest known implementation.
return family.current;
}
}
function isCompatibleFamilyForHotReloading(fiber, element) {
{
if (resolveFamily === null) {
// Hot reloading is disabled.
return false;
}
var prevType = fiber.elementType;
var nextType = element.type; // If we got here, we know types aren't === equal.
var needsCompareFamilies = false;
var $$typeofNextType =
typeof nextType === "object" && nextType !== null
? nextType.$$typeof
: null;
switch (fiber.tag) {
case ClassComponent: {
if (typeof nextType === "function") {
needsCompareFamilies = true;
}
break;
}
case FunctionComponent: {
if (typeof nextType === "function") {
needsCompareFamilies = true;
} else if ($$typeofNextType === REACT_LAZY_TYPE) {
// We don't know the inner type yet.
// We're going to assume that the lazy inner type is stable,
// and so it is sufficient to avoid reconciling it away.
// We're not going to unwrap or actually use the new lazy type.
needsCompareFamilies = true;
}
break;
}
case ForwardRef: {
if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
needsCompareFamilies = true;
} else if ($$typeofNextType === REACT_LAZY_TYPE) {
needsCompareFamilies = true;
}
break;
}
case MemoComponent:
case SimpleMemoComponent: {
if ($$typeofNextType === REACT_MEMO_TYPE) {
// TODO: if it was but can no longer be simple,
// we shouldn't set this.
needsCompareFamilies = true;
} else if ($$typeofNextType === REACT_LAZY_TYPE) {
needsCompareFamilies = true;
}
break;
}
default:
return false;
} // Check if both types have a family and it's the same one.
if (needsCompareFamilies) {
// Note: memo() and forwardRef() we'll compare outer rather than inner type.
// This means both of them need to be registered to preserve state.
// If we unwrapped and compared the inner types for wrappers instead,
// then we would risk falsely saying two separate memo(Foo)
// calls are equivalent because they wrap the same Foo function.
var prevFamily = resolveFamily(prevType);
if (
prevFamily !== undefined &&
prevFamily === resolveFamily(nextType)
) {
return true;
}
}
return false;
}
}
function markFailedErrorBoundaryForHotReloading(fiber) {
{
if (resolveFamily === null) {
// Hot reloading is disabled.
return;
}
if (typeof WeakSet !== "function") {
return;
}
if (failedBoundaries === null) {
failedBoundaries = new WeakSet();
}
failedBoundaries.add(fiber);
}
}
var scheduleRefresh = function (root, update) {
{
if (resolveFamily === null) {
// Hot reloading is disabled.
return;
}
var staleFamilies = update.staleFamilies,
updatedFamilies = update.updatedFamilies;
flushPassiveEffects();
flushSync(function () {
scheduleFibersWithFamiliesRecursively(
root.current,
updatedFamilies,
staleFamilies,
);
});
}
};
var scheduleRoot = function (root, element) {
{
if (root.context !== emptyContextObject) {
// Super edge case: root has a legacy _renderSubtree context
// but we don't know the parentComponent so we can't pass it.
// Just ignore. We'll delete this with _renderSubtree code path later.
return;
}
flushPassiveEffects();
flushSync(function () {
updateContainer(element, root, null, null);
});
}
};
function scheduleFibersWithFamiliesRecursively(
fiber,
updatedFamilies,
staleFamilies,
) {
{
var alternate = fiber.alternate,
child = fiber.child,
sibling = fiber.sibling,
tag = fiber.tag,
type = fiber.type;
var candidateType = null;
switch (tag) {
case FunctionComponent:
case SimpleMemoComponent:
case ClassComponent:
candidateType = type;
break;
case ForwardRef:
candidateType = type.render;
break;
}
if (resolveFamily === null) {
throw new Error("Expected resolveFamily to be set during hot reload.");
}
var needsRender = false;
var needsRemount = false;
if (candidateType !== null) {
var family = resolveFamily(candidateType);
if (family !== undefined) {
if (staleFamilies.has(family)) {
needsRemount = true;
} else if (updatedFamilies.has(family)) {
if (tag === ClassComponent) {
needsRemount = true;
} else {
needsRender = true;
}
}
}
}
if (failedBoundaries !== null) {
if (
failedBoundaries.has(fiber) ||
(alternate !== null && failedBoundaries.has(alternate))
) {
needsRemount = true;
}
}
if (needsRemount) {
fiber._debugNeedsRemount = true;
}
if (needsRemount || needsRender) {
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
}
if (child !== null && !needsRemount) {
scheduleFibersWithFamiliesRecursively(
child,
updatedFamilies,
staleFamilies,
);
}
if (sibling !== null) {
scheduleFibersWithFamiliesRecursively(
sibling,
updatedFamilies,
staleFamilies,
);
}
}
}
var findHostInstancesForRefresh = function (root, families) {
{
var hostInstances = new Set();
var types = new Set(
families.map(function (family) {
return family.current;
}),
);
findHostInstancesForMatchingFibersRecursively(
root.current,
types,
hostInstances,
);
return hostInstances;
}
};
function findHostInstancesForMatchingFibersRecursively(
fiber,
types,
hostInstances,
) {
{
var child = fiber.child,
sibling = fiber.sibling,
tag = fiber.tag,
type = fiber.type;
var candidateType = null;
switch (tag) {
case FunctionComponent:
case SimpleMemoComponent:
case ClassComponent:
candidateType = type;
break;
case ForwardRef:
candidateType = type.render;
break;
}
var didMatch = false;
if (candidateType !== null) {
if (types.has(candidateType)) {
didMatch = true;
}
}
if (didMatch) {
// We have a match. This only drills down to the closest host components.
// There's no need to search deeper because for the purpose of giving
// visual feedback, "flashing" outermost parent rectangles is sufficient.
findHostInstancesForFiberShallowly(fiber, hostInstances);
} else {
// If there's no match, maybe there will be one further down in the child tree.
if (child !== null) {
findHostInstancesForMatchingFibersRecursively(
child,
types,
hostInstances,
);
}
}
if (sibling !== null) {
findHostInstancesForMatchingFibersRecursively(
sibling,
types,
hostInstances,
);
}
}
}
function findHostInstancesForFiberShallowly(fiber, hostInstances) {
{
var foundHostInstances = findChildHostInstancesForFiberShallowly(
fiber,
hostInstances,
);
if (foundHostInstances) {
return;
} // If we didn't find any host children, fallback to closest host parent.
var node = fiber;
while (true) {
switch (node.tag) {
case HostComponent:
hostInstances.add(node.stateNode);
return;
case HostPortal:
hostInstances.add(node.stateNode.containerInfo);
return;
case HostRoot:
hostInstances.add(node.stateNode.containerInfo);
return;
}
if (node.return === null) {
throw new Error("Expected to reach root first.");
}
node = node.return;
}
}
}
function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
{
var node = fiber;
var foundHostInstances = false;
while (true) {
if (node.tag === HostComponent) {
// We got a match.
foundHostInstances = true;
hostInstances.add(node.stateNode); // There may still be more, so keep searching.
} else if (node.child !== null) {
node.child.return = node;
node = node.child;
continue;
}
if (node === fiber) {
return foundHostInstances;
}
while (node.sibling === null) {
if (node.return === null || node.return === fiber) {
return foundHostInstances;
}
node = node.return;
}
node.sibling.return = node.return;
node = node.sibling;
}
}
return false;
}
var hasBadMapPolyfill;
{
hasBadMapPolyfill = false;
try {
var nonExtensibleObject = Object.preventExtensions({});
/* eslint-disable no-new */
new Map([[nonExtensibleObject, null]]);
new Set([nonExtensibleObject]);
/* eslint-enable no-new */
} catch (e) {
// TODO: Consider warning about bad polyfills
hasBadMapPolyfill = true;
}
}
var debugCounter = 1;
function FiberNode(tag, pendingProps, key, mode) {
// Instance
this.tag = tag;
this.key = key;
this.elementType = null;
this.type = null;
this.stateNode = null; // Fiber
this.return = null;
this.child = null;
this.sibling = null;
this.index = 0;
this.ref = null;
this.pendingProps = pendingProps;
this.memoizedProps = null;
this.updateQueue = null;
this.memoizedState = null;
this.dependencies = null;
this.mode = mode; // Effects
this.flags = NoFlags;
this.nextEffect = null;
this.firstEffect = null;
this.lastEffect = null;
this.lanes = NoLanes;
this.childLanes = NoLanes;
this.alternate = null;
{
// Note: The following is done to avoid a v8 performance cliff.
//
// Initializing the fields below to smis and later updating them with
// double values will cause Fibers to end up having separate shapes.
// This behavior/bug has something to do with Object.preventExtension().
// Fortunately this only impacts DEV builds.
// Unfortunately it makes React unusably slow for some applications.
// To work around this, initialize the fields below with doubles.
//
// Learn more about this here:
// https://github.com/facebook/react/issues/14365
// https://bugs.chromium.org/p/v8/issues/detail?id=8538
this.actualDuration = Number.NaN;
this.actualStartTime = Number.NaN;
this.selfBaseDuration = Number.NaN;
this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
// This won't trigger the performance cliff mentioned above,
// and it simplifies other profiler code (including DevTools).
this.actualDuration = 0;
this.actualStartTime = -1;
this.selfBaseDuration = 0;
this.treeBaseDuration = 0;
}
{
// This isn't directly used but is handy for debugging internals:
this._debugID = debugCounter++;
this._debugSource = null;
this._debugOwner = null;
this._debugNeedsRemount = false;
this._debugHookTypes = null;
if (
!hasBadMapPolyfill &&
typeof Object.preventExtensions === "function"
) {
Object.preventExtensions(this);
}
}
} // This is a constructor function, rather than a POJO constructor, still
// please ensure we do the following:
// 1) Nobody should add any instance methods on this. Instance methods can be
// more difficult to predict when they get optimized and they are almost
// never inlined properly in static compilers.
// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
// always know when it is a fiber.
// 3) We might want to experiment with using numeric keys since they are easier
// to optimize in a non-JIT environment.
// 4) We can easily go from a constructor to a createFiber object literal if that
// is faster.
// 5) It should be easy to port this to a C struct and keep a C implementation
// compatible.
var createFiber = function (tag, pendingProps, key, mode) {
// $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
return new FiberNode(tag, pendingProps, key, mode);
};
function shouldConstruct$1(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function isSimpleFunctionComponent(type) {
return (
typeof type === "function" &&
!shouldConstruct$1(type) &&
type.defaultProps === undefined
);
}
function resolveLazyComponentTag(Component) {
if (typeof Component === "function") {
return shouldConstruct$1(Component) ? ClassComponent : FunctionComponent;
} else if (Component !== undefined && Component !== null) {
var $$typeof = Component.$$typeof;
if ($$typeof === REACT_FORWARD_REF_TYPE) {
return ForwardRef;
}
if ($$typeof === REACT_MEMO_TYPE) {
return MemoComponent;
}
}
return IndeterminateComponent;
} // This is used to create an alternate fiber to do work on.
function createWorkInProgress(current, pendingProps) {
var workInProgress = current.alternate;
if (workInProgress === null) {
// We use a double buffering pooling technique because we know that we'll
// only ever need at most two versions of a tree. We pool the "other" unused
// node that we're free to reuse. This is lazily created to avoid allocating
// extra objects for things that are never updated. It also allow us to
// reclaim the extra memory if needed.
workInProgress = createFiber(
current.tag,
pendingProps,
current.key,
current.mode,
);
workInProgress.elementType = current.elementType;
workInProgress.type = current.type;
workInProgress.stateNode = current.stateNode;
{
// DEV-only fields
workInProgress._debugID = current._debugID;
workInProgress._debugSource = current._debugSource;
workInProgress._debugOwner = current._debugOwner;
workInProgress._debugHookTypes = current._debugHookTypes;
}
workInProgress.alternate = current;
current.alternate = workInProgress;
} else {
workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
workInProgress.type = current.type; // We already have an alternate.
// Reset the effect tag.
workInProgress.flags = NoFlags; // The effect list is no longer valid.
workInProgress.nextEffect = null;
workInProgress.firstEffect = null;
workInProgress.lastEffect = null;
{
// We intentionally reset, rather than copy, actualDuration & actualStartTime.
// This prevents time from endlessly accumulating in new commits.
// This has the downside of resetting values for different priority renders,
// But works for yielding (the common case) and should support resuming.
workInProgress.actualDuration = 0;
workInProgress.actualStartTime = -1;
}
}
workInProgress.childLanes = current.childLanes;
workInProgress.lanes = current.lanes;
workInProgress.child = current.child;
workInProgress.memoizedProps = current.memoizedProps;
workInProgress.memoizedState = current.memoizedState;
workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
// it cannot be shared with the current fiber.
var currentDependencies = current.dependencies;
workInProgress.dependencies =
currentDependencies === null
? null
: {
lanes: currentDependencies.lanes,
firstContext: currentDependencies.firstContext,
}; // These will be overridden during the parent's reconciliation
workInProgress.sibling = current.sibling;
workInProgress.index = current.index;
workInProgress.ref = current.ref;
{
workInProgress.selfBaseDuration = current.selfBaseDuration;
workInProgress.treeBaseDuration = current.treeBaseDuration;
}
{
workInProgress._debugNeedsRemount = current._debugNeedsRemount;
switch (workInProgress.tag) {
case IndeterminateComponent:
case FunctionComponent:
case SimpleMemoComponent:
workInProgress.type = resolveFunctionForHotReloading(current.type);
break;
case ClassComponent:
workInProgress.type = resolveClassForHotReloading(current.type);
break;
case ForwardRef:
workInProgress.type = resolveForwardRefForHotReloading(current.type);
break;
}
}
return workInProgress;
} // Used to reuse a Fiber for a second pass.
function resetWorkInProgress(workInProgress, renderLanes) {
// This resets the Fiber to what createFiber or createWorkInProgress would
// have set the values to before during the first pass. Ideally this wouldn't
// be necessary but unfortunately many code paths reads from the workInProgress
// when they should be reading from current and writing to workInProgress.
// We assume pendingProps, index, key, ref, return are still untouched to
// avoid doing another reconciliation.
// Reset the effect tag but keep any Placement tags, since that's something
// that child fiber is setting, not the reconciliation.
workInProgress.flags &= Placement; // The effect list is no longer valid.
workInProgress.nextEffect = null;
workInProgress.firstEffect = null;
workInProgress.lastEffect = null;
var current = workInProgress.alternate;
if (current === null) {
// Reset to createFiber's initial values.
workInProgress.childLanes = NoLanes;
workInProgress.lanes = renderLanes;
workInProgress.child = null;
workInProgress.memoizedProps = null;
workInProgress.memoizedState = null;
workInProgress.updateQueue = null;
workInProgress.dependencies = null;
workInProgress.stateNode = null;
{
// Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration = 0;
workInProgress.treeBaseDuration = 0;
}
} else {
// Reset to the cloned values that createWorkInProgress would've.
workInProgress.childLanes = current.childLanes;
workInProgress.lanes = current.lanes;
workInProgress.child = current.child;
workInProgress.memoizedProps = current.memoizedProps;
workInProgress.memoizedState = current.memoizedState;
workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
// it cannot be shared with the current fiber.
var currentDependencies = current.dependencies;
workInProgress.dependencies =
currentDependencies === null
? null
: {
lanes: currentDependencies.lanes,
firstContext: currentDependencies.firstContext,
};
{
// Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration = current.selfBaseDuration;
workInProgress.treeBaseDuration = current.treeBaseDuration;
}
}
return workInProgress;
}
function createHostRootFiber(tag) {
var mode;
if (tag === ConcurrentRoot) {
mode = ConcurrentMode | BlockingMode | StrictMode;
} else if (tag === BlockingRoot) {
mode = BlockingMode | StrictMode;
} else {
mode = NoMode;
}
if (isDevToolsPresent) {
// Always collect profile timings when DevTools are present.
// This enables DevTools to start capturing timing at any point–
// Without some nodes in the tree having empty base times.
mode |= ProfileMode;
}
return createFiber(HostRoot, null, null, mode);
}
function createFiberFromTypeAndProps(
type, // React$ElementType
key,
pendingProps,
owner,
mode,
lanes,
) {
var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
var resolvedType = type;
if (typeof type === "function") {
if (shouldConstruct$1(type)) {
fiberTag = ClassComponent;
{
resolvedType = resolveClassForHotReloading(resolvedType);
}
} else {
{
resolvedType = resolveFunctionForHotReloading(resolvedType);
}
}
} else if (typeof type === "string") {
fiberTag = HostComponent;
} else {
getTag: switch (type) {
case REACT_FRAGMENT_TYPE:
return createFiberFromFragment(
pendingProps.children,
mode,
lanes,
key,
);
case REACT_DEBUG_TRACING_MODE_TYPE:
fiberTag = Mode;
mode |= DebugTracingMode;
break;
case REACT_STRICT_MODE_TYPE:
fiberTag = Mode;
mode |= StrictMode;
break;
case REACT_PROFILER_TYPE:
return createFiberFromProfiler(pendingProps, mode, lanes, key);
case REACT_SUSPENSE_TYPE:
return createFiberFromSuspense(pendingProps, mode, lanes, key);
case REACT_SUSPENSE_LIST_TYPE:
return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
case REACT_OFFSCREEN_TYPE:
return createFiberFromOffscreen(pendingProps, mode, lanes, key);
case REACT_LEGACY_HIDDEN_TYPE:
return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
case REACT_SCOPE_TYPE:
// eslint-disable-next-line no-fallthrough
default: {
if (typeof type === "object" && type !== null) {
switch (type.$$typeof) {
case REACT_PROVIDER_TYPE:
fiberTag = ContextProvider;
break getTag;
case REACT_CONTEXT_TYPE:
// This is a consumer
fiberTag = ContextConsumer;
break getTag;
case REACT_FORWARD_REF_TYPE:
fiberTag = ForwardRef;
{
resolvedType = resolveForwardRefForHotReloading(resolvedType);
}
break getTag;
case REACT_MEMO_TYPE:
fiberTag = MemoComponent;
break getTag;
case REACT_LAZY_TYPE:
fiberTag = LazyComponent;
resolvedType = null;
break getTag;
case REACT_BLOCK_TYPE:
fiberTag = Block;
break getTag;
}
}
var info = "";
{
if (
type === undefined ||
(typeof type === "object" &&
type !== null &&
Object.keys(type).length === 0)
) {
info +=
" You likely forgot to export your component from the file " +
"it's defined in, or you might have mixed up default and " +
"named imports.";
}
var ownerName = owner ? getComponentName(owner.type) : null;
if (ownerName) {
info += "\n\nCheck the render method of `" + ownerName + "`.";
}
}
{
{
throw Error(
"Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " +
(type == null ? type : typeof type) +
"." +
info,
);
}
}
}
}
}
var fiber = createFiber(fiberTag, pendingProps, key, mode);
fiber.elementType = type;
fiber.type = resolvedType;
fiber.lanes = lanes;
{
fiber._debugOwner = owner;
}
return fiber;
}
function createFiberFromElement(element, mode, lanes) {
var owner = null;
{
owner = element._owner;
}
var type = element.type;
var key = element.key;
var pendingProps = element.props;
var fiber = createFiberFromTypeAndProps(
type,
key,
pendingProps,
owner,
mode,
lanes,
);
{
fiber._debugSource = element._source;
fiber._debugOwner = element._owner;
}
return fiber;
}
function createFiberFromFragment(elements, mode, lanes, key) {
var fiber = createFiber(Fragment, elements, key, mode);
fiber.lanes = lanes;
return fiber;
}
function createFiberFromProfiler(pendingProps, mode, lanes, key) {
{
if (typeof pendingProps.id !== "string") {
error('Profiler must specify an "id" as a prop');
}
}
var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode); // TODO: The Profiler fiber shouldn't have a type. It has a tag.
fiber.elementType = REACT_PROFILER_TYPE;
fiber.type = REACT_PROFILER_TYPE;
fiber.lanes = lanes;
{
fiber.stateNode = {
effectDuration: 0,
passiveEffectDuration: 0,
};
}
return fiber;
}
function createFiberFromSuspense(pendingProps, mode, lanes, key) {
var fiber = createFiber(SuspenseComponent, pendingProps, key, mode); // TODO: The SuspenseComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
fiber.type = REACT_SUSPENSE_TYPE;
fiber.elementType = REACT_SUSPENSE_TYPE;
fiber.lanes = lanes;
return fiber;
}
function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
{
// TODO: The SuspenseListComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
fiber.type = REACT_SUSPENSE_LIST_TYPE;
}
fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
fiber.lanes = lanes;
return fiber;
}
function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
var fiber = createFiber(OffscreenComponent, pendingProps, key, mode); // TODO: The OffscreenComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
{
fiber.type = REACT_OFFSCREEN_TYPE;
}
fiber.elementType = REACT_OFFSCREEN_TYPE;
fiber.lanes = lanes;
return fiber;
}
function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode); // TODO: The LegacyHidden fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
{
fiber.type = REACT_LEGACY_HIDDEN_TYPE;
}
fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
fiber.lanes = lanes;
return fiber;
}
function createFiberFromText(content, mode, lanes) {
var fiber = createFiber(HostText, content, null, mode);
fiber.lanes = lanes;
return fiber;
}
function createFiberFromHostInstanceForDeletion() {
var fiber = createFiber(HostComponent, null, null, NoMode); // TODO: These should not need a type.
fiber.elementType = "DELETED";
fiber.type = "DELETED";
return fiber;
}
function createFiberFromPortal(portal, mode, lanes) {
var pendingProps = portal.children !== null ? portal.children : [];
var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
fiber.lanes = lanes;
fiber.stateNode = {
containerInfo: portal.containerInfo,
pendingChildren: null,
// Used by persistent updates
implementation: portal.implementation,
};
return fiber;
} // Used for stashing WIP properties to replay failed work in DEV.
function assignFiberPropertiesInDEV(target, source) {
if (target === null) {
// This Fiber's initial properties will always be overwritten.
// We only use a Fiber to ensure the same hidden class so DEV isn't slow.
target = createFiber(IndeterminateComponent, null, null, NoMode);
} // This is intentionally written as a list of all properties.
// We tried to use Object.assign() instead but this is called in
// the hottest path, and Object.assign() was too slow:
// https://github.com/facebook/react/issues/12502
// This code is DEV-only so size is not a concern.
target.tag = source.tag;
target.key = source.key;
target.elementType = source.elementType;
target.type = source.type;
target.stateNode = source.stateNode;
target.return = source.return;
target.child = source.child;
target.sibling = source.sibling;
target.index = source.index;
target.ref = source.ref;
target.pendingProps = source.pendingProps;
target.memoizedProps = source.memoizedProps;
target.updateQueue = source.updateQueue;
target.memoizedState = source.memoizedState;
target.dependencies = source.dependencies;
target.mode = source.mode;
target.flags = source.flags;
target.nextEffect = source.nextEffect;
target.firstEffect = source.firstEffect;
target.lastEffect = source.lastEffect;
target.lanes = source.lanes;
target.childLanes = source.childLanes;
target.alternate = source.alternate;
{
target.actualDuration = source.actualDuration;
target.actualStartTime = source.actualStartTime;
target.selfBaseDuration = source.selfBaseDuration;
target.treeBaseDuration = source.treeBaseDuration;
}
target._debugID = source._debugID;
target._debugSource = source._debugSource;
target._debugOwner = source._debugOwner;
target._debugNeedsRemount = source._debugNeedsRemount;
target._debugHookTypes = source._debugHookTypes;
return target;
}
function FiberRootNode(containerInfo, tag, hydrate) {
this.tag = tag;
this.containerInfo = containerInfo;
this.pendingChildren = null;
this.current = null;
this.pingCache = null;
this.finishedWork = null;
this.timeoutHandle = noTimeout;
this.context = null;
this.pendingContext = null;
this.hydrate = hydrate;
this.callbackNode = null;
this.callbackPriority = NoLanePriority;
this.eventTimes = createLaneMap(NoLanes);
this.expirationTimes = createLaneMap(NoTimestamp);
this.pendingLanes = NoLanes;
this.suspendedLanes = NoLanes;
this.pingedLanes = NoLanes;
this.expiredLanes = NoLanes;
this.mutableReadLanes = NoLanes;
this.finishedLanes = NoLanes;
this.entangledLanes = NoLanes;
this.entanglements = createLaneMap(NoLanes);
{
this.mutableSourceEagerHydrationData = null;
}
{
this.interactionThreadID = unstable_getThreadID();
this.memoizedInteractions = new Set();
this.pendingInteractionMap = new Map();
}
{
switch (tag) {
case BlockingRoot:
this._debugRootType = "createBlockingRoot()";
break;
case ConcurrentRoot:
this._debugRootType = "createRoot()";
break;
case LegacyRoot:
this._debugRootType = "createLegacyRoot()";
break;
}
}
}
function createFiberRoot(containerInfo, tag, hydrate, hydrationCallbacks) {
var root = new FiberRootNode(containerInfo, tag, hydrate);
// stateNode is any.
var uninitializedFiber = createHostRootFiber(tag);
root.current = uninitializedFiber;
uninitializedFiber.stateNode = root;
initializeUpdateQueue(uninitializedFiber);
return root;
}
// This ensures that the version used for server rendering matches the one
// that is eventually read during hydration.
// If they don't match there's a potential tear and a full deopt render is required.
function registerMutableSourceForHydration(root, mutableSource) {
var getVersion = mutableSource._getVersion;
var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
// Retaining it forever may interfere with GC.
if (root.mutableSourceEagerHydrationData == null) {
root.mutableSourceEagerHydrationData = [mutableSource, version];
} else {
root.mutableSourceEagerHydrationData.push(mutableSource, version);
}
}
function createPortal(
children,
containerInfo, // TODO: figure out the API for cross-renderer implementation.
implementation,
) {
var key =
arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
return {
// This tag allow us to uniquely identify this as a React Portal
$$typeof: REACT_PORTAL_TYPE,
key: key == null ? null : "" + key,
children: children,
containerInfo: containerInfo,
implementation: implementation,
};
}
var didWarnAboutNestedUpdates;
var didWarnAboutFindNodeInStrictMode;
{
didWarnAboutNestedUpdates = false;
didWarnAboutFindNodeInStrictMode = {};
}
function getContextForSubtree(parentComponent) {
if (!parentComponent) {
return emptyContextObject;
}
var fiber = get(parentComponent);
var parentContext = findCurrentUnmaskedContext(fiber);
if (fiber.tag === ClassComponent) {
var Component = fiber.type;
if (isContextProvider(Component)) {
return processChildContext(fiber, Component, parentContext);
}
}
return parentContext;
}
function findHostInstanceWithWarning(component, methodName) {
{
var fiber = get(component);
if (fiber === undefined) {
if (typeof component.render === "function") {
{
{
throw Error("Unable to find node on an unmounted component.");
}
}
} else {
{
{
throw Error(
"Argument appears to not be a ReactComponent. Keys: " +
Object.keys(component),
);
}
}
}
}
var hostFiber = findCurrentHostFiber(fiber);
if (hostFiber === null) {
return null;
}
if (hostFiber.mode & StrictMode) {
var componentName = getComponentName(fiber.type) || "Component";
if (!didWarnAboutFindNodeInStrictMode[componentName]) {
didWarnAboutFindNodeInStrictMode[componentName] = true;
var previousFiber = current;
try {
setCurrentFiber(hostFiber);
if (fiber.mode & StrictMode) {
error(
"%s is deprecated in StrictMode. " +
"%s was passed an instance of %s which is inside StrictMode. " +
"Instead, add a ref directly to the element you want to reference. " +
"Learn more about using refs safely here: " +
"https://reactjs.org/link/strict-mode-find-node",
methodName,
methodName,
componentName,
);
} else {
error(
"%s is deprecated in StrictMode. " +
"%s was passed an instance of %s which renders StrictMode children. " +
"Instead, add a ref directly to the element you want to reference. " +
"Learn more about using refs safely here: " +
"https://reactjs.org/link/strict-mode-find-node",
methodName,
methodName,
componentName,
);
}
} finally {
// Ideally this should reset to previous but this shouldn't be called in
// render and there's another warning for that anyway.
if (previousFiber) {
setCurrentFiber(previousFiber);
} else {
resetCurrentFiber();
}
}
}
}
return hostFiber.stateNode;
}
}
function createContainer(containerInfo, tag, hydrate, hydrationCallbacks) {
return createFiberRoot(containerInfo, tag, hydrate);
}
function updateContainer(element, container, parentComponent, callback) {
{
onScheduleRoot(container, element);
}
var current$1 = container.current;
var eventTime = requestEventTime();
{
// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
if ("undefined" !== typeof jest) {
warnIfUnmockedScheduler(current$1);
warnIfNotScopedWithMatchingAct(current$1);
}
}
var lane = requestUpdateLane(current$1);
var context = getContextForSubtree(parentComponent);
if (container.context === null) {
container.context = context;
} else {
container.pendingContext = context;
}
{
if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
didWarnAboutNestedUpdates = true;
error(
"Render methods should be a pure function of props and state; " +
"triggering nested component updates from render is not allowed. " +
"If necessary, trigger nested updates in componentDidUpdate.\n\n" +
"Check the render method of %s.",
getComponentName(current.type) || "Unknown",
);
}
}
var update = createUpdate(eventTime, lane); // Caution: React DevTools currently depends on this property
// being called "element".
update.payload = {
element: element,
};
callback = callback === undefined ? null : callback;
if (callback !== null) {
{
if (typeof callback !== "function") {
error(
"render(...): Expected the last optional `callback` argument to be a " +
"function. Instead received: %s.",
callback,
);
}
}
update.callback = callback;
}
enqueueUpdate(current$1, update);
scheduleUpdateOnFiber(current$1, lane, eventTime);
return lane;
}
function getPublicRootInstance(container) {
var containerFiber = container.current;
if (!containerFiber.child) {
return null;
}
switch (containerFiber.child.tag) {
case HostComponent:
return getPublicInstance(containerFiber.child.stateNode);
default:
return containerFiber.child.stateNode;
}
}
function markRetryLaneImpl(fiber, retryLane) {
var suspenseState = fiber.memoizedState;
if (suspenseState !== null && suspenseState.dehydrated !== null) {
suspenseState.retryLane = higherPriorityLane(
suspenseState.retryLane,
retryLane,
);
}
} // Increases the priority of thennables when they resolve within this boundary.
function markRetryLaneIfNotHydrated(fiber, retryLane) {
markRetryLaneImpl(fiber, retryLane);
var alternate = fiber.alternate;
if (alternate) {
markRetryLaneImpl(alternate, retryLane);
}
}
function attemptUserBlockingHydration$1(fiber) {
if (fiber.tag !== SuspenseComponent) {
// We ignore HostRoots here because we can't increase
// their priority and they should not suspend on I/O,
// since you have to wrap anything that might suspend in
// Suspense.
return;
}
var eventTime = requestEventTime();
var lane = InputDiscreteHydrationLane;
scheduleUpdateOnFiber(fiber, lane, eventTime);
markRetryLaneIfNotHydrated(fiber, lane);
}
function attemptContinuousHydration$1(fiber) {
if (fiber.tag !== SuspenseComponent) {
// We ignore HostRoots here because we can't increase
// their priority and they should not suspend on I/O,
// since you have to wrap anything that might suspend in
// Suspense.
return;
}
var eventTime = requestEventTime();
var lane = SelectiveHydrationLane;
scheduleUpdateOnFiber(fiber, lane, eventTime);
markRetryLaneIfNotHydrated(fiber, lane);
}
function attemptHydrationAtCurrentPriority$1(fiber) {
if (fiber.tag !== SuspenseComponent) {
// We ignore HostRoots here because we can't increase
// their priority other than synchronously flush it.
return;
}
var eventTime = requestEventTime();
var lane = requestUpdateLane(fiber);
scheduleUpdateOnFiber(fiber, lane, eventTime);
markRetryLaneIfNotHydrated(fiber, lane);
}
function runWithPriority$2(priority, fn) {
try {
setCurrentUpdateLanePriority(priority);
return fn();
} finally {
}
}
function findHostInstanceWithNoPortals(fiber) {
var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
if (hostFiber === null) {
return null;
}
if (hostFiber.tag === FundamentalComponent) {
return hostFiber.stateNode.instance;
}
return hostFiber.stateNode;
}
var shouldSuspendImpl = function (fiber) {
return false;
};
function shouldSuspend(fiber) {
return shouldSuspendImpl(fiber);
}
var overrideHookState = null;
var overrideHookStateDeletePath = null;
var overrideHookStateRenamePath = null;
var overrideProps = null;
var overridePropsDeletePath = null;
var overridePropsRenamePath = null;
var scheduleUpdate = null;
var setSuspenseHandler = null;
{
var copyWithDeleteImpl = function (obj, path, index) {
var key = path[index];
var updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj);
if (index + 1 === path.length) {
if (Array.isArray(updated)) {
updated.splice(key, 1);
} else {
delete updated[key];
}
return updated;
} // $FlowFixMe number or string is fine here
updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
return updated;
};
var copyWithDelete = function (obj, path) {
return copyWithDeleteImpl(obj, path, 0);
};
var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
var oldKey = oldPath[index];
var updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj);
if (index + 1 === oldPath.length) {
var newKey = newPath[index]; // $FlowFixMe number or string is fine here
updated[newKey] = updated[oldKey];
if (Array.isArray(updated)) {
updated.splice(oldKey, 1);
} else {
delete updated[oldKey];
}
} else {
// $FlowFixMe number or string is fine here
updated[oldKey] = copyWithRenameImpl(
// $FlowFixMe number or string is fine here
obj[oldKey],
oldPath,
newPath,
index + 1,
);
}
return updated;
};
var copyWithRename = function (obj, oldPath, newPath) {
if (oldPath.length !== newPath.length) {
warn("copyWithRename() expects paths of the same length");
return;
} else {
for (var i = 0; i < newPath.length - 1; i++) {
if (oldPath[i] !== newPath[i]) {
warn(
"copyWithRename() expects paths to be the same except for the deepest key",
);
return;
}
}
}
return copyWithRenameImpl(obj, oldPath, newPath, 0);
};
var copyWithSetImpl = function (obj, path, index, value) {
if (index >= path.length) {
return value;
}
var key = path[index];
var updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj); // $FlowFixMe number or string is fine here
updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
return updated;
};
var copyWithSet = function (obj, path, value) {
return copyWithSetImpl(obj, path, 0, value);
};
var findHook = function (fiber, id) {
// For now, the "id" of stateful hooks is just the stateful hook index.
// This may change in the future with e.g. nested hooks.
var currentHook = fiber.memoizedState;
while (currentHook !== null && id > 0) {
currentHook = currentHook.next;
id--;
}
return currentHook;
}; // Support DevTools editable values for useState and useReducer.
overrideHookState = function (fiber, id, path, value) {
var hook = findHook(fiber, id);
if (hook !== null) {
var newState = copyWithSet(hook.memoizedState, path, value);
hook.memoizedState = newState;
hook.baseState = newState; // We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps);
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
}
};
overrideHookStateDeletePath = function (fiber, id, path) {
var hook = findHook(fiber, id);
if (hook !== null) {
var newState = copyWithDelete(hook.memoizedState, path);
hook.memoizedState = newState;
hook.baseState = newState; // We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps);
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
}
};
overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
var hook = findHook(fiber, id);
if (hook !== null) {
var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
hook.memoizedState = newState;
hook.baseState = newState; // We aren't actually adding an update to the queue,
// because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps);
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
}
}; // Support DevTools props for function components, forwardRef, memo, host components, etc.
overrideProps = function (fiber, path, value) {
fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
if (fiber.alternate) {
fiber.alternate.pendingProps = fiber.pendingProps;
}
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
};
overridePropsDeletePath = function (fiber, path) {
fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
if (fiber.alternate) {
fiber.alternate.pendingProps = fiber.pendingProps;
}
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
};
overridePropsRenamePath = function (fiber, oldPath, newPath) {
fiber.pendingProps = copyWithRename(
fiber.memoizedProps,
oldPath,
newPath,
);
if (fiber.alternate) {
fiber.alternate.pendingProps = fiber.pendingProps;
}
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
};
scheduleUpdate = function (fiber) {
scheduleUpdateOnFiber(fiber, SyncLane, NoTimestamp);
};
setSuspenseHandler = function (newShouldSuspendImpl) {
shouldSuspendImpl = newShouldSuspendImpl;
};
}
function findHostInstanceByFiber(fiber) {
var hostFiber = findCurrentHostFiber(fiber);
if (hostFiber === null) {
return null;
}
return hostFiber.stateNode;
}
function emptyFindFiberByHostInstance(instance) {
return null;
}
function getCurrentFiberForDevTools() {
return current;
}
function injectIntoDevTools(devToolsConfig) {
var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
return injectInternals({
bundleType: devToolsConfig.bundleType,
version: devToolsConfig.version,
rendererPackageName: devToolsConfig.rendererPackageName,
rendererConfig: devToolsConfig.rendererConfig,
overrideHookState: overrideHookState,
overrideHookStateDeletePath: overrideHookStateDeletePath,
overrideHookStateRenamePath: overrideHookStateRenamePath,
overrideProps: overrideProps,
overridePropsDeletePath: overridePropsDeletePath,
overridePropsRenamePath: overridePropsRenamePath,
setSuspenseHandler: setSuspenseHandler,
scheduleUpdate: scheduleUpdate,
currentDispatcherRef: ReactCurrentDispatcher,
findHostInstanceByFiber: findHostInstanceByFiber,
findFiberByHostInstance:
findFiberByHostInstance || emptyFindFiberByHostInstance,
// React Refresh
findHostInstancesForRefresh: findHostInstancesForRefresh,
scheduleRefresh: scheduleRefresh,
scheduleRoot: scheduleRoot,
setRefreshHandler: setRefreshHandler,
// Enables DevTools to append owner stacks to error messages in DEV mode.
getCurrentFiber: getCurrentFiberForDevTools,
});
}
function ReactDOMRoot(container, options) {
this._internalRoot = createRootImpl(container, ConcurrentRoot, options);
}
function ReactDOMBlockingRoot(container, tag, options) {
this._internalRoot = createRootImpl(container, tag, options);
}
ReactDOMRoot.prototype.render = ReactDOMBlockingRoot.prototype.render =
function (children) {
var root = this._internalRoot;
{
if (typeof arguments[1] === "function") {
error(
"render(...): does not support the second callback argument. " +
"To execute a side effect after rendering, declare it in a component body with useEffect().",
);
}
var container = root.containerInfo;
if (container.nodeType !== COMMENT_NODE) {
var hostInstance = findHostInstanceWithNoPortals(root.current);
if (hostInstance) {
if (hostInstance.parentNode !== container) {
error(
"render(...): It looks like the React-rendered content of the " +
"root container was removed without using React. This is not " +
"supported and will cause errors. Instead, call " +
"root.unmount() to empty a root's container.",
);
}
}
}
}
updateContainer(children, root, null, null);
};
ReactDOMRoot.prototype.unmount = ReactDOMBlockingRoot.prototype.unmount =
function () {
{
if (typeof arguments[0] === "function") {
error(
"unmount(...): does not support a callback argument. " +
"To execute a side effect after rendering, declare it in a component body with useEffect().",
);
}
}
var root = this._internalRoot;
var container = root.containerInfo;
updateContainer(null, root, null, function () {
unmarkContainerAsRoot(container);
});
};
function createRootImpl(container, tag, options) {
// Tag is either LegacyRoot or Concurrent Root
var hydrate = options != null && options.hydrate === true;
var hydrationCallbacks =
(options != null && options.hydrationOptions) || null;
var mutableSources =
(options != null &&
options.hydrationOptions != null &&
options.hydrationOptions.mutableSources) ||
null;
var root = createContainer(container, tag, hydrate);
markContainerAsRoot(root.current, container);
var containerNodeType = container.nodeType;
{
var rootContainerElement =
container.nodeType === COMMENT_NODE ? container.parentNode : container;
listenToAllSupportedEvents(rootContainerElement);
}
if (mutableSources) {
for (var i = 0; i < mutableSources.length; i++) {
var mutableSource = mutableSources[i];
registerMutableSourceForHydration(root, mutableSource);
}
}
return root;
}
function createLegacyRoot(container, options) {
return new ReactDOMBlockingRoot(container, LegacyRoot, options);
}
function isValidContainer(node) {
return !!(
node &&
(node.nodeType === ELEMENT_NODE ||
node.nodeType === DOCUMENT_NODE ||
node.nodeType === DOCUMENT_FRAGMENT_NODE ||
(node.nodeType === COMMENT_NODE &&
node.nodeValue === " react-mount-point-unstable "))
);
}
var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
var topLevelUpdateWarnings;
var warnedAboutHydrateAPI = false;
{
topLevelUpdateWarnings = function (container) {
if (
container._reactRootContainer &&
container.nodeType !== COMMENT_NODE
) {
var hostInstance = findHostInstanceWithNoPortals(
container._reactRootContainer._internalRoot.current,
);
if (hostInstance) {
if (hostInstance.parentNode !== container) {
error(
"render(...): It looks like the React-rendered content of this " +
"container was removed without using React. This is not " +
"supported and will cause errors. Instead, call " +
"ReactDOM.unmountComponentAtNode to empty a container.",
);
}
}
}
var isRootRenderedBySomeReact = !!container._reactRootContainer;
var rootEl = getReactRootElementInContainer(container);
var hasNonRootReactChild = !!(rootEl && getInstanceFromNode(rootEl));
if (hasNonRootReactChild && !isRootRenderedBySomeReact) {
error(
"render(...): Replacing React-rendered children with a new root " +
"component. If you intended to update the children of this node, " +
"you should instead have the existing children update their state " +
"and render the new components instead of calling ReactDOM.render.",
);
}
if (
container.nodeType === ELEMENT_NODE &&
container.tagName &&
container.tagName.toUpperCase() === "BODY"
) {
error(
"render(): Rendering components directly into document.body is " +
"discouraged, since its children are often manipulated by third-party " +
"scripts and browser extensions. This may lead to subtle " +
"reconciliation issues. Try rendering into a container element created " +
"for your app.",
);
}
};
}
function getReactRootElementInContainer(container) {
if (!container) {
return null;
}
if (container.nodeType === DOCUMENT_NODE) {
return container.documentElement;
} else {
return container.firstChild;
}
}
function shouldHydrateDueToLegacyHeuristic(container) {
var rootElement = getReactRootElementInContainer(container);
return !!(
rootElement &&
rootElement.nodeType === ELEMENT_NODE &&
rootElement.hasAttribute(ROOT_ATTRIBUTE_NAME)
);
}
function legacyCreateRootFromDOMContainer(container, forceHydrate) {
var shouldHydrate =
forceHydrate || shouldHydrateDueToLegacyHeuristic(container); // First clear any existing content.
if (!shouldHydrate) {
var warned = false;
var rootSibling;
while ((rootSibling = container.lastChild)) {
{
if (
!warned &&
rootSibling.nodeType === ELEMENT_NODE &&
rootSibling.hasAttribute(ROOT_ATTRIBUTE_NAME)
) {
warned = true;
error(
"render(): Target node has markup rendered by React, but there " +
"are unrelated nodes as well. This is most commonly caused by " +
"white-space inserted around server-rendered markup.",
);
}
}
container.removeChild(rootSibling);
}
}
{
if (shouldHydrate && !forceHydrate && !warnedAboutHydrateAPI) {
warnedAboutHydrateAPI = true;
warn(
"render(): Calling ReactDOM.render() to hydrate server-rendered markup " +
"will stop working in React v18. Replace the ReactDOM.render() call " +
"with ReactDOM.hydrate() if you want React to attach to the server HTML.",
);
}
}
return createLegacyRoot(
container,
shouldHydrate
? {
hydrate: true,
}
: undefined,
);
}
function warnOnInvalidCallback$1(callback, callerName) {
{
if (callback !== null && typeof callback !== "function") {
error(
"%s(...): Expected the last optional `callback` argument to be a " +
"function. Instead received: %s.",
callerName,
callback,
);
}
}
}
function legacyRenderSubtreeIntoContainer(
parentComponent,
children,
container,
forceHydrate,
callback,
) {
{
topLevelUpdateWarnings(container);
warnOnInvalidCallback$1(
callback === undefined ? null : callback,
"render",
);
} // TODO: Without `any` type, Flow says "Property cannot be accessed on any
// member of intersection type." Whyyyyyy.
var root = container._reactRootContainer;
var fiberRoot;
if (!root) {
// Initial mount
root = container._reactRootContainer = legacyCreateRootFromDOMContainer(
container,
forceHydrate,
);
fiberRoot = root._internalRoot;
if (typeof callback === "function") {
var originalCallback = callback;
callback = function () {
var instance = getPublicRootInstance(fiberRoot);
originalCallback.call(instance);
};
} // Initial mount should not be batched.
unbatchedUpdates(function () {
updateContainer(children, fiberRoot, parentComponent, callback);
});
} else {
fiberRoot = root._internalRoot;
if (typeof callback === "function") {
var _originalCallback = callback;
callback = function () {
var instance = getPublicRootInstance(fiberRoot);
_originalCallback.call(instance);
};
} // Update
updateContainer(children, fiberRoot, parentComponent, callback);
}
return getPublicRootInstance(fiberRoot);
}
function findDOMNode(componentOrElement) {
{
var owner = ReactCurrentOwner$3.current;
if (owner !== null && owner.stateNode !== null) {
var warnedAboutRefsInRender = owner.stateNode._warnedAboutRefsInRender;
if (!warnedAboutRefsInRender) {
error(
"%s is accessing findDOMNode inside its render(). " +
"render() should be a pure function of props and state. It should " +
"never access something that requires stale data from the previous " +
"render, such as refs. Move this logic to componentDidMount and " +
"componentDidUpdate instead.",
getComponentName(owner.type) || "A component",
);
}
owner.stateNode._warnedAboutRefsInRender = true;
}
}
if (componentOrElement == null) {
return null;
}
if (componentOrElement.nodeType === ELEMENT_NODE) {
return componentOrElement;
}
{
return findHostInstanceWithWarning(componentOrElement, "findDOMNode");
}
}
function hydrate(element, container, callback) {
if (!isValidContainer(container)) {
{
throw Error("Target container is not a DOM element.");
}
}
{
var isModernRoot =
isContainerMarkedAsRoot(container) &&
container._reactRootContainer === undefined;
if (isModernRoot) {
error(
"You are calling ReactDOM.hydrate() on a container that was previously " +
"passed to ReactDOM.createRoot(). This is not supported. " +
"Did you mean to call createRoot(container, {hydrate: true}).render(element)?",
);
}
} // TODO: throw or warn if we couldn't hydrate?
return legacyRenderSubtreeIntoContainer(
null,
element,
container,
true,
callback,
);
}
function render(element, container, callback) {
if (!isValidContainer(container)) {
{
throw Error("Target container is not a DOM element.");
}
}
{
var isModernRoot =
isContainerMarkedAsRoot(container) &&
container._reactRootContainer === undefined;
if (isModernRoot) {
error(
"You are calling ReactDOM.render() on a container that was previously " +
"passed to ReactDOM.createRoot(). This is not supported. " +
"Did you mean to call root.render(element)?",
);
}
}
return legacyRenderSubtreeIntoContainer(
null,
element,
container,
false,
callback,
);
}
function unstable_renderSubtreeIntoContainer(
parentComponent,
element,
containerNode,
callback,
) {
if (!isValidContainer(containerNode)) {
{
throw Error("Target container is not a DOM element.");
}
}
if (!(parentComponent != null && has(parentComponent))) {
{
throw Error("parentComponent must be a valid React Component");
}
}
return legacyRenderSubtreeIntoContainer(
parentComponent,
element,
containerNode,
false,
callback,
);
}
function unmountComponentAtNode(container) {
if (!isValidContainer(container)) {
{
throw Error(
"unmountComponentAtNode(...): Target container is not a DOM element.",
);
}
}
{
var isModernRoot =
isContainerMarkedAsRoot(container) &&
container._reactRootContainer === undefined;
if (isModernRoot) {
error(
"You are calling ReactDOM.unmountComponentAtNode() on a container that was previously " +
"passed to ReactDOM.createRoot(). This is not supported. Did you mean to call root.unmount()?",
);
}
}
if (container._reactRootContainer) {
{
var rootEl = getReactRootElementInContainer(container);
var renderedByDifferentReact = rootEl && !getInstanceFromNode(rootEl);
if (renderedByDifferentReact) {
error(
"unmountComponentAtNode(): The node you're attempting to unmount " +
"was rendered by another copy of React.",
);
}
} // Unmount should not be batched.
unbatchedUpdates(function () {
legacyRenderSubtreeIntoContainer(
null,
null,
container,
false,
function () {
// $FlowFixMe This should probably use `delete container._reactRootContainer`
container._reactRootContainer = null;
unmarkContainerAsRoot(container);
},
);
}); // If you call unmountComponentAtNode twice in quick succession, you'll
// get `true` twice. That's probably fine?
return true;
} else {
{
var _rootEl = getReactRootElementInContainer(container);
var hasNonRootReactChild = !!(_rootEl && getInstanceFromNode(_rootEl)); // Check if the container itself is a React root node.
var isContainerReactRoot =
container.nodeType === ELEMENT_NODE &&
isValidContainer(container.parentNode) &&
!!container.parentNode._reactRootContainer;
if (hasNonRootReactChild) {
error(
"unmountComponentAtNode(): The node you're attempting to unmount " +
"was rendered by React and is not a top-level container. %s",
isContainerReactRoot
? "You may have accidentally passed in a React root node instead " +
"of its container."
: "Instead, have the parent component update its state and " +
"rerender in order to remove this component.",
);
}
}
return false;
}
}
setAttemptUserBlockingHydration(attemptUserBlockingHydration$1);
setAttemptContinuousHydration(attemptContinuousHydration$1);
setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);
setAttemptHydrationAtPriority(runWithPriority$2);
var didWarnAboutUnstableCreatePortal = false;
{
if (
typeof Map !== "function" || // $FlowIssue Flow incorrectly thinks Map has no prototype
Map.prototype == null ||
typeof Map.prototype.forEach !== "function" ||
typeof Set !== "function" || // $FlowIssue Flow incorrectly thinks Set has no prototype
Set.prototype == null ||
typeof Set.prototype.clear !== "function" ||
typeof Set.prototype.forEach !== "function"
) {
error(
"React depends on Map and Set built-in types. Make sure that you load a " +
"polyfill in older browsers. https://reactjs.org/link/react-polyfills",
);
}
}
setRestoreImplementation(restoreControlledState$3);
setBatchingImplementation(
batchedUpdates$1,
discreteUpdates$1,
flushDiscreteUpdates,
batchedEventUpdates$1,
);
function createPortal$1(children, container) {
var key =
arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
if (!isValidContainer(container)) {
{
throw Error("Target container is not a DOM element.");
}
} // TODO: pass ReactDOM portal implementation as third argument
// $FlowFixMe The Flow type is opaque but there's no way to actually create it.
return createPortal(children, container, null, key);
}
function renderSubtreeIntoContainer(
parentComponent,
element,
containerNode,
callback,
) {
return unstable_renderSubtreeIntoContainer(
parentComponent,
element,
containerNode,
callback,
);
}
function unstable_createPortal(children, container) {
var key =
arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
{
if (!didWarnAboutUnstableCreatePortal) {
didWarnAboutUnstableCreatePortal = true;
warn(
"The ReactDOM.unstable_createPortal() alias has been deprecated, " +
"and will be removed in React 18+. Update your code to use " +
"ReactDOM.createPortal() instead. It has the exact same API, " +
'but without the "unstable_" prefix.',
);
}
}
return createPortal$1(children, container, key);
}
var Internals = {
// Keep in sync with ReactTestUtils.js, and ReactTestUtilsAct.js.
// This is an array for better minification.
Events: [
getInstanceFromNode,
getNodeFromInstance,
getFiberCurrentPropsFromNode,
enqueueStateRestore,
restoreStateIfNeeded,
flushPassiveEffects, // TODO: This is related to `act`, not events. Move to separate key?
IsThisRendererActing,
],
};
var foundDevTools = injectIntoDevTools({
findFiberByHostInstance: getClosestInstanceFromNode,
bundleType: 1,
version: ReactVersion,
rendererPackageName: "react-dom",
});
{
if (!foundDevTools && canUseDOM && window.top === window.self) {
// If we're in Chrome or Firefox, provide a download link if not installed.
if (
(navigator.userAgent.indexOf("Chrome") > -1 &&
navigator.userAgent.indexOf("Edge") === -1) ||
navigator.userAgent.indexOf("Firefox") > -1
) {
var protocol = window.location.protocol; // Don't warn in exotic cases like chrome-extension://.
if (/^(https?|file):$/.test(protocol)) {
// eslint-disable-next-line react-internal/no-production-logging
console.info(
"%cDownload the React DevTools " +
"for a better development experience: " +
"https://reactjs.org/link/react-devtools" +
(protocol === "file:"
? "\nYou might need to use a local HTTP server (instead of file://): " +
"https://reactjs.org/link/react-devtools-faq"
: ""),
"font-weight:bold",
);
}
}
}
}
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
exports.createPortal = createPortal$1;
exports.findDOMNode = findDOMNode;
exports.flushSync = flushSync;
exports.hydrate = hydrate;
exports.render = render;
exports.unmountComponentAtNode = unmountComponentAtNode;
exports.unstable_batchedUpdates = batchedUpdates$1;
exports.unstable_createPortal = unstable_createPortal;
exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
exports.version = ReactVersion;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/underscore-1.5.2.js | JavaScript | // Underscore.js 1.5.2
// http://underscorejs.org
// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Underscore may be freely distributed under the MIT license.
(function () {
// Baseline setup
// --------------
// Establish the root object, `window` in the browser, or `exports` on the server.
var root = this;
// Save the previous value of the `_` variable.
var previousUnderscore = root._;
// Establish the object that gets returned to break out of a loop iteration.
var breaker = {};
// Save bytes in the minified (but not gzipped) version:
var ArrayProto = Array.prototype,
ObjProto = Object.prototype,
FuncProto = Function.prototype;
// Create quick reference variables for speed access to core prototypes.
var push = ArrayProto.push,
slice = ArrayProto.slice,
concat = ArrayProto.concat,
toString = ObjProto.toString,
hasOwnProperty = ObjProto.hasOwnProperty;
// All **ECMAScript 5** native function implementations that we hope to use
// are declared here.
var nativeForEach = ArrayProto.forEach,
nativeMap = ArrayProto.map,
nativeReduce = ArrayProto.reduce,
nativeReduceRight = ArrayProto.reduceRight,
nativeFilter = ArrayProto.filter,
nativeEvery = ArrayProto.every,
nativeSome = ArrayProto.some,
nativeIndexOf = ArrayProto.indexOf,
nativeLastIndexOf = ArrayProto.lastIndexOf,
nativeIsArray = Array.isArray,
nativeKeys = Object.keys,
nativeBind = FuncProto.bind;
// Create a safe reference to the Underscore object for use below.
var _ = function (obj) {
if (obj instanceof _) return obj;
if (!(this instanceof _)) return new _(obj);
this._wrapped = obj;
};
// Export the Underscore object for **Node.js**, with
// backwards-compatibility for the old `require()` API. If we're in
// the browser, add `_` as a global object via a string identifier,
// for Closure Compiler "advanced" mode.
if (typeof exports !== "undefined") {
if (typeof module !== "undefined" && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} else {
root._ = _;
}
// Current version.
_.VERSION = "1.5.2";
// Collection Functions
// --------------------
// The cornerstone, an `each` implementation, aka `forEach`.
// Handles objects with the built-in `forEach`, arrays, and raw objects.
// Delegates to **ECMAScript 5**'s native `forEach` if available.
var each =
(_.each =
_.forEach =
function (obj, iterator, context) {
if (obj == null) return;
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context);
} else if (obj.length === +obj.length) {
for (var i = 0, length = obj.length; i < length; i++) {
if (iterator.call(context, obj[i], i, obj) === breaker) return;
}
} else {
var keys = _.keys(obj);
for (var i = 0, length = keys.length; i < length; i++) {
if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker)
return;
}
}
});
// Return the results of applying the iterator to each element.
// Delegates to **ECMAScript 5**'s native `map` if available.
_.map = _.collect = function (obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
each(obj, function (value, index, list) {
results.push(iterator.call(context, value, index, list));
});
return results;
};
var reduceError = "Reduce of empty array with no initial value";
// **Reduce** builds up a single result from a list of values, aka `inject`,
// or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
_.reduce =
_.foldl =
_.inject =
function (obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (obj == null) obj = [];
if (nativeReduce && obj.reduce === nativeReduce) {
if (context) iterator = _.bind(iterator, context);
return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
}
each(obj, function (value, index, list) {
if (!initial) {
memo = value;
initial = true;
} else {
memo = iterator.call(context, memo, value, index, list);
}
});
if (!initial) throw new TypeError(reduceError);
return memo;
};
// The right-associative version of reduce, also known as `foldr`.
// Delegates to **ECMAScript 5**'s native `reduceRight` if available.
_.reduceRight = _.foldr = function (obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (obj == null) obj = [];
if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
if (context) iterator = _.bind(iterator, context);
return initial
? obj.reduceRight(iterator, memo)
: obj.reduceRight(iterator);
}
var length = obj.length;
if (length !== +length) {
var keys = _.keys(obj);
length = keys.length;
}
each(obj, function (value, index, list) {
index = keys ? keys[--length] : --length;
if (!initial) {
memo = obj[index];
initial = true;
} else {
memo = iterator.call(context, memo, obj[index], index, list);
}
});
if (!initial) throw new TypeError(reduceError);
return memo;
};
// Return the first value which passes a truth test. Aliased as `detect`.
_.find = _.detect = function (obj, iterator, context) {
var result;
any(obj, function (value, index, list) {
if (iterator.call(context, value, index, list)) {
result = value;
return true;
}
});
return result;
};
// Return all the elements that pass a truth test.
// Delegates to **ECMAScript 5**'s native `filter` if available.
// Aliased as `select`.
_.filter = _.select = function (obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeFilter && obj.filter === nativeFilter)
return obj.filter(iterator, context);
each(obj, function (value, index, list) {
if (iterator.call(context, value, index, list)) results.push(value);
});
return results;
};
// Return all the elements for which a truth test fails.
_.reject = function (obj, iterator, context) {
return _.filter(
obj,
function (value, index, list) {
return !iterator.call(context, value, index, list);
},
context,
);
};
// Determine whether all of the elements match a truth test.
// Delegates to **ECMAScript 5**'s native `every` if available.
// Aliased as `all`.
_.every = _.all = function (obj, iterator, context) {
iterator || (iterator = _.identity);
var result = true;
if (obj == null) return result;
if (nativeEvery && obj.every === nativeEvery)
return obj.every(iterator, context);
each(obj, function (value, index, list) {
if (!(result = result && iterator.call(context, value, index, list)))
return breaker;
});
return !!result;
};
// Determine if at least one element in the object matches a truth test.
// Delegates to **ECMAScript 5**'s native `some` if available.
// Aliased as `any`.
var any =
(_.some =
_.any =
function (obj, iterator, context) {
iterator || (iterator = _.identity);
var result = false;
if (obj == null) return result;
if (nativeSome && obj.some === nativeSome)
return obj.some(iterator, context);
each(obj, function (value, index, list) {
if (result || (result = iterator.call(context, value, index, list)))
return breaker;
});
return !!result;
});
// Determine if the array or object contains a given value (using `===`).
// Aliased as `include`.
_.contains = _.include = function (obj, target) {
if (obj == null) return false;
if (nativeIndexOf && obj.indexOf === nativeIndexOf)
return obj.indexOf(target) != -1;
return any(obj, function (value) {
return value === target;
});
};
// Invoke a method (with arguments) on every item in a collection.
_.invoke = function (obj, method) {
var args = slice.call(arguments, 2);
var isFunc = _.isFunction(method);
return _.map(obj, function (value) {
return (isFunc ? method : value[method]).apply(value, args);
});
};
// Convenience version of a common use case of `map`: fetching a property.
_.pluck = function (obj, key) {
return _.map(obj, function (value) {
return value[key];
});
};
// Convenience version of a common use case of `filter`: selecting only objects
// containing specific `key:value` pairs.
_.where = function (obj, attrs, first) {
if (_.isEmpty(attrs)) return first ? void 0 : [];
return _[first ? "find" : "filter"](obj, function (value) {
for (var key in attrs) {
if (attrs[key] !== value[key]) return false;
}
return true;
});
};
// Convenience version of a common use case of `find`: getting the first object
// containing specific `key:value` pairs.
_.findWhere = function (obj, attrs) {
return _.where(obj, attrs, true);
};
// Return the maximum element or (element-based computation).
// Can't optimize arrays of integers longer than 65,535 elements.
// See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
_.max = function (obj, iterator, context) {
if (
!iterator &&
_.isArray(obj) &&
obj[0] === +obj[0] &&
obj.length < 65535
) {
return Math.max.apply(Math, obj);
}
if (!iterator && _.isEmpty(obj)) return -Infinity;
var result = { computed: -Infinity, value: -Infinity };
each(obj, function (value, index, list) {
var computed = iterator
? iterator.call(context, value, index, list)
: value;
computed > result.computed &&
(result = { value: value, computed: computed });
});
return result.value;
};
// Return the minimum element (or element-based computation).
_.min = function (obj, iterator, context) {
if (
!iterator &&
_.isArray(obj) &&
obj[0] === +obj[0] &&
obj.length < 65535
) {
return Math.min.apply(Math, obj);
}
if (!iterator && _.isEmpty(obj)) return Infinity;
var result = { computed: Infinity, value: Infinity };
each(obj, function (value, index, list) {
var computed = iterator
? iterator.call(context, value, index, list)
: value;
computed < result.computed &&
(result = { value: value, computed: computed });
});
return result.value;
};
// Shuffle an array, using the modern version of the
// [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
_.shuffle = function (obj) {
var rand;
var index = 0;
var shuffled = [];
each(obj, function (value) {
rand = _.random(index++);
shuffled[index - 1] = shuffled[rand];
shuffled[rand] = value;
});
return shuffled;
};
// Sample **n** random values from an array.
// If **n** is not specified, returns a single random element from the array.
// The internal `guard` argument allows it to work with `map`.
_.sample = function (obj, n, guard) {
if (arguments.length < 2 || guard) {
return obj[_.random(obj.length - 1)];
}
return _.shuffle(obj).slice(0, Math.max(0, n));
};
// An internal function to generate lookup iterators.
var lookupIterator = function (value) {
return _.isFunction(value)
? value
: function (obj) {
return obj[value];
};
};
// Sort the object's values by a criterion produced by an iterator.
_.sortBy = function (obj, value, context) {
var iterator = lookupIterator(value);
return _.pluck(
_.map(obj, function (value, index, list) {
return {
value: value,
index: index,
criteria: iterator.call(context, value, index, list),
};
}).sort(function (left, right) {
var a = left.criteria;
var b = right.criteria;
if (a !== b) {
if (a > b || a === void 0) return 1;
if (a < b || b === void 0) return -1;
}
return left.index - right.index;
}),
"value",
);
};
// An internal function used for aggregate "group by" operations.
var group = function (behavior) {
return function (obj, value, context) {
var result = {};
var iterator = value == null ? _.identity : lookupIterator(value);
each(obj, function (value, index) {
var key = iterator.call(context, value, index, obj);
behavior(result, key, value);
});
return result;
};
};
// Groups the object's values by a criterion. Pass either a string attribute
// to group by, or a function that returns the criterion.
_.groupBy = group(function (result, key, value) {
(_.has(result, key) ? result[key] : (result[key] = [])).push(value);
});
// Indexes the object's values by a criterion, similar to `groupBy`, but for
// when you know that your index values will be unique.
_.indexBy = group(function (result, key, value) {
result[key] = value;
});
// Counts instances of an object that group by a certain criterion. Pass
// either a string attribute to count by, or a function that returns the
// criterion.
_.countBy = group(function (result, key) {
_.has(result, key) ? result[key]++ : (result[key] = 1);
});
// Use a comparator function to figure out the smallest index at which
// an object should be inserted so as to maintain order. Uses binary search.
_.sortedIndex = function (array, obj, iterator, context) {
iterator = iterator == null ? _.identity : lookupIterator(iterator);
var value = iterator.call(context, obj);
var low = 0,
high = array.length;
while (low < high) {
var mid = (low + high) >>> 1;
iterator.call(context, array[mid]) < value
? (low = mid + 1)
: (high = mid);
}
return low;
};
// Safely create a real, live array from anything iterable.
_.toArray = function (obj) {
if (!obj) return [];
if (_.isArray(obj)) return slice.call(obj);
if (obj.length === +obj.length) return _.map(obj, _.identity);
return _.values(obj);
};
// Return the number of elements in an object.
_.size = function (obj) {
if (obj == null) return 0;
return obj.length === +obj.length ? obj.length : _.keys(obj).length;
};
// Array Functions
// ---------------
// Get the first element of an array. Passing **n** will return the first N
// values in the array. Aliased as `head` and `take`. The **guard** check
// allows it to work with `_.map`.
_.first =
_.head =
_.take =
function (array, n, guard) {
if (array == null) return void 0;
return n == null || guard ? array[0] : slice.call(array, 0, n);
};
// Returns everything but the last entry of the array. Especially useful on
// the arguments object. Passing **n** will return all the values in
// the array, excluding the last N. The **guard** check allows it to work with
// `_.map`.
_.initial = function (array, n, guard) {
return slice.call(array, 0, array.length - (n == null || guard ? 1 : n));
};
// Get the last element of an array. Passing **n** will return the last N
// values in the array. The **guard** check allows it to work with `_.map`.
_.last = function (array, n, guard) {
if (array == null) return void 0;
if (n == null || guard) {
return array[array.length - 1];
} else {
return slice.call(array, Math.max(array.length - n, 0));
}
};
// Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
// Especially useful on the arguments object. Passing an **n** will return
// the rest N values in the array. The **guard**
// check allows it to work with `_.map`.
_.rest =
_.tail =
_.drop =
function (array, n, guard) {
return slice.call(array, n == null || guard ? 1 : n);
};
// Trim out all falsy values from an array.
_.compact = function (array) {
return _.filter(array, _.identity);
};
// Internal implementation of a recursive `flatten` function.
var flatten = function (input, shallow, output) {
if (shallow && _.every(input, _.isArray)) {
return concat.apply(output, input);
}
each(input, function (value) {
if (_.isArray(value) || _.isArguments(value)) {
shallow ? push.apply(output, value) : flatten(value, shallow, output);
} else {
output.push(value);
}
});
return output;
};
// Flatten out an array, either recursively (by default), or just one level.
_.flatten = function (array, shallow) {
return flatten(array, shallow, []);
};
// Return a version of the array that does not contain the specified value(s).
_.without = function (array) {
return _.difference(array, slice.call(arguments, 1));
};
// Produce a duplicate-free version of the array. If the array has already
// been sorted, you have the option of using a faster algorithm.
// Aliased as `unique`.
_.uniq = _.unique = function (array, isSorted, iterator, context) {
if (_.isFunction(isSorted)) {
context = iterator;
iterator = isSorted;
isSorted = false;
}
var initial = iterator ? _.map(array, iterator, context) : array;
var results = [];
var seen = [];
each(initial, function (value, index) {
if (
isSorted
? !index || seen[seen.length - 1] !== value
: !_.contains(seen, value)
) {
seen.push(value);
results.push(array[index]);
}
});
return results;
};
// Produce an array that contains the union: each distinct element from all of
// the passed-in arrays.
_.union = function () {
return _.uniq(_.flatten(arguments, true));
};
// Produce an array that contains every item shared between all the
// passed-in arrays.
_.intersection = function (array) {
var rest = slice.call(arguments, 1);
return _.filter(_.uniq(array), function (item) {
return _.every(rest, function (other) {
return _.indexOf(other, item) >= 0;
});
});
};
// Take the difference between one array and a number of other arrays.
// Only the elements present in just the first array will remain.
_.difference = function (array) {
var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
return _.filter(array, function (value) {
return !_.contains(rest, value);
});
};
// Zip together multiple lists into a single array -- elements that share
// an index go together.
_.zip = function () {
var length = _.max(_.pluck(arguments, "length").concat(0));
var results = new Array(length);
for (var i = 0; i < length; i++) {
results[i] = _.pluck(arguments, "" + i);
}
return results;
};
// Converts lists into objects. Pass either a single array of `[key, value]`
// pairs, or two parallel arrays of the same length -- one of keys, and one of
// the corresponding values.
_.object = function (list, values) {
if (list == null) return {};
var result = {};
for (var i = 0, length = list.length; i < length; i++) {
if (values) {
result[list[i]] = values[i];
} else {
result[list[i][0]] = list[i][1];
}
}
return result;
};
// If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
// we need this function. Return the position of the first occurrence of an
// item in an array, or -1 if the item is not included in the array.
// Delegates to **ECMAScript 5**'s native `indexOf` if available.
// If the array is large and already in sort order, pass `true`
// for **isSorted** to use binary search.
_.indexOf = function (array, item, isSorted) {
if (array == null) return -1;
var i = 0,
length = array.length;
if (isSorted) {
if (typeof isSorted == "number") {
i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
} else {
i = _.sortedIndex(array, item);
return array[i] === item ? i : -1;
}
}
if (nativeIndexOf && array.indexOf === nativeIndexOf)
return array.indexOf(item, isSorted);
for (; i < length; i++) if (array[i] === item) return i;
return -1;
};
// Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
_.lastIndexOf = function (array, item, from) {
if (array == null) return -1;
var hasIndex = from != null;
if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
}
var i = hasIndex ? from : array.length;
while (i--) if (array[i] === item) return i;
return -1;
};
// Generate an integer Array containing an arithmetic progression. A port of
// the native Python `range()` function. See
// [the Python documentation](http://docs.python.org/library/functions.html#range).
_.range = function (start, stop, step) {
if (arguments.length <= 1) {
stop = start || 0;
start = 0;
}
step = arguments[2] || 1;
var length = Math.max(Math.ceil((stop - start) / step), 0);
var idx = 0;
var range = new Array(length);
while (idx < length) {
range[idx++] = start;
start += step;
}
return range;
};
// Function (ahem) Functions
// ------------------
// Reusable constructor function for prototype setting.
var ctor = function () {};
// Create a function bound to a given object (assigning `this`, and arguments,
// optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
// available.
_.bind = function (func, context) {
var args, bound;
if (nativeBind && func.bind === nativeBind)
return nativeBind.apply(func, slice.call(arguments, 1));
if (!_.isFunction(func)) throw new TypeError();
args = slice.call(arguments, 2);
return (bound = function () {
if (!(this instanceof bound))
return func.apply(context, args.concat(slice.call(arguments)));
ctor.prototype = func.prototype;
var self = new ctor();
ctor.prototype = null;
var result = func.apply(self, args.concat(slice.call(arguments)));
if (Object(result) === result) return result;
return self;
});
};
// Partially apply a function by creating a version that has had some of its
// arguments pre-filled, without changing its dynamic `this` context.
_.partial = function (func) {
var args = slice.call(arguments, 1);
return function () {
return func.apply(this, args.concat(slice.call(arguments)));
};
};
// Bind all of an object's methods to that object. Useful for ensuring that
// all callbacks defined on an object belong to it.
_.bindAll = function (obj) {
var funcs = slice.call(arguments, 1);
if (funcs.length === 0)
throw new Error("bindAll must be passed function names");
each(funcs, function (f) {
obj[f] = _.bind(obj[f], obj);
});
return obj;
};
// Memoize an expensive function by storing its results.
_.memoize = function (func, hasher) {
var memo = {};
hasher || (hasher = _.identity);
return function () {
var key = hasher.apply(this, arguments);
return _.has(memo, key)
? memo[key]
: (memo[key] = func.apply(this, arguments));
};
};
// Delays a function for the given number of milliseconds, and then calls
// it with the arguments supplied.
_.delay = function (func, wait) {
var args = slice.call(arguments, 2);
return setTimeout(function () {
return func.apply(null, args);
}, wait);
};
// Defers a function, scheduling it to run after the current call stack has
// cleared.
_.defer = function (func) {
return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
};
// Returns a function, that, when invoked, will only be triggered at most once
// during a given window of time. Normally, the throttled function will run
// as much as it can, without ever going more than once per `wait` duration;
// but if you'd like to disable the execution on the leading edge, pass
// `{leading: false}`. To disable execution on the trailing edge, ditto.
_.throttle = function (func, wait, options) {
var context, args, result;
var timeout = null;
var previous = 0;
options || (options = {});
var later = function () {
previous = options.leading === false ? 0 : new Date();
timeout = null;
result = func.apply(context, args);
};
return function () {
var now = new Date();
if (!previous && options.leading === false) previous = now;
var remaining = wait - (now - previous);
context = this;
args = arguments;
if (remaining <= 0) {
clearTimeout(timeout);
timeout = null;
previous = now;
result = func.apply(context, args);
} else if (!timeout && options.trailing !== false) {
timeout = setTimeout(later, remaining);
}
return result;
};
};
// Returns a function, that, as long as it continues to be invoked, will not
// be triggered. The function will be called after it stops being called for
// N milliseconds. If `immediate` is passed, trigger the function on the
// leading edge, instead of the trailing.
_.debounce = function (func, wait, immediate) {
var timeout, args, context, timestamp, result;
return function () {
context = this;
args = arguments;
timestamp = new Date();
var later = function () {
var last = new Date() - timestamp;
if (last < wait) {
timeout = setTimeout(later, wait - last);
} else {
timeout = null;
if (!immediate) result = func.apply(context, args);
}
};
var callNow = immediate && !timeout;
if (!timeout) {
timeout = setTimeout(later, wait);
}
if (callNow) result = func.apply(context, args);
return result;
};
};
// Returns a function that will be executed at most one time, no matter how
// often you call it. Useful for lazy initialization.
_.once = function (func) {
var ran = false,
memo;
return function () {
if (ran) return memo;
ran = true;
memo = func.apply(this, arguments);
func = null;
return memo;
};
};
// Returns the first function passed as an argument to the second,
// allowing you to adjust arguments, run code before and after, and
// conditionally execute the original function.
_.wrap = function (func, wrapper) {
return function () {
var args = [func];
push.apply(args, arguments);
return wrapper.apply(this, args);
};
};
// Returns a function that is the composition of a list of functions, each
// consuming the return value of the function that follows.
_.compose = function () {
var funcs = arguments;
return function () {
var args = arguments;
for (var i = funcs.length - 1; i >= 0; i--) {
args = [funcs[i].apply(this, args)];
}
return args[0];
};
};
// Returns a function that will only be executed after being called N times.
_.after = function (times, func) {
return function () {
if (--times < 1) {
return func.apply(this, arguments);
}
};
};
// Object Functions
// ----------------
// Retrieve the names of an object's properties.
// Delegates to **ECMAScript 5**'s native `Object.keys`
_.keys =
nativeKeys ||
function (obj) {
if (obj !== Object(obj)) throw new TypeError("Invalid object");
var keys = [];
for (var key in obj) if (_.has(obj, key)) keys.push(key);
return keys;
};
// Retrieve the values of an object's properties.
_.values = function (obj) {
var keys = _.keys(obj);
var length = keys.length;
var values = new Array(length);
for (var i = 0; i < length; i++) {
values[i] = obj[keys[i]];
}
return values;
};
// Convert an object into a list of `[key, value]` pairs.
_.pairs = function (obj) {
var keys = _.keys(obj);
var length = keys.length;
var pairs = new Array(length);
for (var i = 0; i < length; i++) {
pairs[i] = [keys[i], obj[keys[i]]];
}
return pairs;
};
// Invert the keys and values of an object. The values must be serializable.
_.invert = function (obj) {
var result = {};
var keys = _.keys(obj);
for (var i = 0, length = keys.length; i < length; i++) {
result[obj[keys[i]]] = keys[i];
}
return result;
};
// Return a sorted list of the function names available on the object.
// Aliased as `methods`
_.functions = _.methods = function (obj) {
var names = [];
for (var key in obj) {
if (_.isFunction(obj[key])) names.push(key);
}
return names.sort();
};
// Extend a given object with all the properties in passed-in object(s).
_.extend = function (obj) {
each(slice.call(arguments, 1), function (source) {
if (source) {
for (var prop in source) {
obj[prop] = source[prop];
}
}
});
return obj;
};
// Return a copy of the object only containing the whitelisted properties.
_.pick = function (obj) {
var copy = {};
var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
each(keys, function (key) {
if (key in obj) copy[key] = obj[key];
});
return copy;
};
// Return a copy of the object without the blacklisted properties.
_.omit = function (obj) {
var copy = {};
var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
for (var key in obj) {
if (!_.contains(keys, key)) copy[key] = obj[key];
}
return copy;
};
// Fill in a given object with default properties.
_.defaults = function (obj) {
each(slice.call(arguments, 1), function (source) {
if (source) {
for (var prop in source) {
if (obj[prop] === void 0) obj[prop] = source[prop];
}
}
});
return obj;
};
// Create a (shallow-cloned) duplicate of an object.
_.clone = function (obj) {
if (!_.isObject(obj)) return obj;
return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
};
// Invokes interceptor with the obj, and then returns obj.
// The primary purpose of this method is to "tap into" a method chain, in
// order to perform operations on intermediate results within the chain.
_.tap = function (obj, interceptor) {
interceptor(obj);
return obj;
};
// Internal recursive comparison function for `isEqual`.
var eq = function (a, b, aStack, bStack) {
// Identical objects are equal. `0 === -0`, but they aren't identical.
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
if (a === b) return a !== 0 || 1 / a == 1 / b;
// A strict comparison is necessary because `null == undefined`.
if (a == null || b == null) return a === b;
// Unwrap any wrapped objects.
if (a instanceof _) a = a._wrapped;
if (b instanceof _) b = b._wrapped;
// Compare `[[Class]]` names.
var className = toString.call(a);
if (className != toString.call(b)) return false;
switch (className) {
// Strings, numbers, dates, and booleans are compared by value.
case "[object String]":
// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
// equivalent to `new String("5")`.
return a == String(b);
case "[object Number]":
// `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
// other numeric values.
return a != +a ? b != +b : a == 0 ? 1 / a == 1 / b : a == +b;
case "[object Date]":
case "[object Boolean]":
// Coerce dates and booleans to numeric primitive values. Dates are compared by their
// millisecond representations. Note that invalid dates with millisecond representations
// of `NaN` are not equivalent.
return +a == +b;
// RegExps are compared by their source patterns and flags.
case "[object RegExp]":
return (
a.source == b.source &&
a.global == b.global &&
a.multiline == b.multiline &&
a.ignoreCase == b.ignoreCase
);
}
if (typeof a != "object" || typeof b != "object") return false;
// Assume equality for cyclic structures. The algorithm for detecting cyclic
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
var length = aStack.length;
while (length--) {
// Linear search. Performance is inversely proportional to the number of
// unique nested structures.
if (aStack[length] == a) return bStack[length] == b;
}
// Objects with different constructors are not equivalent, but `Object`s
// from different frames are.
var aCtor = a.constructor,
bCtor = b.constructor;
if (
aCtor !== bCtor &&
!(
_.isFunction(aCtor) &&
aCtor instanceof aCtor &&
_.isFunction(bCtor) &&
bCtor instanceof bCtor
)
) {
return false;
}
// Add the first object to the stack of traversed objects.
aStack.push(a);
bStack.push(b);
var size = 0,
result = true;
// Recursively compare objects and arrays.
if (className == "[object Array]") {
// Compare array lengths to determine if a deep comparison is necessary.
size = a.length;
result = size == b.length;
if (result) {
// Deep compare the contents, ignoring non-numeric properties.
while (size--) {
if (!(result = eq(a[size], b[size], aStack, bStack))) break;
}
}
} else {
// Deep compare objects.
for (var key in a) {
if (_.has(a, key)) {
// Count the expected number of properties.
size++;
// Deep compare each member.
if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack)))
break;
}
}
// Ensure that both objects contain the same number of properties.
if (result) {
for (key in b) {
if (_.has(b, key) && !size--) break;
}
result = !size;
}
}
// Remove the first object from the stack of traversed objects.
aStack.pop();
bStack.pop();
return result;
};
// Perform a deep comparison to check if two objects are equal.
_.isEqual = function (a, b) {
return eq(a, b, [], []);
};
// Is a given array, string, or object empty?
// An "empty" object has no enumerable own-properties.
_.isEmpty = function (obj) {
if (obj == null) return true;
if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
for (var key in obj) if (_.has(obj, key)) return false;
return true;
};
// Is a given value a DOM element?
_.isElement = function (obj) {
return !!(obj && obj.nodeType === 1);
};
// Is a given value an array?
// Delegates to ECMA5's native Array.isArray
_.isArray =
nativeIsArray ||
function (obj) {
return toString.call(obj) == "[object Array]";
};
// Is a given variable an object?
_.isObject = function (obj) {
return obj === Object(obj);
};
// Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
each(
["Arguments", "Function", "String", "Number", "Date", "RegExp"],
function (name) {
_["is" + name] = function (obj) {
return toString.call(obj) == "[object " + name + "]";
};
},
);
// Define a fallback version of the method in browsers (ahem, IE), where
// there isn't any inspectable "Arguments" type.
if (!_.isArguments(arguments)) {
_.isArguments = function (obj) {
return !!(obj && _.has(obj, "callee"));
};
}
// Optimize `isFunction` if appropriate.
if (typeof /./ !== "function") {
_.isFunction = function (obj) {
return typeof obj === "function";
};
}
// Is a given object a finite number?
_.isFinite = function (obj) {
return isFinite(obj) && !isNaN(parseFloat(obj));
};
// Is the given value `NaN`? (NaN is the only number which does not equal itself).
_.isNaN = function (obj) {
return _.isNumber(obj) && obj != +obj;
};
// Is a given value a boolean?
_.isBoolean = function (obj) {
return (
obj === true || obj === false || toString.call(obj) == "[object Boolean]"
);
};
// Is a given value equal to null?
_.isNull = function (obj) {
return obj === null;
};
// Is a given variable undefined?
_.isUndefined = function (obj) {
return obj === void 0;
};
// Shortcut function for checking if an object has a given property directly
// on itself (in other words, not on a prototype).
_.has = function (obj, key) {
return hasOwnProperty.call(obj, key);
};
// Utility Functions
// -----------------
// Run Underscore.js in *noConflict* mode, returning the `_` variable to its
// previous owner. Returns a reference to the Underscore object.
_.noConflict = function () {
root._ = previousUnderscore;
return this;
};
// Keep the identity function around for default iterators.
_.identity = function (value) {
return value;
};
// Run a function **n** times.
_.times = function (n, iterator, context) {
var accum = Array(Math.max(0, n));
for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
return accum;
};
// Return a random integer between min and max (inclusive).
_.random = function (min, max) {
if (max == null) {
max = min;
min = 0;
}
return min + Math.floor(Math.random() * (max - min + 1));
};
// List of HTML entities for escaping.
var entityMap = {
escape: {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'",
},
};
entityMap.unescape = _.invert(entityMap.escape);
// Regexes containing the keys and values listed immediately above.
var entityRegexes = {
escape: new RegExp("[" + _.keys(entityMap.escape).join("") + "]", "g"),
unescape: new RegExp("(" + _.keys(entityMap.unescape).join("|") + ")", "g"),
};
// Functions for escaping and unescaping strings to/from HTML interpolation.
_.each(["escape", "unescape"], function (method) {
_[method] = function (string) {
if (string == null) return "";
return ("" + string).replace(entityRegexes[method], function (match) {
return entityMap[method][match];
});
};
});
// If the value of the named `property` is a function then invoke it with the
// `object` as context; otherwise, return it.
_.result = function (object, property) {
if (object == null) return void 0;
var value = object[property];
return _.isFunction(value) ? value.call(object) : value;
};
// Add your own custom functions to the Underscore object.
_.mixin = function (obj) {
each(_.functions(obj), function (name) {
var func = (_[name] = obj[name]);
_.prototype[name] = function () {
var args = [this._wrapped];
push.apply(args, arguments);
return result.call(this, func.apply(_, args));
};
});
};
// Generate a unique integer id (unique within the entire client session).
// Useful for temporary DOM ids.
var idCounter = 0;
_.uniqueId = function (prefix) {
var id = ++idCounter + "";
return prefix ? prefix + id : id;
};
// By default, Underscore uses ERB-style template delimiters, change the
// following template settings to use alternative delimiters.
_.templateSettings = {
evaluate: /<%([\s\S]+?)%>/g,
interpolate: /<%=([\s\S]+?)%>/g,
escape: /<%-([\s\S]+?)%>/g,
};
// When customizing `templateSettings`, if you don't want to define an
// interpolation, evaluation or escaping regex, we need one that is
// guaranteed not to match.
var noMatch = /(.)^/;
// Certain characters need to be escaped so that they can be put into a
// string literal.
var escapes = {
"'": "'",
"\\": "\\",
"\r": "r",
"\n": "n",
"\t": "t",
"\u2028": "u2028",
"\u2029": "u2029",
};
var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
// JavaScript micro-templating, similar to John Resig's implementation.
// Underscore templating handles arbitrary delimiters, preserves whitespace,
// and correctly escapes quotes within interpolated code.
_.template = function (text, data, settings) {
var render;
settings = _.defaults({}, settings, _.templateSettings);
// Combine delimiters into one regular expression via alternation.
var matcher = new RegExp(
[
(settings.escape || noMatch).source,
(settings.interpolate || noMatch).source,
(settings.evaluate || noMatch).source,
].join("|") + "|$",
"g",
);
// Compile the template source, escaping string literals appropriately.
var index = 0;
var source = "__p+='";
text.replace(
matcher,
function (match, escape, interpolate, evaluate, offset) {
source += text.slice(index, offset).replace(escaper, function (match) {
return "\\" + escapes[match];
});
if (escape) {
source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
}
if (interpolate) {
source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
}
if (evaluate) {
source += "';\n" + evaluate + "\n__p+='";
}
index = offset + match.length;
return match;
},
);
source += "';\n";
// If a variable is not specified, place data values in local scope.
if (!settings.variable) source = "with(obj||{}){\n" + source + "}\n";
source =
"var __t,__p='',__j=Array.prototype.join," +
"print=function(){__p+=__j.call(arguments,'');};\n" +
source +
"return __p;\n";
try {
render = new Function(settings.variable || "obj", "_", source);
} catch (e) {
e.source = source;
throw e;
}
if (data) return render(data, _);
var template = function (data) {
return render.call(this, data, _);
};
// Provide the compiled function source as a convenience for precompilation.
template.source =
"function(" + (settings.variable || "obj") + "){\n" + source + "}";
return template;
};
// Add a "chain" function, which will delegate to the wrapper.
_.chain = function (obj) {
return _(obj).chain();
};
// OOP
// ---------------
// If Underscore is called as a function, it returns a wrapped object that
// can be used OO-style. This wrapper holds altered versions of all the
// underscore functions. Wrapped objects may be chained.
// Helper function to continue chaining intermediate results.
var result = function (obj) {
return this._chain ? _(obj).chain() : obj;
};
// Add all of the Underscore functions to the wrapper object.
_.mixin(_);
// Add all mutator Array functions to the wrapper.
each(
["pop", "push", "reverse", "shift", "sort", "splice", "unshift"],
function (name) {
var method = ArrayProto[name];
_.prototype[name] = function () {
var obj = this._wrapped;
method.apply(obj, arguments);
if ((name == "shift" || name == "splice") && obj.length === 0)
delete obj[0];
return result.call(this, obj);
};
},
);
// Add all accessor Array functions to the wrapper.
each(["concat", "join", "slice"], function (name) {
var method = ArrayProto[name];
_.prototype[name] = function () {
return result.call(this, method.apply(this._wrapped, arguments));
};
});
_.extend(_.prototype, {
// Start chaining a wrapped Underscore object.
chain: function () {
this._chain = true;
return this;
},
// Extracts the result from a wrapped and chained object.
value: function () {
return this._wrapped;
},
});
}.call(this));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/files/yui-3.12.0.js | JavaScript | /*
YUI 3.12.0 (build 8655935)
Copyright 2013 Yahoo! Inc. All rights reserved.
Licensed under the BSD License.
http://yuilibrary.com/license/
*/
/**
The YUI module contains the components required for building the YUI seed file.
This includes the script loading mechanism, a simple queue, and the core
utilities for the library.
@module yui
@main yui
@submodule yui-base
**/
/*jshint eqeqeq: false*/
if (typeof YUI != "undefined") {
YUI._YUI = YUI;
}
/**
The YUI global namespace object. This is the constructor for all YUI instances.
This is a self-instantiable factory function, meaning you don't need to precede
it with the `new` operator. You can invoke it directly like this:
YUI().use('*', function (Y) {
// Y is a new YUI instance.
});
But it also works like this:
var Y = YUI();
The `YUI` constructor accepts an optional config object, like this:
YUI({
debug: true,
combine: false
}).use('node', function (Y) {
// Y.Node is ready to use.
});
See the API docs for the <a href="config.html">Config</a> class for the complete
list of supported configuration properties accepted by the YUI constuctor.
If a global `YUI` object is already defined, the existing YUI object will not be
overwritten, to ensure that defined namespaces are preserved.
Each YUI instance has full custom event support, but only if the event system is
available.
@class YUI
@uses EventTarget
@constructor
@global
@param {Object} [config]* Zero or more optional configuration objects. Config
values are stored in the `Y.config` property. See the
<a href="config.html">Config</a> docs for the list of supported properties.
**/
/*global YUI*/
/*global YUI_config*/
var YUI = function () {
var i = 0,
Y = this,
args = arguments,
l = args.length,
instanceOf = function (o, type) {
return o && o.hasOwnProperty && o instanceof type;
},
gconf = typeof YUI_config !== "undefined" && YUI_config;
if (!instanceOf(Y, YUI)) {
Y = new YUI();
} else {
// set up the core environment
Y._init();
/**
Master configuration that might span multiple contexts in a non-
browser environment. It is applied first to all instances in all
contexts.
@example
YUI.GlobalConfig = {
filter: 'debug'
};
YUI().use('node', function (Y) {
// debug files used here
});
YUI({
filter: 'min'
}).use('node', function (Y) {
// min files used here
});
@property {Object} GlobalConfig
@global
@static
**/
if (YUI.GlobalConfig) {
Y.applyConfig(YUI.GlobalConfig);
}
/**
Page-level config applied to all YUI instances created on the
current page. This is applied after `YUI.GlobalConfig` and before
any instance-level configuration.
@example
// Single global var to include before YUI seed file
YUI_config = {
filter: 'debug'
};
YUI().use('node', function (Y) {
// debug files used here
});
YUI({
filter: 'min'
}).use('node', function (Y) {
// min files used here
});
@property {Object} YUI_config
@global
**/
if (gconf) {
Y.applyConfig(gconf);
}
// bind the specified additional modules for this instance
if (!l) {
Y._setup();
}
}
if (l) {
// Each instance can accept one or more configuration objects.
// These are applied after YUI.GlobalConfig and YUI_Config,
// overriding values set in those config files if there is a
// matching property.
for (; i < l; i++) {
Y.applyConfig(args[i]);
}
Y._setup();
}
Y.instanceOf = instanceOf;
return Y;
};
(function () {
var proto,
prop,
VERSION = "3.12.0",
PERIOD = ".",
BASE = "http://yui.yahooapis.com/",
/*
These CSS class names can't be generated by
getClassName since it is not available at the
time they are being used.
*/
DOC_LABEL = "yui3-js-enabled",
CSS_STAMP_EL = "yui3-css-stamp",
NOOP = function () {},
SLICE = Array.prototype.slice,
APPLY_TO_AUTH = {
"io.xdrReady": 1, // the functions applyTo
"io.xdrResponse": 1, // can call. this should
"SWF.eventHandler": 1,
}, // be done at build time
hasWin = typeof window != "undefined",
win = hasWin ? window : null,
doc = hasWin ? win.document : null,
docEl = doc && doc.documentElement,
docClass = docEl && docEl.className,
instances = {},
time = new Date().getTime(),
add = function (el, type, fn, capture) {
if (el && el.addEventListener) {
el.addEventListener(type, fn, capture);
} else if (el && el.attachEvent) {
el.attachEvent("on" + type, fn);
}
},
remove = function (el, type, fn, capture) {
if (el && el.removeEventListener) {
// this can throw an uncaught exception in FF
try {
el.removeEventListener(type, fn, capture);
} catch (ex) {}
} else if (el && el.detachEvent) {
el.detachEvent("on" + type, fn);
}
},
handleLoad = function () {
YUI.Env.windowLoaded = true;
YUI.Env.DOMReady = true;
if (hasWin) {
remove(window, "load", handleLoad);
}
},
getLoader = function (Y, o) {
var loader = Y.Env._loader,
lCore = ["loader-base"],
G_ENV = YUI.Env,
mods = G_ENV.mods;
if (loader) {
//loader._config(Y.config);
loader.ignoreRegistered = false;
loader.onEnd = null;
loader.data = null;
loader.required = [];
loader.loadType = null;
} else {
loader = new Y.Loader(Y.config);
Y.Env._loader = loader;
}
if (mods && mods.loader) {
lCore = [].concat(lCore, YUI.Env.loaderExtras);
}
YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, lCore));
return loader;
},
clobber = function (r, s) {
for (var i in s) {
if (s.hasOwnProperty(i)) {
r[i] = s[i];
}
}
},
ALREADY_DONE = { success: true };
// Stamp the documentElement (HTML) with a class of "yui-loaded" to
// enable styles that need to key off of JS being enabled.
if (docEl && docClass.indexOf(DOC_LABEL) == -1) {
if (docClass) {
docClass += " ";
}
docClass += DOC_LABEL;
docEl.className = docClass;
}
if (VERSION.indexOf("@") > -1) {
VERSION = "3.5.0"; // dev time hack for cdn test
}
proto = {
/**
Applies a new configuration object to the config of this YUI instance. This
will merge new group/module definitions, and will also update the loader
cache if necessary. Updating `Y.config` directly will not update the cache.
@method applyConfig
@param {Object} o the configuration object.
@since 3.2.0
**/
applyConfig: function (o) {
o = o || NOOP;
var attr,
name,
// detail,
config = this.config,
mods = config.modules,
groups = config.groups,
aliases = config.aliases,
loader = this.Env._loader;
for (name in o) {
if (o.hasOwnProperty(name)) {
attr = o[name];
if (mods && name == "modules") {
clobber(mods, attr);
} else if (aliases && name == "aliases") {
clobber(aliases, attr);
} else if (groups && name == "groups") {
clobber(groups, attr);
} else if (name == "win") {
config[name] = (attr && attr.contentWindow) || attr;
config.doc = config[name] ? config[name].document : null;
} else if (name == "_yuid") {
// preserve the guid
} else {
config[name] = attr;
}
}
}
if (loader) {
loader._config(o);
}
},
/**
Old way to apply a config to this instance (calls `applyConfig` under the
hood).
@private
@method _config
@param {Object} o The config to apply
**/
_config: function (o) {
this.applyConfig(o);
},
/**
Initializes this YUI instance.
@private
@method _init
**/
_init: function () {
var filter,
el,
Y = this,
G_ENV = YUI.Env,
Env = Y.Env,
prop;
/**
The version number of this YUI instance.
This value is typically updated by a script when a YUI release is built,
so it may not reflect the correct version number when YUI is run from
the development source tree.
@property {String} version
**/
Y.version = VERSION;
if (!Env) {
Y.Env = {
core: [
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3",
],
loaderExtras: ["loader-rollup", "loader-yui3"],
mods: {}, // flat module map
versions: {}, // version module map
base: BASE,
cdn: BASE + VERSION + "/build/",
// bootstrapped: false,
_idx: 0,
_used: {},
_attached: {},
_missed: [],
_yidx: 0,
_uidx: 0,
_guidp: "y",
_loaded: {},
// serviced: {},
// Regex in English:
// I'll start at the \b(simpleyui).
// 1. Look in the test string for "simpleyui" or "yui" or
// "yui-base" or "yui-davglass" or "yui-foobar" that comes after a word break. That is, it
// can't match "foyui" or "i_heart_simpleyui". This can be anywhere in the string.
// 2. After #1 must come a forward slash followed by the string matched in #1, so
// "yui-base/yui-base" or "simpleyui/simpleyui" or "yui-pants/yui-pants".
// 3. The second occurence of the #1 token can optionally be followed by "-debug" or "-min",
// so "yui/yui-min", "yui/yui-debug", "yui-base/yui-base-debug". NOT "yui/yui-tshirt".
// 4. This is followed by ".js", so "yui/yui.js", "simpleyui/simpleyui-min.js"
// 0. Going back to the beginning, now. If all that stuff in 1-4 comes after a "?" in the string,
// then capture the junk between the LAST "&" and the string in 1-4. So
// "blah?foo/yui/yui.js" will capture "foo/" and "blah?some/thing.js&3.3.0/build/yui-davglass/yui-davglass.js"
// will capture "3.3.0/build/"
//
// Regex Exploded:
// (?:\? Find a ?
// (?:[^&]*&) followed by 0..n characters followed by an &
// * in fact, find as many sets of characters followed by a & as you can
// ([^&]*) capture the stuff after the last & in \1
// )? but it's ok if all this ?junk&more_junk stuff isn't even there
// \b(simpleyui| after a word break find either the string "simpleyui" or
// yui(?:-\w+)? the string "yui" optionally followed by a -, then more characters
// ) and store the simpleyui or yui-* string in \2
// \/\2 then comes a / followed by the simpleyui or yui-* string in \2
// (?:-(min|debug))? optionally followed by "-min" or "-debug"
// .js and ending in ".js"
_BASE_RE:
/(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,
parseBasePath: function (src, pattern) {
var match = src.match(pattern),
path,
filter;
if (match) {
path = RegExp.leftContext || src.slice(0, src.indexOf(match[0]));
// this is to set up the path to the loader. The file
// filter for loader should match the yui include.
filter = match[3];
// extract correct path for mixed combo urls
// http://yuilibrary.com/projects/yui3/ticket/2528423
if (match[1]) {
path += "?" + match[1];
}
path = {
filter: filter,
path: path,
};
}
return path;
},
getBase:
(G_ENV && G_ENV.getBase) ||
function (pattern) {
var nodes = (doc && doc.getElementsByTagName("script")) || [],
path = Env.cdn,
parsed,
i,
len,
src;
for (i = 0, len = nodes.length; i < len; ++i) {
src = nodes[i].src;
if (src) {
parsed = Y.Env.parseBasePath(src, pattern);
if (parsed) {
filter = parsed.filter;
path = parsed.path;
break;
}
}
}
// use CDN default
return path;
},
};
Env = Y.Env;
Env._loaded[VERSION] = {};
if (G_ENV && Y !== YUI) {
Env._yidx = ++G_ENV._yidx;
Env._guidp = (
"yui_" +
VERSION +
"_" +
Env._yidx +
"_" +
time
).replace(/[^a-z0-9_]+/g, "_");
} else if (YUI._YUI) {
G_ENV = YUI._YUI.Env;
Env._yidx += G_ENV._yidx;
Env._uidx += G_ENV._uidx;
for (prop in G_ENV) {
if (!(prop in Env)) {
Env[prop] = G_ENV[prop];
}
}
delete YUI._YUI;
}
Y.id = Y.stamp(Y);
instances[Y.id] = Y;
}
Y.constructor = YUI;
// configuration defaults
Y.config = Y.config || {
bootstrap: true,
cacheUse: true,
debug: true,
doc: doc,
fetchCSS: true,
throwFail: true,
useBrowserConsole: true,
useNativeES5: true,
win: win,
global: Function("return this")(),
};
//Register the CSS stamp element
if (doc && !doc.getElementById(CSS_STAMP_EL)) {
el = doc.createElement("div");
el.innerHTML =
'<div id="' +
CSS_STAMP_EL +
'" style="position: absolute !important; visibility: hidden !important"></div>';
YUI.Env.cssStampEl = el.firstChild;
if (doc.body) {
doc.body.appendChild(YUI.Env.cssStampEl);
} else {
docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild);
}
} else if (
doc &&
doc.getElementById(CSS_STAMP_EL) &&
!YUI.Env.cssStampEl
) {
YUI.Env.cssStampEl = doc.getElementById(CSS_STAMP_EL);
}
Y.config.lang = Y.config.lang || "en-US";
Y.config.base = YUI.config.base || Y.Env.getBase(Y.Env._BASE_RE);
if (!filter || !"mindebug".indexOf(filter)) {
filter = "min";
}
filter = filter ? "-" + filter : filter;
Y.config.loaderPath =
YUI.config.loaderPath || "loader/loader" + filter + ".js";
},
/**
Finishes the instance setup. Attaches whatever YUI modules were defined
at the time that this instance was created.
@method _setup
@private
**/
_setup: function () {
var i,
Y = this,
core = [],
mods = YUI.Env.mods,
extras = Y.config.core || [].concat(YUI.Env.core); //Clone it..
for (i = 0; i < extras.length; i++) {
if (mods[extras[i]]) {
core.push(extras[i]);
}
}
Y._attach(["yui-base"]);
Y._attach(core);
if (Y.Loader) {
getLoader(Y);
}
},
/**
Executes the named method on the specified YUI instance if that method is
whitelisted.
@method applyTo
@param {String} id YUI instance id.
@param {String} method Name of the method to execute. For example:
'Object.keys'.
@param {Array} args Arguments to apply to the method.
@return {Mixed} Return value from the applied method, or `null` if the
specified instance was not found or the method was not whitelisted.
**/
applyTo: function (id, method, args) {
if (!(method in APPLY_TO_AUTH)) {
this.log(method + ": applyTo not allowed", "warn", "yui");
return null;
}
var instance = instances[id],
nest,
m,
i;
if (instance) {
nest = method.split(".");
m = instance;
for (i = 0; i < nest.length; i = i + 1) {
m = m[nest[i]];
if (!m) {
this.log("applyTo not found: " + method, "warn", "yui");
}
}
return m && m.apply(instance, args);
}
return null;
},
/**
Registers a YUI module and makes it available for use in a `YUI().use()` call or
as a dependency for other modules.
The easiest way to create a first-class YUI module is to use
<a href="http://yui.github.com/shifter/">Shifter</a>, the YUI component build
tool.
Shifter will automatically wrap your module code in a `YUI.add()` call along
with any configuration info required for the module.
@example
YUI.add('davglass', function (Y) {
Y.davglass = function () {
};
}, '3.4.0', {
requires: ['harley-davidson', 'mt-dew']
});
@method add
@param {String} name Module name.
@param {Function} fn Function containing module code. This function will be
executed whenever the module is attached to a specific YUI instance.
@param {YUI} fn.Y The YUI instance to which this module is attached.
@param {String} fn.name Name of the module
@param {String} version Module version number. This is currently used only for
informational purposes, and is not used internally by YUI.
@param {Object} [config] Module config.
@param {Array} [config.requires] Array of other module names that must be
attached before this module can be attached.
@param {Array} [config.optional] Array of optional module names that should
be attached before this module is attached if they've already been
loaded. If the `loadOptional` YUI option is `true`, optional modules
that have not yet been loaded will be loaded just as if they were hard
requirements.
@param {Array} [config.use] Array of module names that are included within
or otherwise provided by this module, and which should be attached
automatically when this module is attached. This makes it possible to
create "virtual rollup" modules that simply attach a collection of other
modules or submodules.
@return {YUI} This YUI instance.
**/
add: function (name, fn, version, details) {
details = details || {};
var env = YUI.Env,
mod = {
name: name,
fn: fn,
version: version,
details: details,
},
//Instance hash so we don't apply it to the same instance twice
applied = {},
loader,
inst,
i,
versions = env.versions;
env.mods[name] = mod;
versions[version] = versions[version] || {};
versions[version][name] = mod;
for (i in instances) {
if (instances.hasOwnProperty(i)) {
inst = instances[i];
if (!applied[inst.id]) {
applied[inst.id] = true;
loader = inst.Env._loader;
if (loader) {
if (!loader.moduleInfo[name] || loader.moduleInfo[name].temp) {
loader.addModule(details, name);
}
}
}
}
}
return this;
},
/**
Executes the callback function associated with each required module,
attaching the module to this YUI instance.
@method _attach
@param {Array} r The array of modules to attach
@param {Boolean} [moot=false] If `true`, don't throw a warning if the module
is not attached.
@private
**/
_attach: function (r, moot) {
var i,
name,
mod,
details,
req,
use,
after,
mods = YUI.Env.mods,
aliases = YUI.Env.aliases,
Y = this,
j,
cache = YUI.Env._renderedMods,
loader = Y.Env._loader,
done = Y.Env._attached,
len = r.length,
loader,
def,
go,
c = [];
//Check for conditional modules (in a second+ instance) and add their requirements
//TODO I hate this entire method, it needs to be fixed ASAP (3.5.0) ^davglass
for (i = 0; i < len; i++) {
name = r[i];
mod = mods[name];
c.push(name);
if (loader && loader.conditions[name]) {
for (j in loader.conditions[name]) {
if (loader.conditions[name].hasOwnProperty(j)) {
def = loader.conditions[name][j];
go =
def && ((def.ua && Y.UA[def.ua]) || (def.test && def.test(Y)));
if (go) {
c.push(def.name);
}
}
}
}
}
r = c;
len = r.length;
for (i = 0; i < len; i++) {
if (!done[r[i]]) {
name = r[i];
mod = mods[name];
if (aliases && aliases[name] && !mod) {
Y._attach(aliases[name]);
continue;
}
if (!mod) {
if (loader && loader.moduleInfo[name]) {
mod = loader.moduleInfo[name];
moot = true;
}
//if (!loader || !loader.moduleInfo[name]) {
//if ((!loader || !loader.moduleInfo[name]) && !moot) {
if (!moot && name) {
if (name.indexOf("skin-") === -1 && name.indexOf("css") === -1) {
Y.Env._missed.push(name);
Y.Env._missed = Y.Array.dedupe(Y.Env._missed);
Y.message("NOT loaded: " + name, "warn", "yui");
}
}
} else {
done[name] = true;
//Don't like this, but in case a mod was asked for once, then we fetch it
//We need to remove it from the missed list ^davglass
for (j = 0; j < Y.Env._missed.length; j++) {
if (Y.Env._missed[j] === name) {
Y.message(
"Found: " + name + " (was reported as missing earlier)",
"warn",
"yui",
);
Y.Env._missed.splice(j, 1);
}
}
/*
If it's a temp module, we need to redo it's requirements if it's already loaded
since it may have been loaded by another instance and it's dependencies might
have been redefined inside the fetched file.
*/
if (loader && cache && cache[name] && cache[name].temp) {
loader.getRequires(cache[name]);
req = [];
for (j in loader.moduleInfo[name].expanded_map) {
if (loader.moduleInfo[name].expanded_map.hasOwnProperty(j)) {
req.push(j);
}
}
Y._attach(req);
}
details = mod.details;
req = details.requires;
use = details.use;
after = details.after;
//Force Intl load if there is a language (Loader logic) @todo fix this shit
if (details.lang) {
req = req || [];
req.unshift("intl");
}
if (req) {
for (j = 0; j < req.length; j++) {
if (!done[req[j]]) {
if (!Y._attach(req)) {
return false;
}
break;
}
}
}
if (after) {
for (j = 0; j < after.length; j++) {
if (!done[after[j]]) {
if (!Y._attach(after, true)) {
return false;
}
break;
}
}
}
if (mod.fn) {
if (Y.config.throwFail) {
mod.fn(Y, name);
} else {
try {
mod.fn(Y, name);
} catch (e) {
Y.error("Attach error: " + name, e, name);
return false;
}
}
}
if (use) {
for (j = 0; j < use.length; j++) {
if (!done[use[j]]) {
if (!Y._attach(use)) {
return false;
}
break;
}
}
}
}
}
}
return true;
},
/**
Delays the `use` callback until another event has taken place such as
`window.onload`, `domready`, `contentready`, or `available`.
@private
@method _delayCallback
@param {Function} cb The original `use` callback.
@param {String|Object} until Either an event name ('load', 'domready', etc.)
or an object containing event/args keys for contentready/available.
@return {Function}
**/
_delayCallback: function (cb, until) {
var Y = this,
mod = ["event-base"];
until = Y.Lang.isObject(until) ? until : { event: until };
if (until.event === "load") {
mod.push("event-synthetic");
}
return function () {
var args = arguments;
Y._use(mod, function () {
Y.on(
until.event,
function () {
args[1].delayUntil = until.event;
cb.apply(Y, args);
},
until.args,
);
});
};
},
/**
Attaches one or more modules to this YUI instance. When this is executed,
the requirements of the desired modules are analyzed, and one of several
things can happen:
* All required modules have already been loaded, and just need to be
attached to this YUI instance. In this case, the `use()` callback will
be executed synchronously after the modules are attached.
* One or more modules have not yet been loaded, or the Get utility is not
available, or the `bootstrap` config option is `false`. In this case,
a warning is issued indicating that modules are missing, but all
available modules will still be attached and the `use()` callback will
be executed synchronously.
* One or more modules are missing and the Loader is not available but the
Get utility is, and `bootstrap` is not `false`. In this case, the Get
utility will be used to load the Loader, and we will then proceed to
the following state:
* One or more modules are missing and the Loader is available. In this
case, the Loader will be used to resolve the dependency tree for the
missing modules and load them and their dependencies. When the Loader is
finished loading modules, the `use()` callback will be executed
asynchronously.
@example
// Loads and attaches dd and its dependencies.
YUI().use('dd', function (Y) {
// ...
});
// Loads and attaches dd and node as well as all of their dependencies.
YUI().use(['dd', 'node'], function (Y) {
// ...
});
// Attaches all modules that have already been loaded.
YUI().use('*', function (Y) {
// ...
});
// Attaches a gallery module.
YUI().use('gallery-yql', function (Y) {
// ...
});
// Attaches a YUI 2in3 module.
YUI().use('yui2-datatable', function (Y) {
// ...
});
@method use
@param {String|Array} modules* One or more module names to attach.
@param {Function} [callback] Callback function to be executed once all
specified modules and their dependencies have been attached.
@param {YUI} callback.Y The YUI instance created for this sandbox.
@param {Object} callback.status Object containing `success`, `msg` and
`data` properties.
@chainable
**/
use: function () {
var args = SLICE.call(arguments, 0),
callback = args[args.length - 1],
Y = this,
i = 0,
name,
Env = Y.Env,
provisioned = true;
// The last argument supplied to use can be a load complete callback
if (Y.Lang.isFunction(callback)) {
args.pop();
if (Y.config.delayUntil) {
callback = Y._delayCallback(callback, Y.config.delayUntil);
}
} else {
callback = null;
}
if (Y.Lang.isArray(args[0])) {
args = args[0];
}
if (Y.config.cacheUse) {
while ((name = args[i++])) {
if (!Env._attached[name]) {
provisioned = false;
break;
}
}
if (provisioned) {
if (args.length) {
}
Y._notify(callback, ALREADY_DONE, args);
return Y;
}
}
if (Y._loading) {
Y._useQueue = Y._useQueue || new Y.Queue();
Y._useQueue.add([args, callback]);
} else {
Y._use(args, function (Y, response) {
Y._notify(callback, response, args);
});
}
return Y;
},
/**
Handles Loader notifications about attachment/load errors.
@method _notify
@param {Function} callback Callback to pass to `Y.config.loadErrorFn`.
@param {Object} response Response returned from Loader.
@param {Array} args Arguments passed from Loader.
@private
**/
_notify: function (callback, response, args) {
if (!response.success && this.config.loadErrorFn) {
this.config.loadErrorFn.call(this, this, callback, response, args);
} else if (callback) {
if (this.Env._missed && this.Env._missed.length) {
response.msg = "Missing modules: " + this.Env._missed.join();
response.success = false;
}
if (this.config.throwFail) {
callback(this, response);
} else {
try {
callback(this, response);
} catch (e) {
this.error("use callback error", e, args);
}
}
}
},
/**
Called from the `use` method queue to ensure that only one set of loading
logic is performed at a time.
@method _use
@param {String} args* One or more modules to attach.
@param {Function} [callback] Function to call once all required modules have
been attached.
@private
**/
_use: function (args, callback) {
if (!this.Array) {
this._attach(["yui-base"]);
}
var len,
loader,
handleBoot,
Y = this,
G_ENV = YUI.Env,
mods = G_ENV.mods,
Env = Y.Env,
used = Env._used,
aliases = G_ENV.aliases,
queue = G_ENV._loaderQueue,
firstArg = args[0],
YArray = Y.Array,
config = Y.config,
boot = config.bootstrap,
missing = [],
i,
r = [],
ret = true,
fetchCSS = config.fetchCSS,
process = function (names, skip) {
var i = 0,
a = [],
name,
len,
m,
req,
use;
if (!names.length) {
return;
}
if (aliases) {
len = names.length;
for (i = 0; i < len; i++) {
if (aliases[names[i]] && !mods[names[i]]) {
a = [].concat(a, aliases[names[i]]);
} else {
a.push(names[i]);
}
}
names = a;
}
len = names.length;
for (i = 0; i < len; i++) {
name = names[i];
if (!skip) {
r.push(name);
}
// only attach a module once
if (used[name]) {
continue;
}
m = mods[name];
req = null;
use = null;
if (m) {
used[name] = true;
req = m.details.requires;
use = m.details.use;
} else {
// CSS files don't register themselves, see if it has
// been loaded
if (!G_ENV._loaded[VERSION][name]) {
missing.push(name);
} else {
used[name] = true; // probably css
}
}
// make sure requirements are attached
if (req && req.length) {
process(req);
}
// make sure we grab the submodule dependencies too
if (use && use.length) {
process(use, 1);
}
}
},
handleLoader = function (fromLoader) {
var response = fromLoader || {
success: true,
msg: "not dynamic",
},
redo,
origMissing,
ret = true,
data = response.data;
Y._loading = false;
if (data) {
origMissing = missing;
missing = [];
r = [];
process(data);
redo = missing.length;
if (redo) {
if (
[].concat(missing).sort().join() == origMissing.sort().join()
) {
redo = false;
}
}
}
if (redo && data) {
Y._loading = true;
Y._use(missing, function () {
if (Y._attach(data)) {
Y._notify(callback, response, data);
}
});
} else {
if (data) {
ret = Y._attach(data);
}
if (ret) {
Y._notify(callback, response, args);
}
}
if (Y._useQueue && Y._useQueue.size() && !Y._loading) {
Y._use.apply(Y, Y._useQueue.next());
}
};
// YUI().use('*'); // bind everything available
if (firstArg === "*") {
args = [];
for (i in mods) {
if (mods.hasOwnProperty(i)) {
args.push(i);
}
}
ret = Y._attach(args);
if (ret) {
handleLoader();
}
return Y;
}
if ((mods.loader || mods["loader-base"]) && !Y.Loader) {
Y._attach(["loader" + (!mods.loader ? "-base" : "")]);
}
// use loader to expand dependencies and sort the
// requirements if it is available.
if (boot && Y.Loader && args.length) {
loader = getLoader(Y);
loader.require(args);
loader.ignoreRegistered = true;
loader._boot = true;
loader.calculate(null, fetchCSS ? null : "js");
args = loader.sorted;
loader._boot = false;
}
process(args);
len = missing.length;
if (len) {
missing = YArray.dedupe(missing);
len = missing.length;
}
// dynamic load
if (boot && len && Y.Loader) {
Y._loading = true;
loader = getLoader(Y);
loader.onEnd = handleLoader;
loader.context = Y;
loader.data = args;
loader.ignoreRegistered = false;
loader.require(missing);
loader.insert(null, fetchCSS ? null : "js");
} else if (boot && len && Y.Get && !Env.bootstrapped) {
Y._loading = true;
handleBoot = function () {
Y._loading = false;
queue.running = false;
Env.bootstrapped = true;
G_ENV._bootstrapping = false;
if (Y._attach(["loader"])) {
Y._use(args, callback);
}
};
if (G_ENV._bootstrapping) {
queue.add(handleBoot);
} else {
G_ENV._bootstrapping = true;
Y.Get.script(config.base + config.loaderPath, {
onEnd: handleBoot,
});
}
} else {
ret = Y._attach(args);
if (ret) {
handleLoader();
}
}
return Y;
},
/**
Utility method for safely creating namespaces if they don't already exist.
May be called statically on the YUI global object or as a method on a YUI
instance.
When called statically, a namespace will be created on the YUI global
object:
// Create `YUI.your.namespace.here` as nested objects, preserving any
// objects that already exist instead of overwriting them.
YUI.namespace('your.namespace.here');
When called as a method on a YUI instance, a namespace will be created on
that instance:
// Creates `Y.property.package`.
Y.namespace('property.package');
Dots in the input string cause `namespace` to create nested objects for each
token. If any part of the requested namespace already exists, the current
object will be left in place and will not be overwritten. This allows
multiple calls to `namespace` to preserve existing namespaced properties.
If the first token in the namespace string is "YAHOO", that token is
discarded. This is legacy behavior for backwards compatibility with YUI 2.
Be careful with namespace tokens. Reserved words may work in some browsers
and not others. For instance, the following will fail in some browsers
because the supported version of JavaScript reserves the word "long":
Y.namespace('really.long.nested.namespace');
Note: If you pass multiple arguments to create multiple namespaces, only the
last one created is returned from this function.
@method namespace
@param {String} namespace* One or more namespaces to create.
@return {Object} Reference to the last namespace object created.
**/
namespace: function () {
var a = arguments,
o,
i = 0,
j,
d,
arg;
for (; i < a.length; i++) {
o = this; //Reset base object per argument or it will get reused from the last
arg = a[i];
if (arg.indexOf(PERIOD) > -1) {
//Skip this if no "." is present
d = arg.split(PERIOD);
for (j = d[0] == "YAHOO" ? 1 : 0; j < d.length; j++) {
o[d[j]] = o[d[j]] || {};
o = o[d[j]];
}
} else {
o[arg] = o[arg] || {};
o = o[arg]; //Reset base object to the new object so it's returned
}
}
return o;
},
// this is replaced if the log module is included
log: NOOP,
message: NOOP,
// this is replaced if the dump module is included
dump: function (o) {
return "" + o;
},
/**
Reports an error.
The reporting mechanism is controlled by the `throwFail` configuration
attribute. If `throwFail` is falsy, the message is logged. If `throwFail` is
truthy, a JS exception is thrown.
If an `errorFn` is specified in the config it must return `true` to indicate
that the exception was handled and keep it from being thrown.
@method error
@param {String} msg Error message.
@param {Error|String} [e] JavaScript error object or an error string.
@param {String} [src] Source of the error (such as the name of the module in
which the error occurred).
@chainable
**/
error: function (msg, e, src) {
//TODO Add check for window.onerror here
var Y = this,
ret;
if (Y.config.errorFn) {
ret = Y.config.errorFn.apply(Y, arguments);
}
if (!ret) {
throw e || new Error(msg);
} else {
Y.message(msg, "error", "" + src); // don't scrub this one
}
return Y;
},
/**
Generates an id string that is unique among all YUI instances in this
execution context.
@method guid
@param {String} [pre] Prefix.
@return {String} Unique id.
**/
guid: function (pre) {
var id = this.Env._guidp + "_" + ++this.Env._uidx;
return pre ? pre + id : id;
},
/**
Returns a unique id associated with the given object and (if *readOnly* is
falsy) stamps the object with that id so it can be identified in the future.
Stamping an object involves adding a `_yuid` property to it that contains
the object's id. One exception to this is that in Internet Explorer, DOM
nodes have a `uniqueID` property that contains a browser-generated unique
id, which will be used instead of a YUI-generated id when available.
@method stamp
@param {Object} o Object to stamp.
@param {Boolean} readOnly If truthy and the given object has not already
been stamped, the object will not be modified and `null` will be
returned.
@return {String} Object's unique id, or `null` if *readOnly* was truthy and
the given object was not already stamped.
**/
stamp: function (o, readOnly) {
var uid;
if (!o) {
return o;
}
// IE generates its own unique ID for dom nodes
// The uniqueID property of a document node returns a new ID
if (o.uniqueID && o.nodeType && o.nodeType !== 9) {
uid = o.uniqueID;
} else {
uid = typeof o === "string" ? o : o._yuid;
}
if (!uid) {
uid = this.guid();
if (!readOnly) {
try {
o._yuid = uid;
} catch (e) {
uid = null;
}
}
}
return uid;
},
/**
Destroys this YUI instance.
@method destroy
@since 3.3.0
**/
destroy: function () {
var Y = this;
if (Y.Event) {
Y.Event._unload();
}
delete instances[Y.id];
delete Y.Env;
delete Y.config;
},
/**
Safe `instanceof` wrapper that works around a memory leak in IE when the
object being tested is `window` or `document`.
Unless you are testing objects that may be `window` or `document`, you
should use the native `instanceof` operator instead of this method.
@method instanceOf
@param {Object} o Object to check.
@param {Object} type Class to check against.
@since 3.3.0
**/
};
YUI.prototype = proto;
// inheritance utilities are not available yet
for (prop in proto) {
if (proto.hasOwnProperty(prop)) {
YUI[prop] = proto[prop];
}
}
/**
Applies a configuration to all YUI instances in this execution context.
The main use case for this method is in "mashups" where several third-party
scripts need to write to a global YUI config, but cannot share a single
centrally-managed config object. This way they can all call
`YUI.applyConfig({})` instead of overwriting the single global config.
@example
YUI.applyConfig({
modules: {
davglass: {
fullpath: './davglass.js'
}
}
});
YUI.applyConfig({
modules: {
foo: {
fullpath: './foo.js'
}
}
});
YUI().use('davglass', function (Y) {
// Module davglass will be available here.
});
@method applyConfig
@param {Object} o Configuration object to apply.
@static
@since 3.5.0
**/
YUI.applyConfig = function (o) {
if (!o) {
return;
}
//If there is a GlobalConfig, apply it first to set the defaults
if (YUI.GlobalConfig) {
this.prototype.applyConfig.call(this, YUI.GlobalConfig);
}
//Apply this config to it
this.prototype.applyConfig.call(this, o);
//Reset GlobalConfig to the combined config
YUI.GlobalConfig = this.config;
};
// set up the environment
YUI._init();
if (hasWin) {
// add a window load event at load time so we can capture
// the case where it fires before dynamic loading is
// complete.
add(window, "load", handleLoad);
} else {
handleLoad();
}
YUI.Env.add = add;
YUI.Env.remove = remove;
/*global exports*/
// Support the CommonJS method for exporting our single global
if (typeof exports == "object") {
exports.YUI = YUI;
/**
* Set a method to be called when `Get.script` is called in Node.js
* `Get` will open the file, then pass it's content and it's path
* to this method before attaching it. Commonly used for code coverage
* instrumentation. <strong>Calling this multiple times will only
* attach the last hook method</strong>. This method is only
* available in Node.js.
* @method setLoadHook
* @static
* @param {Function} fn The function to set
* @param {String} fn.data The content of the file
* @param {String} fn.path The file path of the file
*/
YUI.setLoadHook = function (fn) {
YUI._getLoadHook = fn;
};
/**
* Load hook for `Y.Get.script` in Node.js, see `YUI.setLoadHook`
* @method _getLoadHook
* @private
* @param {String} data The content of the file
* @param {String} path The file path of the file
*/
YUI._getLoadHook = null;
}
YUI.Env[VERSION] = {};
})();
/**
Config object that contains all of the configuration options for
this `YUI` instance.
This object is supplied by the implementer when instantiating YUI. Some
properties have default values if they are not supplied by the implementer.
This object should not be updated directly because some values are cached. Use
`applyConfig()` to update the config object on a YUI instance that has already
been configured.
@class config
@static
**/
/**
If `true` (the default), YUI will "bootstrap" the YUI Loader and module metadata
if they're needed to load additional dependencies and aren't already available.
Setting this to `false` will prevent YUI from automatically loading the Loader
and module metadata, so you will need to manually ensure that they're available
or handle dependency resolution yourself.
@property {Boolean} bootstrap
@default true
**/
/**
@property {Object} aliases
**/
/**
A hash of module group definitions.
For each group you can specify a list of modules and the base path and
combo spec to use when dynamically loading the modules.
@example
groups: {
yui2: {
// specify whether or not this group has a combo service
combine: true,
// The comboSeperator to use with this group's combo handler
comboSep: ';',
// The maxURLLength for this server
maxURLLength: 500,
// the base path for non-combo paths
base: 'http://yui.yahooapis.com/2.8.0r4/build/',
// the path to the combo service
comboBase: 'http://yui.yahooapis.com/combo?',
// a fragment to prepend to the path attribute when
// when building combo urls
root: '2.8.0r4/build/',
// the module definitions
modules: {
yui2_yde: {
path: "yahoo-dom-event/yahoo-dom-event.js"
},
yui2_anim: {
path: "animation/animation.js",
requires: ['yui2_yde']
}
}
}
}
@property {Object} groups
**/
/**
Path to the Loader JS file, relative to the `base` path.
This is used to dynamically bootstrap the Loader when it's needed and isn't yet
available.
@property {String} loaderPath
@default "loader/loader-min.js"
**/
/**
If `true`, YUI will attempt to load CSS dependencies and skins. Set this to
`false` to prevent YUI from loading any CSS, or set it to the string `"force"`
to force CSS dependencies to be loaded even if their associated JS modules are
already loaded.
@property {Boolean|String} fetchCSS
@default true
**/
/**
Default gallery version used to build gallery module urls.
@property {String} gallery
@since 3.1.0
**/
/**
Default YUI 2 version used to build YUI 2 module urls.
This is used for intrinsic YUI 2 support via the 2in3 project. Also see the
`2in3` config for pulling different revisions of the wrapped YUI 2 modules.
@property {String} yui2
@default "2.9.0"
@since 3.1.0
**/
/**
Revision number of YUI 2in3 modules that should be used when loading YUI 2in3.
@property {String} 2in3
@default "4"
@since 3.1.0
**/
/**
Alternate console log function that should be used in environments without a
supported native console. This function is executed with the YUI instance as its
`this` object.
@property {Function} logFn
@since 3.1.0
**/
/**
The minimum log level to log messages for. Log levels are defined
incrementally. Messages greater than or equal to the level specified will
be shown. All others will be discarded. The order of log levels in
increasing priority is:
debug
info
warn
error
@property {String} logLevel
@default 'debug'
@since 3.10.0
**/
/**
Callback to execute when `Y.error()` is called. It receives the error message
and a JavaScript error object if one was provided.
This function is executed with the YUI instance as its `this` object.
Returning `true` from this function will prevent an exception from being thrown.
@property {Function} errorFn
@param {String} errorFn.msg Error message
@param {Object} [errorFn.err] Error object (if one was provided).
@since 3.2.0
**/
/**
A callback to execute when Loader fails to load one or more resources.
This could be because of a script load failure. It could also be because a
module fails to register itself when the `requireRegistration` config is `true`.
If this function is defined, the `use()` callback will only be called when the
loader succeeds. Otherwise, `use()` will always executes unless there was a
JavaScript error when attaching a module.
@property {Function} loadErrorFn
@since 3.3.0
**/
/**
If `true`, Loader will expect all loaded scripts to be first-class YUI modules
that register themselves with the YUI global, and will trigger a failure if a
loaded script does not register a YUI module.
@property {Boolean} requireRegistration
@default false
@since 3.3.0
**/
/**
Cache serviced use() requests.
@property {Boolean} cacheUse
@default true
@since 3.3.0
@deprecated No longer used.
**/
/**
Whether or not YUI should use native ES5 functionality when available for
features like `Y.Array.each()`, `Y.Object()`, etc.
When `false`, YUI will always use its own fallback implementations instead of
relying on ES5 functionality, even when ES5 functionality is available.
@property {Boolean} useNativeES5
@default true
@since 3.5.0
**/
/**
* Leverage native JSON stringify if the browser has a native
* implementation. In general, this is a good idea. See the Known Issues
* section in the JSON user guide for caveats. The default value is true
* for browsers with native JSON support.
*
* @property useNativeJSONStringify
* @type Boolean
* @default true
* @since 3.8.0
*/
/**
* Leverage native JSON parse if the browser has a native implementation.
* In general, this is a good idea. See the Known Issues section in the
* JSON user guide for caveats. The default value is true for browsers with
* native JSON support.
*
* @property useNativeJSONParse
* @type Boolean
* @default true
* @since 3.8.0
*/
/**
Delay the `use` callback until a specific event has passed (`load`, `domready`, `contentready` or `available`)
@property {Object|String} delayUntil
@since 3.6.0
@example
You can use `load` or `domready` strings by default:
YUI({
delayUntil: 'domready'
}, function (Y) {
// This will not execute until 'domeready' occurs.
});
Or you can delay until a node is available (with `available` or `contentready`):
YUI({
delayUntil: {
event: 'available',
args : '#foo'
}
}, function (Y) {
// This will not execute until a node matching the selector "#foo" is
// available in the DOM.
});
**/
YUI.add(
"yui-base",
function (Y, NAME) {
/*
* YUI stub
* @module yui
* @submodule yui-base
*/
/**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/
/**
* Provides core language utilites and extensions used throughout YUI.
*
* @class Lang
* @static
*/
var L = Y.Lang || (Y.Lang = {}),
STRING_PROTO = String.prototype,
TOSTRING = Object.prototype.toString,
TYPES = {
undefined: "undefined",
number: "number",
boolean: "boolean",
string: "string",
"[object Function]": "function",
"[object RegExp]": "regexp",
"[object Array]": "array",
"[object Date]": "date",
"[object Error]": "error",
},
SUBREGEX = /\{\s*([^|}]+?)\s*(?:\|([^}]*))?\s*\}/g,
WHITESPACE =
"\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF",
WHITESPACE_CLASS =
"[\x09-\x0D\x20\xA0\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+",
TRIM_LEFT_REGEX = new RegExp("^" + WHITESPACE_CLASS),
TRIM_RIGHT_REGEX = new RegExp(WHITESPACE_CLASS + "$"),
TRIMREGEX = new RegExp(
TRIM_LEFT_REGEX.source + "|" + TRIM_RIGHT_REGEX.source,
"g",
),
NATIVE_FN_REGEX = /\{\s*\[(?:native code|function)\]\s*\}/i;
// -- Protected Methods --------------------------------------------------------
/**
Returns `true` if the given function appears to be implemented in native code,
`false` otherwise. Will always return `false` -- even in ES5-capable browsers --
if the `useNativeES5` YUI config option is set to `false`.
This isn't guaranteed to be 100% accurate and won't work for anything other than
functions, but it can be useful for determining whether a function like
`Array.prototype.forEach` is native or a JS shim provided by another library.
There's a great article by @kangax discussing certain flaws with this technique:
<http://perfectionkills.com/detecting-built-in-host-methods/>
While his points are valid, it's still possible to benefit from this function
as long as it's used carefully and sparingly, and in such a way that false
negatives have minimal consequences. It's used internally to avoid using
potentially broken non-native ES5 shims that have been added to the page by
other libraries.
@method _isNative
@param {Function} fn Function to test.
@return {Boolean} `true` if _fn_ appears to be native, `false` otherwise.
@static
@protected
@since 3.5.0
**/
L._isNative = function (fn) {
return !!(Y.config.useNativeES5 && fn && NATIVE_FN_REGEX.test(fn));
};
// -- Public Methods -----------------------------------------------------------
/**
* Determines whether or not the provided item is an array.
*
* Returns `false` for array-like collections such as the function `arguments`
* collection or `HTMLElement` collections. Use `Y.Array.test()` if you want to
* test for an array-like collection.
*
* @method isArray
* @param o The object to test.
* @return {boolean} true if o is an array.
* @static
*/
L.isArray = L._isNative(Array.isArray)
? Array.isArray
: function (o) {
return L.type(o) === "array";
};
/**
* Determines whether or not the provided item is a boolean.
* @method isBoolean
* @static
* @param o The object to test.
* @return {boolean} true if o is a boolean.
*/
L.isBoolean = function (o) {
return typeof o === "boolean";
};
/**
* Determines whether or not the supplied item is a date instance.
* @method isDate
* @static
* @param o The object to test.
* @return {boolean} true if o is a date.
*/
L.isDate = function (o) {
return (
L.type(o) === "date" && o.toString() !== "Invalid Date" && !isNaN(o)
);
};
/**
* <p>
* Determines whether or not the provided item is a function.
* Note: Internet Explorer thinks certain functions are objects:
* </p>
*
* <pre>
* var obj = document.createElement("object");
* Y.Lang.isFunction(obj.getAttribute) // reports false in IE
*
* var input = document.createElement("input"); // append to body
* Y.Lang.isFunction(input.focus) // reports false in IE
* </pre>
*
* <p>
* You will have to implement additional tests if these functions
* matter to you.
* </p>
*
* @method isFunction
* @static
* @param o The object to test.
* @return {boolean} true if o is a function.
*/
L.isFunction = function (o) {
return L.type(o) === "function";
};
/**
* Determines whether or not the provided item is null.
* @method isNull
* @static
* @param o The object to test.
* @return {boolean} true if o is null.
*/
L.isNull = function (o) {
return o === null;
};
/**
* Determines whether or not the provided item is a legal number.
* @method isNumber
* @static
* @param o The object to test.
* @return {boolean} true if o is a number.
*/
L.isNumber = function (o) {
return typeof o === "number" && isFinite(o);
};
/**
* Determines whether or not the provided item is of type object
* or function. Note that arrays are also objects, so
* <code>Y.Lang.isObject([]) === true</code>.
* @method isObject
* @static
* @param o The object to test.
* @param failfn {boolean} fail if the input is a function.
* @return {boolean} true if o is an object.
* @see isPlainObject
*/
L.isObject = function (o, failfn) {
var t = typeof o;
return (
(o &&
(t === "object" ||
(!failfn && (t === "function" || L.isFunction(o))))) ||
false
);
};
/**
* Determines whether or not the provided item is a string.
* @method isString
* @static
* @param o The object to test.
* @return {boolean} true if o is a string.
*/
L.isString = function (o) {
return typeof o === "string";
};
/**
* Determines whether or not the provided item is undefined.
* @method isUndefined
* @static
* @param o The object to test.
* @return {boolean} true if o is undefined.
*/
L.isUndefined = function (o) {
return typeof o === "undefined";
};
/**
* A convenience method for detecting a legitimate non-null value.
* Returns false for null/undefined/NaN, true for other values,
* including 0/false/''
* @method isValue
* @static
* @param o The item to test.
* @return {boolean} true if it is not null/undefined/NaN || false.
*/
L.isValue = function (o) {
var t = L.type(o);
switch (t) {
case "number":
return isFinite(o);
case "null": // fallthru
case "undefined":
return false;
default:
return !!t;
}
};
/**
* Returns the current time in milliseconds.
*
* @method now
* @return {Number} Current time in milliseconds.
* @static
* @since 3.3.0
*/
L.now =
Date.now ||
function () {
return new Date().getTime();
};
/**
* Lightweight version of <code>Y.substitute</code>. Uses the same template
* structure as <code>Y.substitute</code>, but doesn't support recursion,
* auto-object coersion, or formats.
* @method sub
* @param {string} s String to be modified.
* @param {object} o Object containing replacement values.
* @return {string} the substitute result.
* @static
* @since 3.2.0
*/
L.sub = function (s, o) {
return s.replace
? s.replace(SUBREGEX, function (match, key) {
return L.isUndefined(o[key]) ? match : o[key];
})
: s;
};
/**
* Returns a string without any leading or trailing whitespace. If
* the input is not a string, the input will be returned untouched.
* @method trim
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/
L.trim =
L._isNative(STRING_PROTO.trim) && !WHITESPACE.trim()
? function (s) {
return s && s.trim ? s.trim() : s;
}
: function (s) {
try {
return s.replace(TRIMREGEX, "");
} catch (e) {
return s;
}
};
/**
* Returns a string without any leading whitespace.
* @method trimLeft
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/
L.trimLeft =
L._isNative(STRING_PROTO.trimLeft) && !WHITESPACE.trimLeft()
? function (s) {
return s.trimLeft();
}
: function (s) {
return s.replace(TRIM_LEFT_REGEX, "");
};
/**
* Returns a string without any trailing whitespace.
* @method trimRight
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/
L.trimRight =
L._isNative(STRING_PROTO.trimRight) && !WHITESPACE.trimRight()
? function (s) {
return s.trimRight();
}
: function (s) {
return s.replace(TRIM_RIGHT_REGEX, "");
};
/**
Returns one of the following strings, representing the type of the item passed
in:
* "array"
* "boolean"
* "date"
* "error"
* "function"
* "null"
* "number"
* "object"
* "regexp"
* "string"
* "undefined"
Known issues:
* `typeof HTMLElementCollection` returns function in Safari, but
`Y.Lang.type()` reports "object", which could be a good thing --
but it actually caused the logic in <code>Y.Lang.isObject</code> to fail.
@method type
@param o the item to test.
@return {string} the detected type.
@static
**/
L.type = function (o) {
return (
TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? "object" : "null")
);
};
/**
@module yui
@submodule yui-base
*/
var Lang = Y.Lang,
Native = Array.prototype,
hasOwn = Object.prototype.hasOwnProperty;
/**
Provides utility methods for working with arrays. Additional array helpers can
be found in the `collection` and `array-extras` modules.
`Y.Array(thing)` returns a native array created from _thing_. Depending on
_thing_'s type, one of the following will happen:
* Arrays are returned unmodified unless a non-zero _startIndex_ is
specified.
* Array-like collections (see `Array.test()`) are converted to arrays.
* For everything else, a new array is created with _thing_ as the sole
item.
Note: elements that are also collections, such as `<form>` and `<select>`
elements, are not automatically converted to arrays. To force a conversion,
pass `true` as the value of the _force_ parameter.
@class Array
@constructor
@param {Any} thing The thing to arrayify.
@param {Number} [startIndex=0] If non-zero and _thing_ is an array or array-like
collection, a subset of items starting at the specified index will be
returned.
@param {Boolean} [force=false] If `true`, _thing_ will be treated as an
array-like collection no matter what.
@return {Array} A native array created from _thing_, according to the rules
described above.
**/
function YArray(thing, startIndex, force) {
var len, result;
/*jshint expr: true*/
startIndex || (startIndex = 0);
if (force || YArray.test(thing)) {
// IE throws when trying to slice HTMLElement collections.
try {
return Native.slice.call(thing, startIndex);
} catch (ex) {
result = [];
for (len = thing.length; startIndex < len; ++startIndex) {
result.push(thing[startIndex]);
}
return result;
}
}
return [thing];
}
Y.Array = YArray;
/**
Dedupes an array of strings, returning an array that's guaranteed to contain
only one copy of a given string.
This method differs from `Array.unique()` in that it's optimized for use only
with arrays consisting entirely of strings or entirely of numbers, whereas
`unique` may be used with other value types (but is slower).
Using `dedupe()` with values other than strings or numbers, or with arrays
containing a mix of strings and numbers, may result in unexpected behavior.
@method dedupe
@param {String[]|Number[]} array Array of strings or numbers to dedupe.
@return {Array} Copy of _array_ containing no duplicate values.
@static
@since 3.4.0
**/
YArray.dedupe = Lang._isNative(Object.create)
? function (array) {
var hash = Object.create(null),
results = [],
i,
item,
len;
for (i = 0, len = array.length; i < len; ++i) {
item = array[i];
if (!hash[item]) {
hash[item] = 1;
results.push(item);
}
}
return results;
}
: function (array) {
var hash = {},
results = [],
i,
item,
len;
for (i = 0, len = array.length; i < len; ++i) {
item = array[i];
if (!hasOwn.call(hash, item)) {
hash[item] = 1;
results.push(item);
}
}
return results;
};
/**
Executes the supplied function on each item in the array. This method wraps
the native ES5 `Array.forEach()` method if available.
@method each
@param {Array} array Array to iterate.
@param {Function} fn Function to execute on each item in the array. The function
will receive the following arguments:
@param {Any} fn.item Current array item.
@param {Number} fn.index Current array index.
@param {Array} fn.array Array being iterated.
@param {Object} [thisObj] `this` object to use when calling _fn_.
@return {YUI} The YUI instance.
@static
**/
YArray.each = YArray.forEach = Lang._isNative(Native.forEach)
? function (array, fn, thisObj) {
Native.forEach.call(array || [], fn, thisObj || Y);
return Y;
}
: function (array, fn, thisObj) {
for (var i = 0, len = (array && array.length) || 0; i < len; ++i) {
if (i in array) {
fn.call(thisObj || Y, array[i], i, array);
}
}
return Y;
};
/**
Alias for `each()`.
@method forEach
@static
**/
/**
Returns an object using the first array as keys and the second as values. If
the second array is not provided, or if it doesn't contain the same number of
values as the first array, then `true` will be used in place of the missing
values.
@example
Y.Array.hash(['a', 'b', 'c'], ['foo', 'bar']);
// => {a: 'foo', b: 'bar', c: true}
@method hash
@param {String[]} keys Array of strings to use as keys.
@param {Array} [values] Array to use as values.
@return {Object} Hash using the first array as keys and the second as values.
@static
**/
YArray.hash = function (keys, values) {
var hash = {},
vlen = (values && values.length) || 0,
i,
len;
for (i = 0, len = keys.length; i < len; ++i) {
if (i in keys) {
hash[keys[i]] = vlen > i && i in values ? values[i] : true;
}
}
return hash;
};
/**
Returns the index of the first item in the array that's equal (using a strict
equality check) to the specified _value_, or `-1` if the value isn't found.
This method wraps the native ES5 `Array.indexOf()` method if available.
@method indexOf
@param {Array} array Array to search.
@param {Any} value Value to search for.
@param {Number} [from=0] The index at which to begin the search.
@return {Number} Index of the item strictly equal to _value_, or `-1` if not
found.
@static
**/
YArray.indexOf = Lang._isNative(Native.indexOf)
? function (array, value, from) {
return Native.indexOf.call(array, value, from);
}
: function (array, value, from) {
// http://es5.github.com/#x15.4.4.14
var len = array.length;
from = +from || 0;
from = (from > 0 || -1) * Math.floor(Math.abs(from));
if (from < 0) {
from += len;
if (from < 0) {
from = 0;
}
}
for (; from < len; ++from) {
if (from in array && array[from] === value) {
return from;
}
}
return -1;
};
/**
Numeric sort convenience function.
The native `Array.prototype.sort()` function converts values to strings and
sorts them in lexicographic order, which is unsuitable for sorting numeric
values. Provide `Array.numericSort` as a custom sort function when you want
to sort values in numeric order.
@example
[42, 23, 8, 16, 4, 15].sort(Y.Array.numericSort);
// => [4, 8, 15, 16, 23, 42]
@method numericSort
@param {Number} a First value to compare.
@param {Number} b Second value to compare.
@return {Number} Difference between _a_ and _b_.
@static
**/
YArray.numericSort = function (a, b) {
return a - b;
};
/**
Executes the supplied function on each item in the array. Returning a truthy
value from the function will stop the processing of remaining items.
@method some
@param {Array} array Array to iterate over.
@param {Function} fn Function to execute on each item. The function will receive
the following arguments:
@param {Any} fn.value Current array item.
@param {Number} fn.index Current array index.
@param {Array} fn.array Array being iterated over.
@param {Object} [thisObj] `this` object to use when calling _fn_.
@return {Boolean} `true` if the function returns a truthy value on any of the
items in the array; `false` otherwise.
@static
**/
YArray.some = Lang._isNative(Native.some)
? function (array, fn, thisObj) {
return Native.some.call(array, fn, thisObj);
}
: function (array, fn, thisObj) {
for (var i = 0, len = array.length; i < len; ++i) {
if (i in array && fn.call(thisObj, array[i], i, array)) {
return true;
}
}
return false;
};
/**
Evaluates _obj_ to determine if it's an array, an array-like collection, or
something else. This is useful when working with the function `arguments`
collection and `HTMLElement` collections.
Note: This implementation doesn't consider elements that are also
collections, such as `<form>` and `<select>`, to be array-like.
@method test
@param {Object} obj Object to test.
@return {Number} A number indicating the results of the test:
* 0: Neither an array nor an array-like collection.
* 1: Real array.
* 2: Array-like collection.
@static
**/
YArray.test = function (obj) {
var result = 0;
if (Lang.isArray(obj)) {
result = 1;
} else if (Lang.isObject(obj)) {
try {
// indexed, but no tagName (element) or scrollTo/document (window. From DOM.isWindow test which we can't use here),
// or functions without apply/call (Safari
// HTMLElementCollection bug).
if (
"length" in obj &&
!obj.tagName &&
!(obj.scrollTo && obj.document) &&
!obj.apply
) {
result = 2;
}
} catch (ex) {}
}
return result;
};
/**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/
/**
* A simple FIFO queue. Items are added to the Queue with add(1..n items) and
* removed using next().
*
* @class Queue
* @constructor
* @param {MIXED} item* 0..n items to seed the queue.
*/
function Queue() {
this._init();
this.add.apply(this, arguments);
}
Queue.prototype = {
/**
* Initialize the queue
*
* @method _init
* @protected
*/
_init: function () {
/**
* The collection of enqueued items
*
* @property _q
* @type Array
* @protected
*/
this._q = [];
},
/**
* Get the next item in the queue. FIFO support
*
* @method next
* @return {MIXED} the next item in the queue.
*/
next: function () {
return this._q.shift();
},
/**
* Get the last in the queue. LIFO support.
*
* @method last
* @return {MIXED} the last item in the queue.
*/
last: function () {
return this._q.pop();
},
/**
* Add 0..n items to the end of the queue.
*
* @method add
* @param {MIXED} item* 0..n items.
* @return {object} this queue.
*/
add: function () {
this._q.push.apply(this._q, arguments);
return this;
},
/**
* Returns the current number of queued items.
*
* @method size
* @return {Number} The size.
*/
size: function () {
return this._q.length;
},
};
Y.Queue = Queue;
YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Queue();
/**
The YUI module contains the components required for building the YUI seed file.
This includes the script loading mechanism, a simple queue, and the core
utilities for the library.
@module yui
@submodule yui-base
**/
var CACHED_DELIMITER = "__",
hasOwn = Object.prototype.hasOwnProperty,
isObject = Y.Lang.isObject;
/**
Returns a wrapper for a function which caches the return value of that function,
keyed off of the combined string representation of the argument values provided
when the wrapper is called.
Calling this function again with the same arguments will return the cached value
rather than executing the wrapped function.
Note that since the cache is keyed off of the string representation of arguments
passed to the wrapper function, arguments that aren't strings and don't provide
a meaningful `toString()` method may result in unexpected caching behavior. For
example, the objects `{}` and `{foo: 'bar'}` would both be converted to the
string `[object Object]` when used as a cache key.
@method cached
@param {Function} source The function to memoize.
@param {Object} [cache={}] Object in which to store cached values. You may seed
this object with pre-existing cached values if desired.
@param {any} [refetch] If supplied, this value is compared with the cached value
using a `==` comparison. If the values are equal, the wrapped function is
executed again even though a cached value exists.
@return {Function} Wrapped function.
@for YUI
**/
Y.cached = function (source, cache, refetch) {
/*jshint expr: true*/
cache || (cache = {});
return function (arg) {
var key =
arguments.length > 1
? Array.prototype.join.call(arguments, CACHED_DELIMITER)
: String(arg);
/*jshint eqeqeq: false*/
if (!(key in cache) || (refetch && cache[key] == refetch)) {
cache[key] = source.apply(source, arguments);
}
return cache[key];
};
};
/**
Returns the `location` object from the window/frame in which this YUI instance
operates, or `undefined` when executing in a non-browser environment
(e.g. Node.js).
It is _not_ recommended to hold references to the `window.location` object
outside of the scope of a function in which its properties are being accessed or
its methods are being called. This is because of a nasty bug/issue that exists
in both Safari and MobileSafari browsers:
[WebKit Bug 34679](https://bugs.webkit.org/show_bug.cgi?id=34679).
@method getLocation
@return {location} The `location` object from the window/frame in which this YUI
instance operates.
@since 3.5.0
**/
Y.getLocation = function () {
// It is safer to look this up every time because yui-base is attached to a
// YUI instance before a user's config is applied; i.e. `Y.config.win` does
// not point the correct window object when this file is loaded.
var win = Y.config.win;
// It is not safe to hold a reference to the `location` object outside the
// scope in which it is being used. The WebKit engine used in Safari and
// MobileSafari will "disconnect" the `location` object from the `window`
// when a page is restored from back/forward history cache.
return win && win.location;
};
/**
Returns a new object containing all of the properties of all the supplied
objects. The properties from later objects will overwrite those in earlier
objects.
Passing in a single object will create a shallow copy of it. For a deep copy,
use `clone()`.
@method merge
@param {Object} objects* One or more objects to merge.
@return {Object} A new merged object.
**/
Y.merge = function () {
var i = 0,
len = arguments.length,
result = {},
key,
obj;
for (; i < len; ++i) {
obj = arguments[i];
for (key in obj) {
if (hasOwn.call(obj, key)) {
result[key] = obj[key];
}
}
}
return result;
};
/**
Mixes _supplier_'s properties into _receiver_.
Properties on _receiver_ or _receiver_'s prototype will not be overwritten or
shadowed unless the _overwrite_ parameter is `true`, and will not be merged
unless the _merge_ parameter is `true`.
In the default mode (0), only properties the supplier owns are copied (prototype
properties are not copied). The following copying modes are available:
* `0`: _Default_. Object to object.
* `1`: Prototype to prototype.
* `2`: Prototype to prototype and object to object.
* `3`: Prototype to object.
* `4`: Object to prototype.
@method mix
@param {Function|Object} receiver The object or function to receive the mixed
properties.
@param {Function|Object} supplier The object or function supplying the
properties to be mixed.
@param {Boolean} [overwrite=false] If `true`, properties that already exist
on the receiver will be overwritten with properties from the supplier.
@param {String[]} [whitelist] An array of property names to copy. If
specified, only the whitelisted properties will be copied, and all others
will be ignored.
@param {Number} [mode=0] Mix mode to use. See above for available modes.
@param {Boolean} [merge=false] If `true`, objects and arrays that already
exist on the receiver will have the corresponding object/array from the
supplier merged into them, rather than being skipped or overwritten. When
both _overwrite_ and _merge_ are `true`, _merge_ takes precedence.
@return {Function|Object|YUI} The receiver, or the YUI instance if the
specified receiver is falsy.
**/
Y.mix = function (receiver, supplier, overwrite, whitelist, mode, merge) {
var alwaysOverwrite, exists, from, i, key, len, to;
// If no supplier is given, we return the receiver. If no receiver is given,
// we return Y. Returning Y doesn't make much sense to me, but it's
// grandfathered in for backcompat reasons.
if (!receiver || !supplier) {
return receiver || Y;
}
if (mode) {
// In mode 2 (prototype to prototype and object to object), we recurse
// once to do the proto to proto mix. The object to object mix will be
// handled later on.
if (mode === 2) {
Y.mix(
receiver.prototype,
supplier.prototype,
overwrite,
whitelist,
0,
merge,
);
}
// Depending on which mode is specified, we may be copying from or to
// the prototypes of the supplier and receiver.
from = mode === 1 || mode === 3 ? supplier.prototype : supplier;
to = mode === 1 || mode === 4 ? receiver.prototype : receiver;
// If either the supplier or receiver doesn't actually have a
// prototype property, then we could end up with an undefined `from`
// or `to`. If that happens, we abort and return the receiver.
if (!from || !to) {
return receiver;
}
} else {
from = supplier;
to = receiver;
}
// If `overwrite` is truthy and `merge` is falsy, then we can skip a
// property existence check on each iteration and save some time.
alwaysOverwrite = overwrite && !merge;
if (whitelist) {
for (i = 0, len = whitelist.length; i < len; ++i) {
key = whitelist[i];
// We call `Object.prototype.hasOwnProperty` instead of calling
// `hasOwnProperty` on the object itself, since the object's
// `hasOwnProperty` method may have been overridden or removed.
// Also, some native objects don't implement a `hasOwnProperty`
// method.
if (!hasOwn.call(from, key)) {
continue;
}
// The `key in to` check here is (sadly) intentional for backwards
// compatibility reasons. It prevents undesired shadowing of
// prototype members on `to`.
exists = alwaysOverwrite ? false : key in to;
if (
merge &&
exists &&
isObject(to[key], true) &&
isObject(from[key], true)
) {
// If we're in merge mode, and the key is present on both
// objects, and the value on both objects is either an object or
// an array (but not a function), then we recurse to merge the
// `from` value into the `to` value instead of overwriting it.
//
// Note: It's intentional that the whitelist isn't passed to the
// recursive call here. This is legacy behavior that lots of
// code still depends on.
Y.mix(to[key], from[key], overwrite, null, 0, merge);
} else if (overwrite || !exists) {
// We're not in merge mode, so we'll only copy the `from` value
// to the `to` value if we're in overwrite mode or if the
// current key doesn't exist on the `to` object.
to[key] = from[key];
}
}
} else {
for (key in from) {
// The code duplication here is for runtime performance reasons.
// Combining whitelist and non-whitelist operations into a single
// loop or breaking the shared logic out into a function both result
// in worse performance, and Y.mix is critical enough that the byte
// tradeoff is worth it.
if (!hasOwn.call(from, key)) {
continue;
}
// The `key in to` check here is (sadly) intentional for backwards
// compatibility reasons. It prevents undesired shadowing of
// prototype members on `to`.
exists = alwaysOverwrite ? false : key in to;
if (
merge &&
exists &&
isObject(to[key], true) &&
isObject(from[key], true)
) {
Y.mix(to[key], from[key], overwrite, null, 0, merge);
} else if (overwrite || !exists) {
to[key] = from[key];
}
}
// If this is an IE browser with the JScript enumeration bug, force
// enumeration of the buggy properties by making a recursive call with
// the buggy properties as the whitelist.
if (Y.Object._hasEnumBug) {
Y.mix(to, from, overwrite, Y.Object._forceEnum, mode, merge);
}
}
return receiver;
};
/**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/
/**
* Adds utilities to the YUI instance for working with objects.
*
* @class Object
*/
var Lang = Y.Lang,
hasOwn = Object.prototype.hasOwnProperty,
UNDEFINED, // <-- Note the comma. We're still declaring vars.
/**
* Returns a new object that uses _obj_ as its prototype. This method wraps the
* native ES5 `Object.create()` method if available, but doesn't currently
* pass through `Object.create()`'s second argument (properties) in order to
* ensure compatibility with older browsers.
*
* @method ()
* @param {Object} obj Prototype object.
* @return {Object} New object using _obj_ as its prototype.
* @static
*/
O = (Y.Object = Lang._isNative(Object.create)
? function (obj) {
// We currently wrap the native Object.create instead of simply aliasing it
// to ensure consistency with our fallback shim, which currently doesn't
// support Object.create()'s second argument (properties). Once we have a
// safe fallback for the properties arg, we can stop wrapping
// Object.create().
return Object.create(obj);
}
: (function () {
// Reusable constructor function for the Object.create() shim.
function F() {}
// The actual shim.
return function (obj) {
F.prototype = obj;
return new F();
};
})()),
/**
* Property names that IE doesn't enumerate in for..in loops, even when they
* should be enumerable. When `_hasEnumBug` is `true`, it's necessary to
* manually enumerate these properties.
*
* @property _forceEnum
* @type String[]
* @protected
* @static
*/
forceEnum = (O._forceEnum = [
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"toString",
"toLocaleString",
"valueOf",
]),
/**
* `true` if this browser has the JScript enumeration bug that prevents
* enumeration of the properties named in the `_forceEnum` array, `false`
* otherwise.
*
* See:
* - <https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug>
* - <http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation>
*
* @property _hasEnumBug
* @type Boolean
* @protected
* @static
*/
hasEnumBug = (O._hasEnumBug = !{ valueOf: 0 }.propertyIsEnumerable(
"valueOf",
)),
/**
* `true` if this browser incorrectly considers the `prototype` property of
* functions to be enumerable. Currently known to affect Opera 11.50 and Android 2.3.x.
*
* @property _hasProtoEnumBug
* @type Boolean
* @protected
* @static
*/
hasProtoEnumBug = (O._hasProtoEnumBug =
function () {}.propertyIsEnumerable("prototype")),
/**
* Returns `true` if _key_ exists on _obj_, `false` if _key_ doesn't exist or
* exists only on _obj_'s prototype. This is essentially a safer version of
* `obj.hasOwnProperty()`.
*
* @method owns
* @param {Object} obj Object to test.
* @param {String} key Property name to look for.
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
* @static
*/
owns = (O.owns = function (obj, key) {
return !!obj && hasOwn.call(obj, key);
}); // <-- End of var declarations.
/**
* Alias for `owns()`.
*
* @method hasKey
* @param {Object} obj Object to test.
* @param {String} key Property name to look for.
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
* @static
*/
O.hasKey = owns;
/**
* Returns an array containing the object's enumerable keys. Does not include
* prototype keys or non-enumerable keys.
*
* Note that keys are returned in enumeration order (that is, in the same order
* that they would be enumerated by a `for-in` loop), which may not be the same
* as the order in which they were defined.
*
* This method is an alias for the native ES5 `Object.keys()` method if
* available and non-buggy. The Opera 11.50 and Android 2.3.x versions of
* `Object.keys()` have an inconsistency as they consider `prototype` to be
* enumerable, so a non-native shim is used to rectify the difference.
*
* @example
*
* Y.Object.keys({a: 'foo', b: 'bar', c: 'baz'});
* // => ['a', 'b', 'c']
*
* @method keys
* @param {Object} obj An object.
* @return {String[]} Array of keys.
* @static
*/
O.keys =
Lang._isNative(Object.keys) && !hasProtoEnumBug
? Object.keys
: function (obj) {
if (!Lang.isObject(obj)) {
throw new TypeError("Object.keys called on a non-object");
}
var keys = [],
i,
key,
len;
if (hasProtoEnumBug && typeof obj === "function") {
for (key in obj) {
if (owns(obj, key) && key !== "prototype") {
keys.push(key);
}
}
} else {
for (key in obj) {
if (owns(obj, key)) {
keys.push(key);
}
}
}
if (hasEnumBug) {
for (i = 0, len = forceEnum.length; i < len; ++i) {
key = forceEnum[i];
if (owns(obj, key)) {
keys.push(key);
}
}
}
return keys;
};
/**
* Returns an array containing the values of the object's enumerable keys.
*
* Note that values are returned in enumeration order (that is, in the same
* order that they would be enumerated by a `for-in` loop), which may not be the
* same as the order in which they were defined.
*
* @example
*
* Y.Object.values({a: 'foo', b: 'bar', c: 'baz'});
* // => ['foo', 'bar', 'baz']
*
* @method values
* @param {Object} obj An object.
* @return {Array} Array of values.
* @static
*/
O.values = function (obj) {
var keys = O.keys(obj),
i = 0,
len = keys.length,
values = [];
for (; i < len; ++i) {
values.push(obj[keys[i]]);
}
return values;
};
/**
* Returns the number of enumerable keys owned by an object.
*
* @method size
* @param {Object} obj An object.
* @return {Number} The object's size.
* @static
*/
O.size = function (obj) {
try {
return O.keys(obj).length;
} catch (ex) {
return 0; // Legacy behavior for non-objects.
}
};
/**
* Returns `true` if the object owns an enumerable property with the specified
* value.
*
* @method hasValue
* @param {Object} obj An object.
* @param {any} value The value to search for.
* @return {Boolean} `true` if _obj_ contains _value_, `false` otherwise.
* @static
*/
O.hasValue = function (obj, value) {
return Y.Array.indexOf(O.values(obj), value) > -1;
};
/**
* Executes a function on each enumerable property in _obj_. The function
* receives the value, the key, and the object itself as parameters (in that
* order).
*
* By default, only properties owned by _obj_ are enumerated. To include
* prototype properties, set the _proto_ parameter to `true`.
*
* @method each
* @param {Object} obj Object to enumerate.
* @param {Function} fn Function to execute on each enumerable property.
* @param {mixed} fn.value Value of the current property.
* @param {String} fn.key Key of the current property.
* @param {Object} fn.obj Object being enumerated.
* @param {Object} [thisObj] `this` object to use when calling _fn_.
* @param {Boolean} [proto=false] Include prototype properties.
* @return {YUI} the YUI instance.
* @chainable
* @static
*/
O.each = function (obj, fn, thisObj, proto) {
var key;
for (key in obj) {
if (proto || owns(obj, key)) {
fn.call(thisObj || Y, obj[key], key, obj);
}
}
return Y;
};
/**
* Executes a function on each enumerable property in _obj_, but halts if the
* function returns a truthy value. The function receives the value, the key,
* and the object itself as paramters (in that order).
*
* By default, only properties owned by _obj_ are enumerated. To include
* prototype properties, set the _proto_ parameter to `true`.
*
* @method some
* @param {Object} obj Object to enumerate.
* @param {Function} fn Function to execute on each enumerable property.
* @param {mixed} fn.value Value of the current property.
* @param {String} fn.key Key of the current property.
* @param {Object} fn.obj Object being enumerated.
* @param {Object} [thisObj] `this` object to use when calling _fn_.
* @param {Boolean} [proto=false] Include prototype properties.
* @return {Boolean} `true` if any execution of _fn_ returns a truthy value,
* `false` otherwise.
* @static
*/
O.some = function (obj, fn, thisObj, proto) {
var key;
for (key in obj) {
if (proto || owns(obj, key)) {
if (fn.call(thisObj || Y, obj[key], key, obj)) {
return true;
}
}
}
return false;
};
/**
* Retrieves the sub value at the provided path,
* from the value object provided.
*
* @method getValue
* @static
* @param o The object from which to extract the property value.
* @param path {Array} A path array, specifying the object traversal path
* from which to obtain the sub value.
* @return {Any} The value stored in the path, undefined if not found,
* undefined if the source is not an object. Returns the source object
* if an empty path is provided.
*/
O.getValue = function (o, path) {
if (!Lang.isObject(o)) {
return UNDEFINED;
}
var i,
p = Y.Array(path),
l = p.length;
for (i = 0; o !== UNDEFINED && i < l; i++) {
o = o[p[i]];
}
return o;
};
/**
* Sets the sub-attribute value at the provided path on the
* value object. Returns the modified value object, or
* undefined if the path is invalid.
*
* @method setValue
* @static
* @param o The object on which to set the sub value.
* @param path {Array} A path array, specifying the object traversal path
* at which to set the sub value.
* @param val {Any} The new value for the sub-attribute.
* @return {Object} The modified object, with the new sub value set, or
* undefined, if the path was invalid.
*/
O.setValue = function (o, path, val) {
var i,
p = Y.Array(path),
leafIdx = p.length - 1,
ref = o;
if (leafIdx >= 0) {
for (i = 0; ref !== UNDEFINED && i < leafIdx; i++) {
ref = ref[p[i]];
}
if (ref !== UNDEFINED) {
ref[p[i]] = val;
} else {
return UNDEFINED;
}
}
return o;
};
/**
* Returns `true` if the object has no enumerable properties of its own.
*
* @method isEmpty
* @param {Object} obj An object.
* @return {Boolean} `true` if the object is empty.
* @static
* @since 3.2.0
*/
O.isEmpty = function (obj) {
return !O.keys(Object(obj)).length;
};
/**
* The YUI module contains the components required for building the YUI seed
* file. This includes the script loading mechanism, a simple queue, and the
* core utilities for the library.
* @module yui
* @submodule yui-base
*/
/**
* YUI user agent detection.
* Do not fork for a browser if it can be avoided. Use feature detection when
* you can. Use the user agent as a last resort. For all fields listed
* as @type float, UA stores a version number for the browser engine,
* 0 otherwise. This value may or may not map to the version number of
* the browser using the engine. The value is presented as a float so
* that it can easily be used for boolean evaluation as well as for
* looking for a particular range of versions. Because of this,
* some of the granularity of the version info may be lost. The fields that
* are @type string default to null. The API docs list the values that
* these fields can have.
* @class UA
* @static
*/
/**
* Static method on `YUI.Env` for parsing a UA string. Called at instantiation
* to populate `Y.UA`.
*
* @static
* @method parseUA
* @param {String} [subUA=navigator.userAgent] UA string to parse
* @return {Object} The Y.UA object
*/
YUI.Env.parseUA = function (subUA) {
var numberify = function (s) {
var c = 0;
return parseFloat(
s.replace(/\./g, function () {
return c++ === 1 ? "" : ".";
}),
);
},
win = Y.config.win,
nav = win && win.navigator,
o = {
/**
* Internet Explorer version number or 0. Example: 6
* @property ie
* @type float
* @static
*/
ie: 0,
/**
* Opera version number or 0. Example: 9.2
* @property opera
* @type float
* @static
*/
opera: 0,
/**
* Gecko engine revision number. Will evaluate to 1 if Gecko
* is detected but the revision could not be found. Other browsers
* will be 0. Example: 1.8
* <pre>
* Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7
* Firefox 1.5.0.9: 1.8.0.9 <-- 1.8
* Firefox 2.0.0.3: 1.8.1.3 <-- 1.81
* Firefox 3.0 <-- 1.9
* Firefox 3.5 <-- 1.91
* </pre>
* @property gecko
* @type float
* @static
*/
gecko: 0,
/**
* AppleWebKit version. KHTML browsers that are not WebKit browsers
* will evaluate to 1, other browsers 0. Example: 418.9
* <pre>
* Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the
* latest available for Mac OSX 10.3.
* Safari 2.0.2: 416 <-- hasOwnProperty introduced
* Safari 2.0.4: 418 <-- preventDefault fixed
* Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run
* different versions of webkit
* Safari 2.0.4 (419.3): 419 <-- Tiger installations that have been
* updated, but not updated
* to the latest patch.
* Webkit 212 nightly: 522+ <-- Safari 3.0 precursor (with native
* SVG and many major issues fixed).
* Safari 3.0.4 (523.12) 523.12 <-- First Tiger release - automatic
* update from 2.x via the 10.4.11 OS patch.
* Webkit nightly 1/2008:525+ <-- Supports DOMContentLoaded event.
* yahoo.com user agent hack removed.
* </pre>
* http://en.wikipedia.org/wiki/Safari_version_history
* @property webkit
* @type float
* @static
*/
webkit: 0,
/**
* Safari will be detected as webkit, but this property will also
* be populated with the Safari version number
* @property safari
* @type float
* @static
*/
safari: 0,
/**
* Chrome will be detected as webkit, but this property will also
* be populated with the Chrome version number
* @property chrome
* @type float
* @static
*/
chrome: 0,
/**
* The mobile property will be set to a string containing any relevant
* user agent information when a modern mobile browser is detected.
* Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series
* devices with the WebKit-based browser, and Opera Mini.
* @property mobile
* @type string
* @default null
* @static
*/
mobile: null,
/**
* Adobe AIR version number or 0. Only populated if webkit is detected.
* Example: 1.0
* @property air
* @type float
*/
air: 0,
/**
* PhantomJS version number or 0. Only populated if webkit is detected.
* Example: 1.0
* @property phantomjs
* @type float
*/
phantomjs: 0,
/**
* Detects Apple iPad's OS version
* @property ipad
* @type float
* @static
*/
ipad: 0,
/**
* Detects Apple iPhone's OS version
* @property iphone
* @type float
* @static
*/
iphone: 0,
/**
* Detects Apples iPod's OS version
* @property ipod
* @type float
* @static
*/
ipod: 0,
/**
* General truthy check for iPad, iPhone or iPod
* @property ios
* @type Boolean
* @default null
* @static
*/
ios: null,
/**
* Detects Googles Android OS version
* @property android
* @type float
* @static
*/
android: 0,
/**
* Detects Kindle Silk
* @property silk
* @type float
* @static
*/
silk: 0,
/**
* Detects Kindle Silk Acceleration
* @property accel
* @type Boolean
* @static
*/
accel: false,
/**
* Detects Palms WebOS version
* @property webos
* @type float
* @static
*/
webos: 0,
/**
* Google Caja version number or 0.
* @property caja
* @type float
*/
caja: nav && nav.cajaVersion,
/**
* Set to true if the page appears to be in SSL
* @property secure
* @type boolean
* @static
*/
secure: false,
/**
* The operating system. Currently only detecting windows or macintosh
* @property os
* @type string
* @default null
* @static
*/
os: null,
/**
* The Nodejs Version
* @property nodejs
* @type float
* @default 0
* @static
*/
nodejs: 0,
/**
* Window8/IE10 Application host environment
* @property winjs
* @type Boolean
* @static
*/
winjs: !!(typeof Windows !== "undefined" && Windows.System),
/**
* Are touch/msPointer events available on this device
* @property touchEnabled
* @type Boolean
* @static
*/
touchEnabled: false,
},
ua = subUA || (nav && nav.userAgent),
loc = win && win.location,
href = loc && loc.href,
m;
/**
* The User Agent string that was parsed
* @property userAgent
* @type String
* @static
*/
o.userAgent = ua;
o.secure = href && href.toLowerCase().indexOf("https") === 0;
if (ua) {
if (/windows|win32/i.test(ua)) {
o.os = "windows";
} else if (/macintosh|mac_powerpc/i.test(ua)) {
o.os = "macintosh";
} else if (/android/i.test(ua)) {
o.os = "android";
} else if (/symbos/i.test(ua)) {
o.os = "symbos";
} else if (/linux/i.test(ua)) {
o.os = "linux";
} else if (/rhino/i.test(ua)) {
o.os = "rhino";
}
// Modern KHTML browsers should qualify as Safari X-Grade
if (/KHTML/.test(ua)) {
o.webkit = 1;
}
if (/IEMobile|XBLWP7/.test(ua)) {
o.mobile = "windows";
}
if (/Fennec/.test(ua)) {
o.mobile = "gecko";
}
// Modern WebKit browsers are at least X-Grade
m = ua.match(/AppleWebKit\/([^\s]*)/);
if (m && m[1]) {
o.webkit = numberify(m[1]);
o.safari = o.webkit;
if (/PhantomJS/.test(ua)) {
m = ua.match(/PhantomJS\/([^\s]*)/);
if (m && m[1]) {
o.phantomjs = numberify(m[1]);
}
}
// Mobile browser check
if (/ Mobile\//.test(ua) || /iPad|iPod|iPhone/.test(ua)) {
o.mobile = "Apple"; // iPhone or iPod Touch
m = ua.match(/OS ([^\s]*)/);
if (m && m[1]) {
m = numberify(m[1].replace("_", "."));
}
o.ios = m;
o.os = "ios";
o.ipad = o.ipod = o.iphone = 0;
m = ua.match(/iPad|iPod|iPhone/);
if (m && m[0]) {
o[m[0].toLowerCase()] = o.ios;
}
} else {
m = ua.match(/NokiaN[^\/]*|webOS\/\d\.\d/);
if (m) {
// Nokia N-series, webOS, ex: NokiaN95
o.mobile = m[0];
}
if (/webOS/.test(ua)) {
o.mobile = "WebOS";
m = ua.match(/webOS\/([^\s]*);/);
if (m && m[1]) {
o.webos = numberify(m[1]);
}
}
if (/ Android/.test(ua)) {
if (/Mobile/.test(ua)) {
o.mobile = "Android";
}
m = ua.match(/Android ([^\s]*);/);
if (m && m[1]) {
o.android = numberify(m[1]);
}
}
if (/Silk/.test(ua)) {
m = ua.match(/Silk\/([^\s]*)\)/);
if (m && m[1]) {
o.silk = numberify(m[1]);
}
if (!o.android) {
o.android = 2.34; //Hack for desktop mode in Kindle
o.os = "Android";
}
if (/Accelerated=true/.test(ua)) {
o.accel = true;
}
}
}
m = ua.match(/OPR\/(\d+\.\d+)/);
if (m && m[1]) {
// Opera 15+ with Blink (pretends to be both Chrome and Safari)
o.opera = numberify(m[1]);
} else {
m = ua.match(/(Chrome|CrMo|CriOS)\/([^\s]*)/);
if (m && m[1] && m[2]) {
o.chrome = numberify(m[2]); // Chrome
o.safari = 0; //Reset safari back to 0
if (m[1] === "CrMo") {
o.mobile = "chrome";
}
} else {
m = ua.match(/AdobeAIR\/([^\s]*)/);
if (m) {
o.air = m[0]; // Adobe AIR 1.0 or better
}
}
}
}
if (!o.webkit) {
// not webkit
// @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr)
if (/Opera/.test(ua)) {
m = ua.match(/Opera[\s\/]([^\s]*)/);
if (m && m[1]) {
o.opera = numberify(m[1]);
}
m = ua.match(/Version\/([^\s]*)/);
if (m && m[1]) {
o.opera = numberify(m[1]); // opera 10+
}
if (/Opera Mobi/.test(ua)) {
o.mobile = "opera";
m = ua.replace("Opera Mobi", "").match(/Opera ([^\s]*)/);
if (m && m[1]) {
o.opera = numberify(m[1]);
}
}
m = ua.match(/Opera Mini[^;]*/);
if (m) {
o.mobile = m[0]; // ex: Opera Mini/2.0.4509/1316
}
} else {
// not opera or webkit
m = ua.match(/MSIE ([^;]*)|Trident.*; rv:([0-9.]+)/);
if (m && (m[1] || m[2])) {
o.ie = numberify(m[1] || m[2]);
} else {
// not opera, webkit, or ie
m = ua.match(/Gecko\/([^\s]*)/);
if (m) {
o.gecko = 1; // Gecko detected, look for revision
m = ua.match(/rv:([^\s\)]*)/);
if (m && m[1]) {
o.gecko = numberify(m[1]);
if (/Mobile|Tablet/.test(ua)) {
o.mobile = "ffos";
}
}
}
}
}
}
}
//Check for known properties to tell if touch events are enabled on this device or if
//the number of MSPointer touchpoints on this device is greater than 0.
if (win && nav && !(o.chrome && o.chrome < 6)) {
o.touchEnabled =
"ontouchstart" in win ||
("msMaxTouchPoints" in nav && nav.msMaxTouchPoints > 0);
}
//It was a parsed UA, do not assign the global value.
if (!subUA) {
if (typeof process === "object") {
if (process.versions && process.versions.node) {
//NodeJS
o.os = process.platform;
o.nodejs = numberify(process.versions.node);
}
}
YUI.Env.UA = o;
}
return o;
};
Y.UA = YUI.Env.UA || YUI.Env.parseUA();
/**
Performs a simple comparison between two version numbers, accounting for
standard versioning logic such as the fact that "535.8" is a lower version than
"535.24", even though a simple numerical comparison would indicate that it's
greater. Also accounts for cases such as "1.1" vs. "1.1.0", which are
considered equivalent.
Returns -1 if version _a_ is lower than version _b_, 0 if they're equivalent,
1 if _a_ is higher than _b_.
Versions may be numbers or strings containing numbers and dots. For example,
both `535` and `"535.8.10"` are acceptable. A version string containing
non-numeric characters, like `"535.8.beta"`, may produce unexpected results.
@method compareVersions
@param {Number|String} a First version number to compare.
@param {Number|String} b Second version number to compare.
@return -1 if _a_ is lower than _b_, 0 if they're equivalent, 1 if _a_ is
higher than _b_.
**/
Y.UA.compareVersions = function (a, b) {
var aPart, aParts, bPart, bParts, i, len;
if (a === b) {
return 0;
}
aParts = (a + "").split(".");
bParts = (b + "").split(".");
for (i = 0, len = Math.max(aParts.length, bParts.length); i < len; ++i) {
aPart = parseInt(aParts[i], 10);
bPart = parseInt(bParts[i], 10);
/*jshint expr: true*/
isNaN(aPart) && (aPart = 0);
isNaN(bPart) && (bPart = 0);
if (aPart < bPart) {
return -1;
}
if (aPart > bPart) {
return 1;
}
}
return 0;
};
YUI.Env.aliases = {
anim: [
"anim-base",
"anim-color",
"anim-curve",
"anim-easing",
"anim-node-plugin",
"anim-scroll",
"anim-xy",
],
"anim-shape-transform": ["anim-shape"],
app: [
"app-base",
"app-content",
"app-transitions",
"lazy-model-list",
"model",
"model-list",
"model-sync-rest",
"router",
"view",
"view-node-map",
],
attribute: ["attribute-base", "attribute-complex"],
"attribute-events": ["attribute-observable"],
autocomplete: [
"autocomplete-base",
"autocomplete-sources",
"autocomplete-list",
"autocomplete-plugin",
],
axes: ["axis-numeric", "axis-category", "axis-time", "axis-stacked"],
"axes-base": [
"axis-numeric-base",
"axis-category-base",
"axis-time-base",
"axis-stacked-base",
],
base: ["base-base", "base-pluginhost", "base-build"],
cache: ["cache-base", "cache-offline", "cache-plugin"],
charts: ["charts-base"],
collection: [
"array-extras",
"arraylist",
"arraylist-add",
"arraylist-filter",
"array-invoke",
],
color: ["color-base", "color-hsl", "color-harmony"],
controller: ["router"],
dataschema: [
"dataschema-base",
"dataschema-json",
"dataschema-xml",
"dataschema-array",
"dataschema-text",
],
datasource: [
"datasource-local",
"datasource-io",
"datasource-get",
"datasource-function",
"datasource-cache",
"datasource-jsonschema",
"datasource-xmlschema",
"datasource-arrayschema",
"datasource-textschema",
"datasource-polling",
],
datatable: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"datatable-base",
"datatable-column-widths",
"datatable-message",
"datatable-mutable",
"datatable-sort",
"datatable-datasource",
],
datatype: ["datatype-date", "datatype-number", "datatype-xml"],
"datatype-date": [
"datatype-date-parse",
"datatype-date-format",
"datatype-date-math",
],
"datatype-number": ["datatype-number-parse", "datatype-number-format"],
"datatype-xml": ["datatype-xml-parse", "datatype-xml-format"],
dd: [
"dd-ddm-base",
"dd-ddm",
"dd-ddm-drop",
"dd-drag",
"dd-proxy",
"dd-constrain",
"dd-drop",
"dd-scroll",
"dd-delegate",
],
dom: [
"dom-base",
"dom-screen",
"dom-style",
"selector-native",
"selector",
],
editor: [
"frame",
"editor-selection",
"exec-command",
"editor-base",
"editor-para",
"editor-br",
"editor-bidi",
"editor-tab",
"createlink-base",
],
event: [
"event-base",
"event-delegate",
"event-synthetic",
"event-mousewheel",
"event-mouseenter",
"event-key",
"event-focus",
"event-resize",
"event-hover",
"event-outside",
"event-touch",
"event-move",
"event-flick",
"event-valuechange",
"event-tap",
],
"event-custom": ["event-custom-base", "event-custom-complex"],
"event-gestures": ["event-flick", "event-move"],
handlebars: ["handlebars-compiler"],
highlight: ["highlight-base", "highlight-accentfold"],
history: [
"history-base",
"history-hash",
"history-hash-ie",
"history-html5",
],
io: ["io-base", "io-xdr", "io-form", "io-upload-iframe", "io-queue"],
json: ["json-parse", "json-stringify"],
loader: ["loader-base", "loader-rollup", "loader-yui3"],
node: [
"node-base",
"node-event-delegate",
"node-pluginhost",
"node-screen",
"node-style",
],
pluginhost: ["pluginhost-base", "pluginhost-config"],
querystring: ["querystring-parse", "querystring-stringify"],
recordset: [
"recordset-base",
"recordset-sort",
"recordset-filter",
"recordset-indexer",
],
resize: ["resize-base", "resize-proxy", "resize-constrain"],
slider: [
"slider-base",
"slider-value-range",
"clickable-rail",
"range-slider",
],
template: ["template-base", "template-micro"],
text: ["text-accentfold", "text-wordbreak"],
widget: [
"widget-base",
"widget-htmlparser",
"widget-skin",
"widget-uievents",
],
};
},
"3.12.0",
{
use: [
"yui-base",
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3",
],
},
);
YUI.add(
"get",
function (Y, NAME) {
/*jslint boss:true, expr:true, laxbreak: true */
/**
Provides dynamic loading of remote JavaScript and CSS resources.
@module get
@class Get
@static
**/
var Lang = Y.Lang,
CUSTOM_ATTRS, // defined lazily in Y.Get.Transaction._createNode()
Get,
Transaction;
Y.Get = Get = {
// -- Public Properties ----------------------------------------------------
/**
Default options for CSS requests. Options specified here will override
global defaults for CSS requests.
See the `options` property for all available options.
@property cssOptions
@type Object
@static
@since 3.5.0
**/
cssOptions: {
attributes: {
rel: "stylesheet",
},
doc: Y.config.linkDoc || Y.config.doc,
pollInterval: 50,
},
/**
Default options for JS requests. Options specified here will override global
defaults for JS requests.
See the `options` property for all available options.
@property jsOptions
@type Object
@static
@since 3.5.0
**/
jsOptions: {
autopurge: true,
doc: Y.config.scriptDoc || Y.config.doc,
},
/**
Default options to use for all requests.
Note that while all available options are documented here for ease of
discovery, some options (like callback functions) only make sense at the
transaction level.
Callback functions specified via the options object or the `options`
parameter of the `css()`, `js()`, or `load()` methods will receive the
transaction object as a parameter. See `Y.Get.Transaction` for details on
the properties and methods available on transactions.
@static
@since 3.5.0
@property {Object} options
@property {Boolean} [options.async=false] Whether or not to load scripts
asynchronously, meaning they're requested in parallel and execution
order is not guaranteed. Has no effect on CSS, since CSS is always
loaded asynchronously.
@property {Object} [options.attributes] HTML attribute name/value pairs that
should be added to inserted nodes. By default, the `charset` attribute
will be set to "utf-8" and nodes will be given an auto-generated `id`
attribute, but you can override these with your own values if desired.
@property {Boolean} [options.autopurge] Whether or not to automatically
purge inserted nodes after the purge threshold is reached. This is
`true` by default for JavaScript, but `false` for CSS since purging a
CSS node will also remove any styling applied by the referenced file.
@property {Object} [options.context] `this` object to use when calling
callback functions. Defaults to the transaction object.
@property {Mixed} [options.data] Arbitrary data object to pass to "on*"
callbacks.
@property {Document} [options.doc] Document into which nodes should be
inserted. By default, the current document is used.
@property {HTMLElement|String} [options.insertBefore] HTML element or id
string of an element before which all generated nodes should be
inserted. If not specified, Get will automatically determine the best
place to insert nodes for maximum compatibility.
@property {Function} [options.onEnd] Callback to execute after a transaction
is complete, regardless of whether it succeeded or failed.
@property {Function} [options.onFailure] Callback to execute after a
transaction fails, times out, or is aborted.
@property {Function} [options.onProgress] Callback to execute after each
individual request in a transaction either succeeds or fails.
@property {Function} [options.onSuccess] Callback to execute after a
transaction completes successfully with no errors. Note that in browsers
that don't support the `error` event on CSS `<link>` nodes, a failed CSS
request may still be reported as a success because in these browsers
it can be difficult or impossible to distinguish between success and
failure for CSS resources.
@property {Function} [options.onTimeout] Callback to execute after a
transaction times out.
@property {Number} [options.pollInterval=50] Polling interval (in
milliseconds) for detecting CSS load completion in browsers that don't
support the `load` event on `<link>` nodes. This isn't used for
JavaScript.
@property {Number} [options.purgethreshold=20] Number of nodes to insert
before triggering an automatic purge when `autopurge` is `true`.
@property {Number} [options.timeout] Number of milliseconds to wait before
aborting a transaction. When a timeout occurs, the `onTimeout` callback
is called, followed by `onFailure` and finally `onEnd`. By default,
there is no timeout.
@property {String} [options.type] Resource type ("css" or "js"). This option
is set automatically by the `css()` and `js()` functions and will be
ignored there, but may be useful when using the `load()` function. If
not specified, the type will be inferred from the URL, defaulting to
"js" if the URL doesn't contain a recognizable file extension.
**/
options: {
attributes: {
charset: "utf-8",
},
purgethreshold: 20,
},
// -- Protected Properties -------------------------------------------------
/**
Regex that matches a CSS URL. Used to guess the file type when it's not
specified.
@property REGEX_CSS
@type RegExp
@final
@protected
@static
@since 3.5.0
**/
REGEX_CSS: /\.css(?:[?;].*)?$/i,
/**
Regex that matches a JS URL. Used to guess the file type when it's not
specified.
@property REGEX_JS
@type RegExp
@final
@protected
@static
@since 3.5.0
**/
REGEX_JS: /\.js(?:[?;].*)?$/i,
/**
Contains information about the current environment, such as what script and
link injection features it supports.
This object is created and populated the first time the `_getEnv()` method
is called.
@property _env
@type Object
@protected
@static
@since 3.5.0
**/
/**
Mapping of document _yuid strings to <head> or <base> node references so we
don't have to look the node up each time we want to insert a request node.
@property _insertCache
@type Object
@protected
@static
@since 3.5.0
**/
_insertCache: {},
/**
Information about the currently pending transaction, if any.
This is actually an object with two properties: `callback`, containing the
optional callback passed to `css()`, `load()`, or `js()`; and `transaction`,
containing the actual transaction instance.
@property _pending
@type Object
@protected
@static
@since 3.5.0
**/
_pending: null,
/**
HTML nodes eligible to be purged next time autopurge is triggered.
@property _purgeNodes
@type HTMLElement[]
@protected
@static
@since 3.5.0
**/
_purgeNodes: [],
/**
Queued transactions and associated callbacks.
@property _queue
@type Object[]
@protected
@static
@since 3.5.0
**/
_queue: [],
// -- Public Methods -------------------------------------------------------
/**
Aborts the specified transaction.
This will cause the transaction's `onFailure` callback to be called and
will prevent any new script and link nodes from being added to the document,
but any resources that have already been requested will continue loading
(there's no safe way to prevent this, unfortunately).
*Note:* This method is deprecated as of 3.5.0, and will be removed in a
future version of YUI. Use the transaction-level `abort()` method instead.
@method abort
@param {Get.Transaction} transaction Transaction to abort.
@deprecated Use the `abort()` method on the transaction instead.
@static
**/
abort: function (transaction) {
var i, id, item, len, pending;
if (!transaction.abort) {
id = transaction;
pending = this._pending;
transaction = null;
if (pending && pending.transaction.id === id) {
transaction = pending.transaction;
this._pending = null;
} else {
for (i = 0, len = this._queue.length; i < len; ++i) {
item = this._queue[i].transaction;
if (item.id === id) {
transaction = item;
this._queue.splice(i, 1);
break;
}
}
}
}
transaction && transaction.abort();
},
/**
Loads one or more CSS files.
The _urls_ parameter may be provided as a URL string, a request object,
or an array of URL strings and/or request objects.
A request object is just an object that contains a `url` property and zero
or more options that should apply specifically to that request.
Request-specific options take priority over transaction-level options and
default options.
URLs may be relative or absolute, and do not have to have the same origin
as the current page.
The `options` parameter may be omitted completely and a callback passed in
its place, if desired.
@example
// Load a single CSS file and log a message on completion.
Y.Get.css('foo.css', function (err) {
if (err) {
} else {
}
});
// Load multiple CSS files and log a message when all have finished
// loading.
var urls = ['foo.css', 'http://example.com/bar.css', 'baz/quux.css'];
Y.Get.css(urls, function (err) {
if (err) {
} else {
}
});
// Specify transaction-level options, which will apply to all requests
// within the transaction.
Y.Get.css(urls, {
attributes: {'class': 'my-css'},
timeout : 5000
});
// Specify per-request options, which override transaction-level and
// default options.
Y.Get.css([
{url: 'foo.css', attributes: {id: 'foo'}},
{url: 'bar.css', attributes: {id: 'bar', charset: 'iso-8859-1'}}
]);
@method css
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} callback.err Array of errors that occurred during
the transaction, or `null` on success.
@param {Get.Transaction} callback.transaction Transaction object.
@return {Get.Transaction} Transaction object.
@static
**/
css: function (urls, options, callback) {
return this._load("css", urls, options, callback);
},
/**
Loads one or more JavaScript resources.
The _urls_ parameter may be provided as a URL string, a request object,
or an array of URL strings and/or request objects.
A request object is just an object that contains a `url` property and zero
or more options that should apply specifically to that request.
Request-specific options take priority over transaction-level options and
default options.
URLs may be relative or absolute, and do not have to have the same origin
as the current page.
The `options` parameter may be omitted completely and a callback passed in
its place, if desired.
Scripts will be executed in the order they're specified unless the `async`
option is `true`, in which case they'll be loaded in parallel and executed
in whatever order they finish loading.
@example
// Load a single JS file and log a message on completion.
Y.Get.js('foo.js', function (err) {
if (err) {
} else {
}
});
// Load multiple JS files, execute them in order, and log a message when
// all have finished loading.
var urls = ['foo.js', 'http://example.com/bar.js', 'baz/quux.js'];
Y.Get.js(urls, function (err) {
if (err) {
} else {
}
});
// Specify transaction-level options, which will apply to all requests
// within the transaction.
Y.Get.js(urls, {
attributes: {'class': 'my-js'},
timeout : 5000
});
// Specify per-request options, which override transaction-level and
// default options.
Y.Get.js([
{url: 'foo.js', attributes: {id: 'foo'}},
{url: 'bar.js', attributes: {id: 'bar', charset: 'iso-8859-1'}}
]);
@method js
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} callback.err Array of errors that occurred during
the transaction, or `null` on success.
@param {Get.Transaction} callback.transaction Transaction object.
@return {Get.Transaction} Transaction object.
@since 3.5.0
@static
**/
js: function (urls, options, callback) {
return this._load("js", urls, options, callback);
},
/**
Loads one or more CSS and/or JavaScript resources in the same transaction.
Use this method when you want to load both CSS and JavaScript in a single
transaction and be notified when all requested URLs have finished loading,
regardless of type.
Behavior and options are the same as for the `css()` and `js()` methods. If
a resource type isn't specified in per-request options or transaction-level
options, Get will guess the file type based on the URL's extension (`.css`
or `.js`, with or without a following query string). If the file type can't
be guessed from the URL, a warning will be logged and Get will assume the
URL is a JavaScript resource.
@example
// Load both CSS and JS files in a single transaction, and log a message
// when all files have finished loading.
Y.Get.load(['foo.css', 'bar.js', 'baz.css'], function (err) {
if (err) {
} else {
}
});
@method load
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} err Array of errors that occurred during the
transaction, or `null` on success.
@param {Get.Transaction} Transaction object.
@return {Get.Transaction} Transaction object.
@since 3.5.0
@static
**/
load: function (urls, options, callback) {
return this._load(null, urls, options, callback);
},
// -- Protected Methods ----------------------------------------------------
/**
Triggers an automatic purge if the purge threshold has been reached.
@method _autoPurge
@param {Number} threshold Purge threshold to use, in milliseconds.
@protected
@since 3.5.0
@static
**/
_autoPurge: function (threshold) {
if (threshold && this._purgeNodes.length >= threshold) {
this._purge(this._purgeNodes);
}
},
/**
Populates the `_env` property with information about the current
environment.
@method _getEnv
@return {Object} Environment information.
@protected
@since 3.5.0
@static
**/
_getEnv: function () {
var doc = Y.config.doc,
ua = Y.UA;
// Note: some of these checks require browser sniffs since it's not
// feasible to load test files on every pageview just to perform a
// feature test. I'm sorry if this makes you sad.
return (this._env = {
// True if this is a browser that supports disabling async mode on
// dynamically created script nodes. See
// https://developer.mozilla.org/En/HTML/Element/Script#Attributes
// IE10 doesn't return true for the MDN feature test, so setting it explicitly,
// because it is async by default, and allows you to disable async by setting it to false
async:
(doc && doc.createElement("script").async === true) || ua.ie >= 10,
// True if this browser fires an event when a dynamically injected
// link node fails to load. This is currently true for Firefox 9+
// and WebKit 535.24+
cssFail: ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0,
// True if this browser fires an event when a dynamically injected
// link node finishes loading. This is currently true for IE, Opera,
// Firefox 9+, and WebKit 535.24+. Note that IE versions <9 fire the
// DOM 0 "onload" event, but not "load". All versions of IE fire
// "onload".
// davglass: Seems that Chrome on Android needs this to be false.
cssLoad:
((!ua.gecko && !ua.webkit) ||
ua.gecko >= 9 ||
ua.compareVersions(ua.webkit, 535.24) >= 0) &&
!(ua.chrome && ua.chrome <= 18),
// True if this browser preserves script execution order while
// loading scripts in parallel as long as the script node's `async`
// attribute is set to false to explicitly disable async execution.
preservesScriptOrder: !!(
ua.gecko ||
ua.opera ||
(ua.ie && ua.ie >= 10)
),
});
},
_getTransaction: function (urls, options) {
var requests = [],
i,
len,
req,
url;
if (!Lang.isArray(urls)) {
urls = [urls];
}
options = Y.merge(this.options, options);
// Clone the attributes object so we don't end up modifying it by ref.
options.attributes = Y.merge(
this.options.attributes,
options.attributes,
);
for (i = 0, len = urls.length; i < len; ++i) {
url = urls[i];
req = { attributes: {} };
// If `url` is a string, we create a URL object for it, then mix in
// global options and request-specific options. If it's an object
// with a "url" property, we assume it's a request object containing
// URL-specific options.
if (typeof url === "string") {
req.url = url;
} else if (url.url) {
// URL-specific options override both global defaults and
// request-specific options.
Y.mix(req, url, false, null, 0, true);
url = url.url; // Make url a string so we can use it later.
} else {
continue;
}
Y.mix(req, options, false, null, 0, true);
// If we didn't get an explicit type for this URL either in the
// request options or the URL-specific options, try to determine
// one from the file extension.
if (!req.type) {
if (this.REGEX_CSS.test(url)) {
req.type = "css";
} else {
if (!this.REGEX_JS.test(url)) {
}
req.type = "js";
}
}
// Mix in type-specific default options, but don't overwrite any
// options that have already been set.
Y.mix(
req,
req.type === "js" ? this.jsOptions : this.cssOptions,
false,
null,
0,
true,
);
// Give the node an id attribute if it doesn't already have one.
req.attributes.id || (req.attributes.id = Y.guid());
// Backcompat for <3.5.0 behavior.
if (req.win) {
req.doc = req.win.document;
} else {
req.win = req.doc.defaultView || req.doc.parentWindow;
}
if (req.charset) {
req.attributes.charset = req.charset;
}
requests.push(req);
}
return new Transaction(requests, options);
},
_load: function (type, urls, options, callback) {
var transaction;
// Allow callback as third param.
if (typeof options === "function") {
callback = options;
options = {};
}
options || (options = {});
options.type = type;
options._onFinish = Get._onTransactionFinish;
if (!this._env) {
this._getEnv();
}
transaction = this._getTransaction(urls, options);
this._queue.push({
callback: callback,
transaction: transaction,
});
this._next();
return transaction;
},
_onTransactionFinish: function () {
Get._pending = null;
Get._next();
},
_next: function () {
var item;
if (this._pending) {
return;
}
item = this._queue.shift();
if (item) {
this._pending = item;
item.transaction.execute(item.callback);
}
},
_purge: function (nodes) {
var purgeNodes = this._purgeNodes,
isTransaction = nodes !== purgeNodes,
index,
node;
while ((node = nodes.pop())) {
// assignment
// Don't purge nodes that haven't finished loading (or errored out),
// since this can hang the transaction.
if (!node._yuiget_finished) {
continue;
}
node.parentNode && node.parentNode.removeChild(node);
// If this is a transaction-level purge and this node also exists in
// the Get-level _purgeNodes array, we need to remove it from
// _purgeNodes to avoid creating a memory leak. The indexOf lookup
// sucks, but until we get WeakMaps, this is the least troublesome
// way to do this (we can't just hold onto node ids because they may
// not be in the same document).
if (isTransaction) {
index = Y.Array.indexOf(purgeNodes, node);
if (index > -1) {
purgeNodes.splice(index, 1);
}
}
}
},
};
/**
Alias for `js()`.
@method script
@static
**/
Get.script = Get.js;
/**
Represents a Get transaction, which may contain requests for one or more JS or
CSS files.
This class should not be instantiated manually. Instances will be created and
returned as needed by Y.Get's `css()`, `js()`, and `load()` methods.
@class Get.Transaction
@constructor
@since 3.5.0
**/
Get.Transaction = Transaction = function (requests, options) {
var self = this;
self.id = Transaction._lastId += 1;
self.data = options.data;
self.errors = [];
self.nodes = [];
self.options = options;
self.requests = requests;
self._callbacks = []; // callbacks to call after execution finishes
self._queue = [];
self._reqsWaiting = 0;
// Deprecated pre-3.5.0 properties.
self.tId = self.id; // Use `id` instead.
self.win = options.win || Y.config.win;
};
/**
Arbitrary data object associated with this transaction.
This object comes from the options passed to `Get.css()`, `Get.js()`, or
`Get.load()`, and will be `undefined` if no data object was specified.
@property {Object} data
**/
/**
Array of errors that have occurred during this transaction, if any.
@since 3.5.0
@property {Object[]} errors
@property {String} errors.error Error message.
@property {Object} errors.request Request object related to the error.
**/
/**
Numeric id for this transaction, unique among all transactions within the same
YUI sandbox in the current pageview.
@property {Number} id
@since 3.5.0
**/
/**
HTMLElement nodes (native ones, not YUI Node instances) that have been inserted
during the current transaction.
@property {HTMLElement[]} nodes
**/
/**
Options associated with this transaction.
See `Get.options` for the full list of available options.
@property {Object} options
@since 3.5.0
**/
/**
Request objects contained in this transaction. Each request object represents
one CSS or JS URL that will be (or has been) requested and loaded into the page.
@property {Object} requests
@since 3.5.0
**/
/**
Id of the most recent transaction.
@property _lastId
@type Number
@protected
@static
**/
Transaction._lastId = 0;
Transaction.prototype = {
// -- Public Properties ----------------------------------------------------
/**
Current state of this transaction. One of "new", "executing", or "done".
@property _state
@type String
@protected
**/
_state: "new", // "new", "executing", or "done"
// -- Public Methods -------------------------------------------------------
/**
Aborts this transaction.
This will cause the transaction's `onFailure` callback to be called and
will prevent any new script and link nodes from being added to the document,
but any resources that have already been requested will continue loading
(there's no safe way to prevent this, unfortunately).
@method abort
@param {String} [msg="Aborted."] Optional message to use in the `errors`
array describing why the transaction was aborted.
**/
abort: function (msg) {
this._pending = null;
this._pendingCSS = null;
this._pollTimer = clearTimeout(this._pollTimer);
this._queue = [];
this._reqsWaiting = 0;
this.errors.push({ error: msg || "Aborted" });
this._finish();
},
/**
Begins execting the transaction.
There's usually no reason to call this manually, since Get will call it
automatically when other pending transactions have finished. If you really
want to execute your transaction before Get does, you can, but be aware that
this transaction's scripts may end up executing before the scripts in other
pending transactions.
If the transaction is already executing, the specified callback (if any)
will be queued and called after execution finishes. If the transaction has
already finished, the callback will be called immediately (the transaction
will not be executed again).
@method execute
@param {Function} callback Callback function to execute after all requests
in the transaction are complete, or after the transaction is aborted.
**/
execute: function (callback) {
var self = this,
requests = self.requests,
state = self._state,
i,
len,
queue,
req;
if (state === "done") {
callback && callback(self.errors.length ? self.errors : null, self);
return;
} else {
callback && self._callbacks.push(callback);
if (state === "executing") {
return;
}
}
self._state = "executing";
self._queue = queue = [];
if (self.options.timeout) {
self._timeout = setTimeout(function () {
self.abort("Timeout");
}, self.options.timeout);
}
self._reqsWaiting = requests.length;
for (i = 0, len = requests.length; i < len; ++i) {
req = requests[i];
if (req.async || req.type === "css") {
// No need to queue CSS or fully async JS.
self._insert(req);
} else {
queue.push(req);
}
}
self._next();
},
/**
Manually purges any `<script>` or `<link>` nodes this transaction has
created.
Be careful when purging a transaction that contains CSS requests, since
removing `<link>` nodes will also remove any styles they applied.
@method purge
**/
purge: function () {
Get._purge(this.nodes);
},
// -- Protected Methods ----------------------------------------------------
_createNode: function (name, attrs, doc) {
var node = doc.createElement(name),
attr,
testEl;
if (!CUSTOM_ATTRS) {
// IE6 and IE7 expect property names rather than attribute names for
// certain attributes. Rather than sniffing, we do a quick feature
// test the first time _createNode() runs to determine whether we
// need to provide a workaround.
testEl = doc.createElement("div");
testEl.setAttribute("class", "a");
CUSTOM_ATTRS =
testEl.className === "a"
? {}
: {
for: "htmlFor",
class: "className",
};
}
for (attr in attrs) {
if (attrs.hasOwnProperty(attr)) {
node.setAttribute(CUSTOM_ATTRS[attr] || attr, attrs[attr]);
}
}
return node;
},
_finish: function () {
var errors = this.errors.length ? this.errors : null,
options = this.options,
thisObj = options.context || this,
data,
i,
len;
if (this._state === "done") {
return;
}
this._state = "done";
for (i = 0, len = this._callbacks.length; i < len; ++i) {
this._callbacks[i].call(thisObj, errors, this);
}
data = this._getEventData();
if (errors) {
if (
options.onTimeout &&
errors[errors.length - 1].error === "Timeout"
) {
options.onTimeout.call(thisObj, data);
}
if (options.onFailure) {
options.onFailure.call(thisObj, data);
}
} else if (options.onSuccess) {
options.onSuccess.call(thisObj, data);
}
if (options.onEnd) {
options.onEnd.call(thisObj, data);
}
if (options._onFinish) {
options._onFinish();
}
},
_getEventData: function (req) {
if (req) {
// This merge is necessary for backcompat. I hate it.
return Y.merge(this, {
abort: this.abort, // have to copy these because the prototype isn't preserved
purge: this.purge,
request: req,
url: req.url,
win: req.win,
});
} else {
return this;
}
},
_getInsertBefore: function (req) {
var doc = req.doc,
el = req.insertBefore,
cache,
docStamp;
if (el) {
return typeof el === "string" ? doc.getElementById(el) : el;
}
cache = Get._insertCache;
docStamp = Y.stamp(doc);
if ((el = cache[docStamp])) {
// assignment
return el;
}
// Inserting before a <base> tag apparently works around an IE bug
// (according to a comment from pre-3.5.0 Y.Get), but I'm not sure what
// bug that is, exactly. Better safe than sorry?
if ((el = doc.getElementsByTagName("base")[0])) {
// assignment
return (cache[docStamp] = el);
}
// Look for a <head> element.
el = doc.head || doc.getElementsByTagName("head")[0];
if (el) {
// Create a marker node at the end of <head> to use as an insertion
// point. Inserting before this node will ensure that all our CSS
// gets inserted in the correct order, to maintain style precedence.
el.appendChild(doc.createTextNode(""));
return (cache[docStamp] = el.lastChild);
}
// If all else fails, just insert before the first script node on the
// page, which is virtually guaranteed to exist.
return (cache[docStamp] = doc.getElementsByTagName("script")[0]);
},
_insert: function (req) {
var env = Get._env,
insertBefore = this._getInsertBefore(req),
isScript = req.type === "js",
node = req.node,
self = this,
ua = Y.UA,
cssTimeout,
nodeType;
if (!node) {
if (isScript) {
nodeType = "script";
} else if (!env.cssLoad && ua.gecko) {
nodeType = "style";
} else {
nodeType = "link";
}
node = req.node = this._createNode(nodeType, req.attributes, req.doc);
}
function onError() {
self._progress("Failed to load " + req.url, req);
}
function onLoad() {
if (cssTimeout) {
clearTimeout(cssTimeout);
}
self._progress(null, req);
}
// Deal with script asynchronicity.
if (isScript) {
node.setAttribute("src", req.url);
if (req.async) {
// Explicitly indicate that we want the browser to execute this
// script asynchronously. This is necessary for older browsers
// like Firefox <4.
node.async = true;
} else {
if (env.async) {
// This browser treats injected scripts as async by default
// (standard HTML5 behavior) but asynchronous loading isn't
// desired, so tell the browser not to mark this script as
// async.
node.async = false;
}
// If this browser doesn't preserve script execution order based
// on insertion order, we'll need to avoid inserting other
// scripts until this one finishes loading.
if (!env.preservesScriptOrder) {
this._pending = req;
}
}
} else {
if (!env.cssLoad && ua.gecko) {
// In Firefox <9, we can import the requested URL into a <style>
// node and poll for the existence of node.sheet.cssRules. This
// gives us a reliable way to determine CSS load completion that
// also works for cross-domain stylesheets.
//
// Props to Zach Leatherman for calling my attention to this
// technique.
node.innerHTML =
(req.attributes.charset
? '@charset "' + req.attributes.charset + '";'
: "") +
'@import "' +
req.url +
'";';
} else {
node.setAttribute("href", req.url);
}
}
// Inject the node.
if (
isScript &&
ua.ie &&
(ua.ie < 9 || (document.documentMode && document.documentMode < 9))
) {
// Script on IE < 9, and IE 9+ when in IE 8 or older modes, including quirks mode.
node.onreadystatechange = function () {
if (/loaded|complete/.test(node.readyState)) {
node.onreadystatechange = null;
onLoad();
}
};
} else if (!isScript && !env.cssLoad) {
// CSS on Firefox <9 or WebKit.
this._poll(req);
} else {
// Script or CSS on everything else. Using DOM 0 events because that
// evens the playing field with older IEs.
if (ua.ie >= 10) {
// We currently need to introduce a timeout for IE10, since it
// calls onerror/onload synchronously for 304s - messing up existing
// program flow.
// Remove this block if the following bug gets fixed by GA
/*jshint maxlen: 1500 */
// https://connect.microsoft.com/IE/feedback/details/763871/dynamically-loaded-scripts-with-304s-responses-interrupt-the-currently-executing-js-thread-onload
node.onerror = function () {
setTimeout(onError, 0);
};
node.onload = function () {
setTimeout(onLoad, 0);
};
} else {
node.onerror = onError;
node.onload = onLoad;
}
// If this browser doesn't fire an event when CSS fails to load,
// fail after a timeout to avoid blocking the transaction queue.
if (!env.cssFail && !isScript) {
cssTimeout = setTimeout(onError, req.timeout || 3000);
}
}
this.nodes.push(node);
insertBefore.parentNode.insertBefore(node, insertBefore);
},
_next: function () {
if (this._pending) {
return;
}
// If there are requests in the queue, insert the next queued request.
// Otherwise, if we're waiting on already-inserted requests to finish,
// wait longer. If there are no queued requests and we're not waiting
// for anything to load, then we're done!
if (this._queue.length) {
this._insert(this._queue.shift());
} else if (!this._reqsWaiting) {
this._finish();
}
},
_poll: function (newReq) {
var self = this,
pendingCSS = self._pendingCSS,
isWebKit = Y.UA.webkit,
i,
hasRules,
j,
nodeHref,
req,
sheets;
if (newReq) {
pendingCSS || (pendingCSS = self._pendingCSS = []);
pendingCSS.push(newReq);
if (self._pollTimer) {
// A poll timeout is already pending, so no need to create a
// new one.
return;
}
}
self._pollTimer = null;
// Note: in both the WebKit and Gecko hacks below, a CSS URL that 404s
// will still be treated as a success. There's no good workaround for
// this.
for (i = 0; i < pendingCSS.length; ++i) {
req = pendingCSS[i];
if (isWebKit) {
// Look for a stylesheet matching the pending URL.
sheets = req.doc.styleSheets;
j = sheets.length;
nodeHref = req.node.href;
while (--j >= 0) {
if (sheets[j].href === nodeHref) {
pendingCSS.splice(i, 1);
i -= 1;
self._progress(null, req);
break;
}
}
} else {
// Many thanks to Zach Leatherman for calling my attention to
// the @import-based cross-domain technique used here, and to
// Oleg Slobodskoi for an earlier same-domain implementation.
//
// See Zach's blog for more details:
// http://www.zachleat.com/web/2010/07/29/load-css-dynamically/
try {
// We don't really need to store this value since we never
// use it again, but if we don't store it, Closure Compiler
// assumes the code is useless and removes it.
hasRules = !!req.node.sheet.cssRules;
// If we get here, the stylesheet has loaded.
pendingCSS.splice(i, 1);
i -= 1;
self._progress(null, req);
} catch (ex) {
// An exception means the stylesheet is still loading.
}
}
}
if (pendingCSS.length) {
self._pollTimer = setTimeout(function () {
self._poll.call(self);
}, self.options.pollInterval);
}
},
_progress: function (err, req) {
var options = this.options;
if (err) {
req.error = err;
this.errors.push({
error: err,
request: req,
});
}
req.node._yuiget_finished = req.finished = true;
if (options.onProgress) {
options.onProgress.call(
options.context || this,
this._getEventData(req),
);
}
if (req.autopurge) {
// Pre-3.5.0 Get always excludes the most recent node from an
// autopurge. I find this odd, but I'm keeping that behavior for
// the sake of backcompat.
Get._autoPurge(this.options.purgethreshold);
Get._purgeNodes.push(req.node);
}
if (this._pending === req) {
this._pending = null;
}
this._reqsWaiting -= 1;
this._next();
},
};
},
"3.12.0",
{ requires: ["yui-base"] },
);
YUI.add(
"features",
function (Y, NAME) {
var feature_tests = {};
/**
Contains the core of YUI's feature test architecture.
@module features
*/
/**
* Feature detection
* @class Features
* @static
*/
Y.mix(Y.namespace("Features"), {
/**
* Object hash of all registered feature tests
* @property tests
* @type Object
*/
tests: feature_tests,
/**
* Add a test to the system
*
* ```
* Y.Features.add("load", "1", {});
* ```
*
* @method add
* @param {String} cat The category, right now only 'load' is supported
* @param {String} name The number sequence of the test, how it's reported in the URL or config: 1, 2, 3
* @param {Object} o Object containing test properties
* @param {String} o.name The name of the test
* @param {Function} o.test The test function to execute, the only argument to the function is the `Y` instance
* @param {String} o.trigger The module that triggers this test.
*/
add: function (cat, name, o) {
feature_tests[cat] = feature_tests[cat] || {};
feature_tests[cat][name] = o;
},
/**
* Execute all tests of a given category and return the serialized results
*
* ```
* caps=1:1;2:1;3:0
* ```
* @method all
* @param {String} cat The category to execute
* @param {Array} args The arguments to pass to the test function
* @return {String} A semi-colon separated string of tests and their success/failure: 1:1;2:1;3:0
*/
all: function (cat, args) {
var cat_o = feature_tests[cat],
// results = {};
result = [];
if (cat_o) {
Y.Object.each(cat_o, function (v, k) {
result.push(k + ":" + (Y.Features.test(cat, k, args) ? 1 : 0));
});
}
return result.length ? result.join(";") : "";
},
/**
* Run a sepecific test and return a Boolean response.
*
* ```
* Y.Features.test("load", "1");
* ```
*
* @method test
* @param {String} cat The category of the test to run
* @param {String} name The name of the test to run
* @param {Array} args The arguments to pass to the test function
* @return {Boolean} True or false if the test passed/failed.
*/
test: function (cat, name, args) {
args = args || [];
var result,
ua,
test,
cat_o = feature_tests[cat],
feature = cat_o && cat_o[name];
if (!feature) {
} else {
result = feature.result;
if (Y.Lang.isUndefined(result)) {
ua = feature.ua;
if (ua) {
result = Y.UA[ua];
}
test = feature.test;
if (test && (!ua || result)) {
result = test.apply(Y, args);
}
feature.result = result;
}
}
return result;
},
});
// Y.Features.add("load", "1", {});
// Y.Features.test("load", "1");
// caps=1:1;2:0;3:1;
/* This file is auto-generated by (yogi.js loader --mix --yes) */
/*jshint maxlen:900, eqeqeq: false */
var add = Y.Features.add;
// app-transitions-native
add("load", "0", {
name: "app-transitions-native",
test: function (Y) {
var doc = Y.config.doc,
node = doc ? doc.documentElement : null;
if (node && node.style) {
return (
"MozTransition" in node.style ||
"WebkitTransition" in node.style ||
"transition" in node.style
);
}
return false;
},
trigger: "app-transitions",
});
// autocomplete-list-keys
add("load", "1", {
name: "autocomplete-list-keys",
test: function (Y) {
// Only add keyboard support to autocomplete-list if this doesn't appear to
// be an iOS or Android-based mobile device.
//
// There's currently no feasible way to actually detect whether a device has
// a hardware keyboard, so this sniff will have to do. It can easily be
// overridden by manually loading the autocomplete-list-keys module.
//
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
// doesn't fire the keyboard events used by AutoCompleteList, so there's
// no point loading the -keys module even when a bluetooth keyboard may be
// available.
return !(Y.UA.ios || Y.UA.android);
},
trigger: "autocomplete-list",
});
// dd-gestures
add("load", "2", {
name: "dd-gestures",
trigger: "dd-drag",
ua: "touchEnabled",
});
// dom-style-ie
add("load", "3", {
name: "dom-style-ie",
test: function (Y) {
var testFeature = Y.Features.test,
addFeature = Y.Features.add,
WINDOW = Y.config.win,
DOCUMENT = Y.config.doc,
DOCUMENT_ELEMENT = "documentElement",
ret = false;
addFeature("style", "computedStyle", {
test: function () {
return WINDOW && "getComputedStyle" in WINDOW;
},
});
addFeature("style", "opacity", {
test: function () {
return DOCUMENT && "opacity" in DOCUMENT[DOCUMENT_ELEMENT].style;
},
});
ret =
!testFeature("style", "opacity") &&
!testFeature("style", "computedStyle");
return ret;
},
trigger: "dom-style",
});
// editor-para-ie
add("load", "4", {
name: "editor-para-ie",
trigger: "editor-para",
ua: "ie",
when: "instead",
});
// event-base-ie
add("load", "5", {
name: "event-base-ie",
test: function (Y) {
var imp = Y.config.doc && Y.config.doc.implementation;
return imp && !imp.hasFeature("Events", "2.0");
},
trigger: "node-base",
});
// graphics-canvas
add("load", "6", {
name: "graphics-canvas",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useCanvas =
Y.config.defaultGraphicEngine &&
Y.config.defaultGraphicEngine == "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return (
(!svg || useCanvas) &&
canvas &&
canvas.getContext &&
canvas.getContext("2d")
);
},
trigger: "graphics",
});
// graphics-canvas-default
add("load", "7", {
name: "graphics-canvas-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useCanvas =
Y.config.defaultGraphicEngine &&
Y.config.defaultGraphicEngine == "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return (
(!svg || useCanvas) &&
canvas &&
canvas.getContext &&
canvas.getContext("2d")
);
},
trigger: "graphics",
});
// graphics-svg
add("load", "8", {
name: "graphics-svg",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useSVG =
!Y.config.defaultGraphicEngine ||
Y.config.defaultGraphicEngine != "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return svg && (useSVG || !canvas);
},
trigger: "graphics",
});
// graphics-svg-default
add("load", "9", {
name: "graphics-svg-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useSVG =
!Y.config.defaultGraphicEngine ||
Y.config.defaultGraphicEngine != "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return svg && (useSVG || !canvas);
},
trigger: "graphics",
});
// graphics-vml
add("load", "10", {
name: "graphics-vml",
test: function (Y) {
var DOCUMENT = Y.config.doc,
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (
DOCUMENT &&
!DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
) &&
(!canvas || !canvas.getContext || !canvas.getContext("2d"))
);
},
trigger: "graphics",
});
// graphics-vml-default
add("load", "11", {
name: "graphics-vml-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (
DOCUMENT &&
!DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
) &&
(!canvas || !canvas.getContext || !canvas.getContext("2d"))
);
},
trigger: "graphics",
});
// history-hash-ie
add("load", "12", {
name: "history-hash-ie",
test: function (Y) {
var docMode = Y.config.doc && Y.config.doc.documentMode;
return (
Y.UA.ie &&
(!("onhashchange" in Y.config.win) || !docMode || docMode < 8)
);
},
trigger: "history-hash",
});
// io-nodejs
add("load", "13", {
name: "io-nodejs",
trigger: "io-base",
ua: "nodejs",
});
// json-parse-shim
add("load", "14", {
name: "json-parse-shim",
test: function (Y) {
var _JSON = Y.config.global.JSON,
Native =
Object.prototype.toString.call(_JSON) === "[object JSON]" && _JSON,
nativeSupport = Y.config.useNativeJSONParse !== false && !!Native;
function workingNative(k, v) {
return k === "ok" ? true : v;
}
// Double check basic functionality. This is mainly to catch early broken
// implementations of the JSON API in Firefox 3.1 beta1 and beta2
if (nativeSupport) {
try {
nativeSupport = Native.parse('{"ok":false}', workingNative).ok;
} catch (e) {
nativeSupport = false;
}
}
return !nativeSupport;
},
trigger: "json-parse",
});
// json-stringify-shim
add("load", "15", {
name: "json-stringify-shim",
test: function (Y) {
var _JSON = Y.config.global.JSON,
Native =
Object.prototype.toString.call(_JSON) === "[object JSON]" && _JSON,
nativeSupport = Y.config.useNativeJSONStringify !== false && !!Native;
// Double check basic native functionality. This is primarily to catch broken
// early JSON API implementations in Firefox 3.1 beta1 and beta2.
if (nativeSupport) {
try {
nativeSupport = "0" === Native.stringify(0);
} catch (e) {
nativeSupport = false;
}
}
return !nativeSupport;
},
trigger: "json-stringify",
});
// scrollview-base-ie
add("load", "16", {
name: "scrollview-base-ie",
trigger: "scrollview-base",
ua: "ie",
});
// selector-css2
add("load", "17", {
name: "selector-css2",
test: function (Y) {
var DOCUMENT = Y.config.doc,
ret = DOCUMENT && !("querySelectorAll" in DOCUMENT);
return ret;
},
trigger: "selector",
});
// transition-timer
add("load", "18", {
name: "transition-timer",
test: function (Y) {
var DOCUMENT = Y.config.doc,
node = DOCUMENT ? DOCUMENT.documentElement : null,
ret = true;
if (node && node.style) {
ret = !(
"MozTransition" in node.style ||
"WebkitTransition" in node.style ||
"transition" in node.style
);
}
return ret;
},
trigger: "transition",
});
// widget-base-ie
add("load", "19", {
name: "widget-base-ie",
trigger: "widget-base",
ua: "ie",
});
// yql-jsonp
add("load", "20", {
name: "yql-jsonp",
test: function (Y) {
/* Only load the JSONP module when not in nodejs or winjs
TODO Make the winjs module a CORS module
*/
return !Y.UA.nodejs && !Y.UA.winjs;
},
trigger: "yql",
when: "after",
});
// yql-nodejs
add("load", "21", {
name: "yql-nodejs",
trigger: "yql",
ua: "nodejs",
when: "after",
});
// yql-winjs
add("load", "22", {
name: "yql-winjs",
trigger: "yql",
ua: "winjs",
when: "after",
});
},
"3.12.0",
{ requires: ["yui-base"] },
);
YUI.add(
"intl-base",
function (Y, NAME) {
/**
* The Intl utility provides a central location for managing sets of
* localized resources (strings and formatting patterns).
*
* @class Intl
* @uses EventTarget
* @static
*/
var SPLIT_REGEX = /[, ]/;
Y.mix(Y.namespace("Intl"), {
/**
* Returns the language among those available that
* best matches the preferred language list, using the Lookup
* algorithm of BCP 47.
* If none of the available languages meets the user's preferences,
* then "" is returned.
* Extended language ranges are not supported.
*
* @method lookupBestLang
* @param {String[] | String} preferredLanguages The list of preferred
* languages in descending preference order, represented as BCP 47
* language tags. A string array or a comma-separated list.
* @param {String[]} availableLanguages The list of languages
* that the application supports, represented as BCP 47 language
* tags.
*
* @return {String} The available language that best matches the
* preferred language list, or "".
* @since 3.1.0
*/
lookupBestLang: function (preferredLanguages, availableLanguages) {
var i, language, result, index;
// check whether the list of available languages contains language;
// if so return it
function scan(language) {
var i;
for (i = 0; i < availableLanguages.length; i += 1) {
if (
language.toLowerCase() === availableLanguages[i].toLowerCase()
) {
return availableLanguages[i];
}
}
}
if (Y.Lang.isString(preferredLanguages)) {
preferredLanguages = preferredLanguages.split(SPLIT_REGEX);
}
for (i = 0; i < preferredLanguages.length; i += 1) {
language = preferredLanguages[i];
if (!language || language === "*") {
continue;
}
// check the fallback sequence for one language
while (language.length > 0) {
result = scan(language);
if (result) {
return result;
} else {
index = language.lastIndexOf("-");
if (index >= 0) {
language = language.substring(0, index);
// one-character subtags get cut along with the
// following subtag
if (index >= 2 && language.charAt(index - 2) === "-") {
language = language.substring(0, index - 2);
}
} else {
// nothing available for this language
break;
}
}
}
}
return "";
},
});
},
"3.12.0",
{ requires: ["yui-base"] },
);
YUI.add(
"yui-log",
function (Y, NAME) {
/**
* Provides console log capability and exposes a custom event for
* console implementations. This module is a `core` YUI module,
* <a href="../classes/YUI.html#method_log">it's documentation is located under the YUI class</a>.
*
* @module yui
* @submodule yui-log
*/
var INSTANCE = Y,
LOGEVENT = "yui:log",
UNDEFINED = "undefined",
LEVELS = { debug: 1, info: 2, warn: 4, error: 8 };
/**
* If the 'debug' config is true, a 'yui:log' event will be
* dispatched, which the Console widget and anything else
* can consume. If the 'useBrowserConsole' config is true, it will
* write to the browser console if available. YUI-specific log
* messages will only be present in the -debug versions of the
* JS files. The build system is supposed to remove log statements
* from the raw and minified versions of the files.
*
* @method log
* @for YUI
* @param {String} msg The message to log.
* @param {String} cat The log category for the message. Default
* categories are "info", "warn", "error", time".
* Custom categories can be used as well. (opt).
* @param {String} src The source of the the message (opt).
* @param {boolean} silent If true, the log event won't fire.
* @return {YUI} YUI instance.
*/
INSTANCE.log = function (msg, cat, src, silent) {
var bail,
excl,
incl,
m,
f,
minlevel,
Y = INSTANCE,
c = Y.config,
publisher = Y.fire ? Y : YUI.Env.globalEvents;
// suppress log message if the config is off or the event stack
// or the event call stack contains a consumer of the yui:log event
if (c.debug) {
// apply source filters
src = src || "";
if (typeof src !== "undefined") {
excl = c.logExclude;
incl = c.logInclude;
if (incl && !(src in incl)) {
bail = 1;
} else if (incl && src in incl) {
bail = !incl[src];
} else if (excl && src in excl) {
bail = excl[src];
}
// Determine the current minlevel as defined in configuration
Y.config.logLevel = Y.config.logLevel || "debug";
minlevel = LEVELS[Y.config.logLevel.toLowerCase()];
if (cat in LEVELS && LEVELS[cat] < minlevel) {
// Skip this message if the we don't meet the defined minlevel
bail = 1;
}
}
if (!bail) {
if (c.useBrowserConsole) {
m = src ? src + ": " + msg : msg;
if (Y.Lang.isFunction(c.logFn)) {
c.logFn.call(Y, msg, cat, src);
} else if (typeof console !== UNDEFINED && console.log) {
f = cat && console[cat] && cat in LEVELS ? cat : "log";
console[f](m);
} else if (typeof opera !== UNDEFINED) {
opera.postError(m);
}
}
if (publisher && !silent) {
if (publisher === Y && !publisher.getEvent(LOGEVENT)) {
publisher.publish(LOGEVENT, {
broadcast: 2,
});
}
publisher.fire(LOGEVENT, {
msg: msg,
cat: cat,
src: src,
});
}
}
}
return Y;
};
/**
* Write a system message. This message will be preserved in the
* minified and raw versions of the YUI files, unlike log statements.
* @method message
* @for YUI
* @param {String} msg The message to log.
* @param {String} cat The log category for the message. Default
* categories are "info", "warn", "error", time".
* Custom categories can be used as well. (opt).
* @param {String} src The source of the the message (opt).
* @param {boolean} silent If true, the log event won't fire.
* @return {YUI} YUI instance.
*/
INSTANCE.message = function () {
return INSTANCE.log.apply(INSTANCE, arguments);
};
},
"3.12.0",
{ requires: ["yui-base"] },
);
YUI.add(
"yui-later",
function (Y, NAME) {
/**
* Provides a setTimeout/setInterval wrapper. This module is a `core` YUI module,
* <a href="../classes/YUI.html#method_later">it's documentation is located under the YUI class</a>.
*
* @module yui
* @submodule yui-later
*/
var NO_ARGS = [];
/**
* Executes the supplied function in the context of the supplied
* object 'when' milliseconds later. Executes the function a
* single time unless periodic is set to true.
* @for YUI
* @method later
* @param when {int} the number of milliseconds to wait until the fn
* is executed.
* @param o the context object.
* @param fn {Function|String} the function to execute or the name of
* the method in the 'o' object to execute.
* @param data [Array] data that is provided to the function. This
* accepts either a single item or an array. If an array is provided,
* the function is executed with one parameter for each array item.
* If you need to pass a single array parameter, it needs to be wrapped
* in an array [myarray].
*
* Note: native methods in IE may not have the call and apply methods.
* In this case, it will work, but you are limited to four arguments.
*
* @param periodic {boolean} if true, executes continuously at supplied
* interval until canceled.
* @return {object} a timer object. Call the cancel() method on this
* object to stop the timer.
*/
Y.later = function (when, o, fn, data, periodic) {
when = when || 0;
data = !Y.Lang.isUndefined(data) ? Y.Array(data) : NO_ARGS;
o = o || Y.config.win || Y;
var cancelled = false,
method = o && Y.Lang.isString(fn) ? o[fn] : fn,
wrapper = function () {
// IE 8- may execute a setInterval callback one last time
// after clearInterval was called, so in order to preserve
// the cancel() === no more runny-run, we have to jump through
// an extra hoop.
if (!cancelled) {
if (!method.apply) {
method(data[0], data[1], data[2], data[3]);
} else {
method.apply(o, data || NO_ARGS);
}
}
},
id = periodic ? setInterval(wrapper, when) : setTimeout(wrapper, when);
return {
id: id,
interval: periodic,
cancel: function () {
cancelled = true;
if (this.interval) {
clearInterval(id);
} else {
clearTimeout(id);
}
},
};
};
Y.Lang.later = Y.later;
},
"3.12.0",
{ requires: ["yui-base"] },
);
YUI.add(
"loader-base",
function (Y, NAME) {
/**
* The YUI loader core
* @module loader
* @submodule loader-base
*/
(function () {
var VERSION = Y.version,
BUILD = "/build/",
ROOT = VERSION + "/",
CDN_BASE = Y.Env.base,
GALLERY_VERSION = "gallery-2013.08.22-21-03",
TNT = "2in3",
TNT_VERSION = "4",
YUI2_VERSION = "2.9.0",
COMBO_BASE = CDN_BASE + "combo?",
META = {
version: VERSION,
root: ROOT,
base: Y.Env.base,
comboBase: COMBO_BASE,
skin: {
defaultSkin: "sam",
base: "assets/skins/",
path: "skin.css",
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssbase",
"cssreset-context",
"cssfonts-context",
],
},
groups: {},
patterns: {},
},
groups = META.groups,
yui2Update = function (tnt, yui2, config) {
var root =
TNT +
"." +
(tnt || TNT_VERSION) +
"/" +
(yui2 || YUI2_VERSION) +
BUILD,
base = config && config.base ? config.base : CDN_BASE,
combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
groups.yui2.base = base + root;
groups.yui2.root = root;
groups.yui2.comboBase = combo;
},
galleryUpdate = function (tag, config) {
var root = (tag || GALLERY_VERSION) + BUILD,
base = config && config.base ? config.base : CDN_BASE,
combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
groups.gallery.base = base + root;
groups.gallery.root = root;
groups.gallery.comboBase = combo;
};
groups[VERSION] = {};
groups.gallery = {
ext: false,
combine: true,
comboBase: COMBO_BASE,
update: galleryUpdate,
patterns: {
"gallery-": {},
"lang/gallery-": {},
"gallerycss-": {
type: "css",
},
},
};
groups.yui2 = {
combine: true,
ext: false,
comboBase: COMBO_BASE,
update: yui2Update,
patterns: {
"yui2-": {
configFn: function (me) {
if (/-skin|reset|fonts|grids|base/.test(me.name)) {
me.type = "css";
me.path = me.path.replace(/\.js/, ".css");
// this makes skins in builds earlier than
// 2.6.0 work as long as combine is false
me.path = me.path.replace(
/\/yui2-skin/,
"/assets/skins/sam/yui2-skin",
);
}
},
},
},
};
galleryUpdate();
yui2Update();
if (YUI.Env[VERSION]) {
Y.mix(
META,
YUI.Env[VERSION],
false,
["modules", "groups", "skin"],
0,
true,
);
}
YUI.Env[VERSION] = META;
})();
/*jslint forin: true, maxlen: 350 */
/**
* Loader dynamically loads script and css files. It includes the dependency
* information for the version of the library in use, and will automatically pull in
* dependencies for the modules requested. It can also load the
* files from the Yahoo! CDN, and it can utilize the combo service provided on
* this network to reduce the number of http connections required to download
* YUI files.
*
* @module loader
* @main loader
* @submodule loader-base
*/
var NOT_FOUND = {},
NO_REQUIREMENTS = [],
MAX_URL_LENGTH = 1024,
GLOBAL_ENV = YUI.Env,
GLOBAL_LOADED = GLOBAL_ENV._loaded,
CSS = "css",
JS = "js",
INTL = "intl",
DEFAULT_SKIN = "sam",
VERSION = Y.version,
ROOT_LANG = "",
YObject = Y.Object,
oeach = YObject.each,
yArray = Y.Array,
_queue = GLOBAL_ENV._loaderQueue,
META = GLOBAL_ENV[VERSION],
SKIN_PREFIX = "skin-",
L = Y.Lang,
ON_PAGE = GLOBAL_ENV.mods,
modulekey,
_path = function (dir, file, type, nomin) {
var path = dir + "/" + file;
if (!nomin) {
path += "-min";
}
path += "." + (type || CSS);
return path;
};
if (!YUI.Env._cssLoaded) {
YUI.Env._cssLoaded = {};
}
/**
* The component metadata is stored in Y.Env.meta.
* Part of the loader module.
* @property meta
* @for YUI
*/
Y.Env.meta = META;
/**
* Loader dynamically loads script and css files. It includes the dependency
* info for the version of the library in use, and will automatically pull in
* dependencies for the modules requested. It can load the
* files from the Yahoo! CDN, and it can utilize the combo service provided on
* this network to reduce the number of http connections required to download
* YUI files. You can also specify an external, custom combo service to host
* your modules as well.
var Y = YUI();
var loader = new Y.Loader({
filter: 'debug',
base: '../../',
root: 'build/',
combine: true,
require: ['node', 'dd', 'console']
});
var out = loader.resolve(true);
* @constructor
* @class Loader
* @param {Object} config an optional set of configuration options.
* @param {String} config.base The base dir which to fetch this module from
* @param {String} config.comboBase The Combo service base path. Ex: `http://yui.yahooapis.com/combo?`
* @param {String} config.root The root path to prepend to module names for the combo service. Ex: `2.5.2/build/`
* @param {String|Object} config.filter A filter to apply to result urls. <a href="#property_filter">See filter property</a>
* @param {Object} config.filters Per-component filter specification. If specified for a given component, this overrides the filter config.
* @param {Boolean} config.combine Use a combo service to reduce the number of http connections required to load your dependencies
* @param {Boolean} [config.async=true] Fetch files in async
* @param {Array} config.ignore: A list of modules that should never be dynamically loaded
* @param {Array} config.force A list of modules that should always be loaded when required, even if already present on the page
* @param {HTMLElement|String} config.insertBefore Node or id for a node that should be used as the insertion point for new nodes
* @param {Object} config.jsAttributes Object literal containing attributes to add to script nodes
* @param {Object} config.cssAttributes Object literal containing attributes to add to link nodes
* @param {Number} config.timeout The number of milliseconds before a timeout occurs when dynamically loading nodes. If not set, there is no timeout
* @param {Object} config.context Execution context for all callbacks
* @param {Function} config.onSuccess Callback for the 'success' event
* @param {Function} config.onFailure Callback for the 'failure' event
* @param {Function} config.onCSS Callback for the 'CSSComplete' event. When loading YUI components with CSS the CSS is loaded first, then the script. This provides a moment you can tie into to improve the presentation of the page while the script is loading.
* @param {Function} config.onTimeout Callback for the 'timeout' event
* @param {Function} config.onProgress Callback executed each time a script or css file is loaded
* @param {Object} config.modules A list of module definitions. See <a href="#method_addModule">Loader.addModule</a> for the supported module metadata
* @param {Object} config.groups A list of group definitions. Each group can contain specific definitions for `base`, `comboBase`, `combine`, and accepts a list of `modules`.
* @param {String} config.2in3 The version of the YUI 2 in 3 wrapper to use. The intrinsic support for YUI 2 modules in YUI 3 relies on versions of the YUI 2 components inside YUI 3 module wrappers. These wrappers change over time to accomodate the issues that arise from running YUI 2 in a YUI 3 sandbox.
* @param {String} config.yui2 When using the 2in3 project, you can select the version of YUI 2 to use. Valid values are `2.2.2`, `2.3.1`, `2.4.1`, `2.5.2`, `2.6.0`, `2.7.0`, `2.8.0`, `2.8.1` and `2.9.0` [default] -- plus all versions of YUI 2 going forward.
*/
Y.Loader = function (o) {
var self = this;
//Catch no config passed.
o = o || {};
modulekey = META.md5;
/**
* Internal callback to handle multiple internal insert() calls
* so that css is inserted prior to js
* @property _internalCallback
* @private
*/
// self._internalCallback = null;
/**
* Callback that will be executed when the loader is finished
* with an insert
* @method onSuccess
* @type function
*/
// self.onSuccess = null;
/**
* Callback that will be executed if there is a failure
* @method onFailure
* @type function
*/
// self.onFailure = null;
/**
* Callback for the 'CSSComplete' event. When loading YUI components
* with CSS the CSS is loaded first, then the script. This provides
* a moment you can tie into to improve the presentation of the page
* while the script is loading.
* @method onCSS
* @type function
*/
// self.onCSS = null;
/**
* Callback executed each time a script or css file is loaded
* @method onProgress
* @type function
*/
// self.onProgress = null;
/**
* Callback that will be executed if a timeout occurs
* @method onTimeout
* @type function
*/
// self.onTimeout = null;
/**
* The execution context for all callbacks
* @property context
* @default {YUI} the YUI instance
*/
self.context = Y;
/**
* Data that is passed to all callbacks
* @property data
*/
// self.data = null;
/**
* Node reference or id where new nodes should be inserted before
* @property insertBefore
* @type string|HTMLElement
*/
// self.insertBefore = null;
/**
* The charset attribute for inserted nodes
* @property charset
* @type string
* @deprecated , use cssAttributes or jsAttributes.
*/
// self.charset = null;
/**
* An object literal containing attributes to add to link nodes
* @property cssAttributes
* @type object
*/
// self.cssAttributes = null;
/**
* An object literal containing attributes to add to script nodes
* @property jsAttributes
* @type object
*/
// self.jsAttributes = null;
/**
* The base directory.
* @property base
* @type string
* @default http://yui.yahooapis.com/[YUI VERSION]/build/
*/
self.base = Y.Env.meta.base + Y.Env.meta.root;
/**
* Base path for the combo service
* @property comboBase
* @type string
* @default http://yui.yahooapis.com/combo?
*/
self.comboBase = Y.Env.meta.comboBase;
/*
* Base path for language packs.
*/
// self.langBase = Y.Env.meta.langBase;
// self.lang = "";
/**
* If configured, the loader will attempt to use the combo
* service for YUI resources and configured external resources.
* @property combine
* @type boolean
* @default true if a base dir isn't in the config
*/
self.combine =
o.base && o.base.indexOf(self.comboBase.substr(0, 20)) > -1;
/**
* The default seperator to use between files in a combo URL
* @property comboSep
* @type {String}
* @default Ampersand
*/
self.comboSep = "&";
/**
* Max url length for combo urls. The default is 1024. This is the URL
* limit for the Yahoo! hosted combo servers. If consuming
* a different combo service that has a different URL limit
* it is possible to override this default by supplying
* the maxURLLength config option. The config option will
* only take effect if lower than the default.
*
* @property maxURLLength
* @type int
*/
self.maxURLLength = MAX_URL_LENGTH;
/**
* Ignore modules registered on the YUI global
* @property ignoreRegistered
* @default false
*/
self.ignoreRegistered = o.ignoreRegistered;
/**
* Root path to prepend to module path for the combo
* service
* @property root
* @type string
* @default [YUI VERSION]/build/
*/
self.root = Y.Env.meta.root;
/**
* Timeout value in milliseconds. If set, self value will be used by
* the get utility. the timeout event will fire if
* a timeout occurs.
* @property timeout
* @type int
*/
self.timeout = 0;
/**
* A list of modules that should not be loaded, even if
* they turn up in the dependency tree
* @property ignore
* @type string[]
*/
// self.ignore = null;
/**
* A list of modules that should always be loaded, even
* if they have already been inserted into the page.
* @property force
* @type string[]
*/
// self.force = null;
self.forceMap = {};
/**
* Should we allow rollups
* @property allowRollup
* @type boolean
* @default false
*/
self.allowRollup = false;
/**
* A filter to apply to result urls. This filter will modify the default
* path for all modules. The default path for the YUI library is the
* minified version of the files (e.g., event-min.js). The filter property
* can be a predefined filter or a custom filter. The valid predefined
* filters are:
* <dl>
* <dt>DEBUG</dt>
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
* This option will automatically include the Logger widget</dd>
* <dt>RAW</dt>
* <dd>Selects the non-minified version of the library (e.g., event.js).
* </dd>
* </dl>
* You can also define a custom filter, which must be an object literal
* containing a search expression and a replace string:
*
* myFilter: {
* 'searchExp': "-min\\.js",
* 'replaceStr': "-debug.js"
* }
*
* @property filter
* @type string| {searchExp: string, replaceStr: string}
*/
// self.filter = null;
/**
* per-component filter specification. If specified for a given
* component, this overrides the filter config.
* @property filters
* @type object
*/
self.filters = {};
/**
* The list of requested modules
* @property required
* @type {string: boolean}
*/
self.required = {};
/**
* If a module name is predefined when requested, it is checked againsts
* the patterns provided in this property. If there is a match, the
* module is added with the default configuration.
*
* At the moment only supporting module prefixes, but anticipate
* supporting at least regular expressions.
* @property patterns
* @type Object
*/
// self.patterns = Y.merge(Y.Env.meta.patterns);
self.patterns = {};
/**
* The library metadata
* @property moduleInfo
*/
// self.moduleInfo = Y.merge(Y.Env.meta.moduleInfo);
self.moduleInfo = {};
self.groups = Y.merge(Y.Env.meta.groups);
/**
* Provides the information used to skin the skinnable components.
* The following skin definition would result in 'skin1' and 'skin2'
* being loaded for calendar (if calendar was requested), and
* 'sam' for all other skinnable components:
*
* skin: {
* // The default skin, which is automatically applied if not
* // overriden by a component-specific skin definition.
* // Change this in to apply a different skin globally
* defaultSkin: 'sam',
*
* // This is combined with the loader base property to get
* // the default root directory for a skin. ex:
* // http://yui.yahooapis.com/2.3.0/build/assets/skins/sam/
* base: 'assets/skins/',
*
* // Any component-specific overrides can be specified here,
* // making it possible to load different skins for different
* // components. It is possible to load more than one skin
* // for a given component as well.
* overrides: {
* calendar: ['skin1', 'skin2']
* }
* }
* @property skin
* @type {Object}
*/
self.skin = Y.merge(Y.Env.meta.skin);
/*
* Map of conditional modules
* @since 3.2.0
*/
self.conditions = {};
// map of modules with a hash of modules that meet the requirement
// self.provides = {};
self.config = o;
self._internal = true;
self._populateCache();
/**
* Set when beginning to compute the dependency tree.
* Composed of what YUI reports to be loaded combined
* with what has been loaded by any instance on the page
* with the version number specified in the metadata.
* @property loaded
* @type {string: boolean}
*/
self.loaded = GLOBAL_LOADED[VERSION];
/**
* Should Loader fetch scripts in `async`, defaults to `true`
* @property async
*/
self.async = true;
self._inspectPage();
self._internal = false;
self._config(o);
self.forceMap = self.force ? Y.Array.hash(self.force) : {};
self.testresults = null;
if (Y.config.tests) {
self.testresults = Y.config.tests;
}
/**
* List of rollup files found in the library metadata
* @property rollups
*/
// self.rollups = null;
/**
* Whether or not to load optional dependencies for
* the requested modules
* @property loadOptional
* @type boolean
* @default false
*/
// self.loadOptional = false;
/**
* All of the derived dependencies in sorted order, which
* will be populated when either calculate() or insert()
* is called
* @property sorted
* @type string[]
*/
self.sorted = [];
/*
* A list of modules to attach to the YUI instance when complete.
* If not supplied, the sorted list of dependencies are applied.
* @property attaching
*/
// self.attaching = null;
/**
* Flag to indicate the dependency tree needs to be recomputed
* if insert is called again.
* @property dirty
* @type boolean
* @default true
*/
self.dirty = true;
/**
* List of modules inserted by the utility
* @property inserted
* @type {string: boolean}
*/
self.inserted = {};
/**
* List of skipped modules during insert() because the module
* was not defined
* @property skipped
*/
self.skipped = {};
// Y.on('yui:load', self.loadNext, self);
self.tested = {};
/*
* Cached sorted calculate results
* @property results
* @since 3.2.0
*/
//self.results = {};
if (self.ignoreRegistered) {
//Clear inpage already processed modules.
self._resetModules();
}
};
Y.Loader.prototype = {
/**
* Checks the cache for modules and conditions, if they do not exist
* process the default metadata and populate the local moduleInfo hash.
* @method _populateCache
* @private
*/
_populateCache: function () {
var self = this,
defaults = META.modules,
cache = GLOBAL_ENV._renderedMods,
i;
if (cache && !self.ignoreRegistered) {
for (i in cache) {
if (cache.hasOwnProperty(i)) {
self.moduleInfo[i] = Y.merge(cache[i]);
}
}
cache = GLOBAL_ENV._conditions;
for (i in cache) {
if (cache.hasOwnProperty(i)) {
self.conditions[i] = Y.merge(cache[i]);
}
}
} else {
for (i in defaults) {
if (defaults.hasOwnProperty(i)) {
self.addModule(defaults[i], i);
}
}
}
},
/**
* Reset modules in the module cache to a pre-processed state so additional
* computations with a different skin or language will work as expected.
* @method _resetModules
* @private
*/
_resetModules: function () {
var self = this,
i,
o,
mod,
name,
details;
for (i in self.moduleInfo) {
if (self.moduleInfo.hasOwnProperty(i)) {
mod = self.moduleInfo[i];
name = mod.name;
details = YUI.Env.mods[name] ? YUI.Env.mods[name].details : null;
if (details) {
self.moduleInfo[name]._reset = true;
self.moduleInfo[name].requires = details.requires || [];
self.moduleInfo[name].optional = details.optional || [];
self.moduleInfo[name].supersedes = details.supercedes || [];
}
if (mod.defaults) {
for (o in mod.defaults) {
if (mod.defaults.hasOwnProperty(o)) {
if (mod[o]) {
mod[o] = mod.defaults[o];
}
}
}
}
delete mod.langCache;
delete mod.skinCache;
if (mod.skinnable) {
self._addSkin(self.skin.defaultSkin, mod.name);
}
}
}
},
/**
Regex that matches a CSS URL. Used to guess the file type when it's not
specified.
@property REGEX_CSS
@type RegExp
@final
@protected
@since 3.5.0
**/
REGEX_CSS: /\.css(?:[?;].*)?$/i,
/**
* Default filters for raw and debug
* @property FILTER_DEFS
* @type Object
* @final
* @protected
*/
FILTER_DEFS: {
RAW: {
searchExp: "-min\\.js",
replaceStr: ".js",
},
DEBUG: {
searchExp: "-min\\.js",
replaceStr: "-debug.js",
},
COVERAGE: {
searchExp: "-min\\.js",
replaceStr: "-coverage.js",
},
},
/*
* Check the pages meta-data and cache the result.
* @method _inspectPage
* @private
*/
_inspectPage: function () {
var self = this,
v,
m,
req,
mr,
i;
//Inspect the page for CSS only modules and mark them as loaded.
for (i in self.moduleInfo) {
if (self.moduleInfo.hasOwnProperty(i)) {
v = self.moduleInfo[i];
if (v.type && v.type === CSS) {
if (self.isCSSLoaded(v.name)) {
self.loaded[i] = true;
}
}
}
}
for (i in ON_PAGE) {
if (ON_PAGE.hasOwnProperty(i)) {
v = ON_PAGE[i];
if (v.details) {
m = self.moduleInfo[v.name];
req = v.details.requires;
mr = m && m.requires;
if (m) {
if (!m._inspected && req && mr.length !== req.length) {
// console.log('deleting ' + m.name);
delete m.expanded;
}
} else {
m = self.addModule(v.details, i);
}
m._inspected = true;
}
}
}
},
/*
* returns true if b is not loaded, and is required directly or by means of modules it supersedes.
* @private
* @method _requires
* @param {String} mod1 The first module to compare
* @param {String} mod2 The second module to compare
*/
_requires: function (mod1, mod2) {
var i,
rm,
after_map,
s,
info = this.moduleInfo,
m = info[mod1],
other = info[mod2];
if (!m || !other) {
return false;
}
rm = m.expanded_map;
after_map = m.after_map;
// check if this module should be sorted after the other
// do this first to short circut circular deps
if (after_map && mod2 in after_map) {
return true;
}
after_map = other.after_map;
// and vis-versa
if (after_map && mod1 in after_map) {
return false;
}
// check if this module requires one the other supersedes
s = info[mod2] && info[mod2].supersedes;
if (s) {
for (i = 0; i < s.length; i++) {
if (this._requires(mod1, s[i])) {
return true;
}
}
}
s = info[mod1] && info[mod1].supersedes;
if (s) {
for (i = 0; i < s.length; i++) {
if (this._requires(mod2, s[i])) {
return false;
}
}
}
// check if this module requires the other directly
// if (r && yArray.indexOf(r, mod2) > -1) {
if (rm && mod2 in rm) {
return true;
}
// external css files should be sorted below yui css
if (m.ext && m.type === CSS && !other.ext && other.type === CSS) {
return true;
}
return false;
},
/**
* Apply a new config to the Loader instance
* @method _config
* @private
* @param {Object} o The new configuration
*/
_config: function (o) {
var i,
j,
val,
a,
f,
group,
groupName,
self = this,
mods = [],
mod;
// apply config values
if (o) {
for (i in o) {
if (o.hasOwnProperty(i)) {
val = o[i];
//TODO This should be a case
if (i === "require") {
self.require(val);
} else if (i === "skin") {
//If the config.skin is a string, format to the expected object
if (typeof val === "string") {
self.skin.defaultSkin = o.skin;
val = {
defaultSkin: val,
};
}
Y.mix(self.skin, val, true);
} else if (i === "groups") {
for (j in val) {
if (val.hasOwnProperty(j)) {
groupName = j;
group = val[j];
self.addGroup(group, groupName);
if (group.aliases) {
for (a in group.aliases) {
if (group.aliases.hasOwnProperty(a)) {
self.addAlias(group.aliases[a], a);
}
}
}
}
}
} else if (i === "modules") {
// add a hash of module definitions
for (j in val) {
if (val.hasOwnProperty(j)) {
self.addModule(val[j], j);
}
}
} else if (i === "aliases") {
for (j in val) {
if (val.hasOwnProperty(j)) {
self.addAlias(val[j], j);
}
}
} else if (i === "gallery") {
if (this.groups.gallery.update) {
this.groups.gallery.update(val, o);
}
} else if (i === "yui2" || i === "2in3") {
if (this.groups.yui2.update) {
this.groups.yui2.update(o["2in3"], o.yui2, o);
}
} else {
self[i] = val;
}
}
}
}
// fix filter
f = self.filter;
if (L.isString(f)) {
f = f.toUpperCase();
self.filterName = f;
self.filter = self.FILTER_DEFS[f];
if (f === "DEBUG") {
self.require("yui-log", "dump");
}
}
if (self.filterName && self.coverage) {
if (
self.filterName === "COVERAGE" &&
L.isArray(self.coverage) &&
self.coverage.length
) {
for (i = 0; i < self.coverage.length; i++) {
mod = self.coverage[i];
if (self.moduleInfo[mod] && self.moduleInfo[mod].use) {
mods = [].concat(mods, self.moduleInfo[mod].use);
} else {
mods.push(mod);
}
}
self.filters = self.filters || {};
Y.Array.each(mods, function (mod) {
self.filters[mod] = self.FILTER_DEFS.COVERAGE;
});
self.filterName = "RAW";
self.filter = self.FILTER_DEFS[self.filterName];
}
}
},
/**
* Returns the skin module name for the specified skin name. If a
* module name is supplied, the returned skin module name is
* specific to the module passed in.
* @method formatSkin
* @param {string} skin the name of the skin.
* @param {string} mod optional: the name of a module to skin.
* @return {string} the full skin module name.
*/
formatSkin: function (skin, mod) {
var s = SKIN_PREFIX + skin;
if (mod) {
s = s + "-" + mod;
}
return s;
},
/**
* Adds the skin def to the module info
* @method _addSkin
* @param {string} skin the name of the skin.
* @param {string} mod the name of the module.
* @param {string} parent parent module if this is a skin of a
* submodule or plugin.
* @return {string} the module name for the skin.
* @private
*/
_addSkin: function (skin, mod, parent) {
var mdef,
pkg,
name,
nmod,
info = this.moduleInfo,
sinf = this.skin,
ext = info[mod] && info[mod].ext;
// Add a module definition for the module-specific skin css
if (mod) {
name = this.formatSkin(skin, mod);
if (!info[name]) {
mdef = info[mod];
pkg = mdef.pkg || mod;
nmod = {
skin: true,
name: name,
group: mdef.group,
type: "css",
after: sinf.after,
path:
(parent || pkg) + "/" + sinf.base + skin + "/" + mod + ".css",
ext: ext,
};
if (mdef.base) {
nmod.base = mdef.base;
}
if (mdef.configFn) {
nmod.configFn = mdef.configFn;
}
this.addModule(nmod, name);
}
}
return name;
},
/**
* Adds an alias module to the system
* @method addAlias
* @param {Array} use An array of modules that makes up this alias
* @param {String} name The name of the alias
* @example
* var loader = new Y.Loader({});
* loader.addAlias([ 'node', 'yql' ], 'davglass');
* loader.require(['davglass']);
* var out = loader.resolve(true);
*
* //out.js will contain Node and YQL modules
*/
addAlias: function (use, name) {
YUI.Env.aliases[name] = use;
this.addModule({
name: name,
use: use,
});
},
/**
* Add a new module group
* @method addGroup
* @param {Object} config An object containing the group configuration data
* @param {String} config.name required, the group name
* @param {String} config.base The base directory for this module group
* @param {String} config.root The root path to add to each combo resource path
* @param {Boolean} config.combine Should the request be combined
* @param {String} config.comboBase Combo service base path
* @param {Object} config.modules The group of modules
* @param {String} name the group name.
* @example
* var loader = new Y.Loader({});
* loader.addGroup({
* name: 'davglass',
* combine: true,
* comboBase: '/combo?',
* root: '',
* modules: {
* //Module List here
* }
* }, 'davglass');
*/
addGroup: function (o, name) {
var mods = o.modules,
self = this,
i,
v;
name = name || o.name;
o.name = name;
self.groups[name] = o;
if (o.patterns) {
for (i in o.patterns) {
if (o.patterns.hasOwnProperty(i)) {
o.patterns[i].group = name;
self.patterns[i] = o.patterns[i];
}
}
}
if (mods) {
for (i in mods) {
if (mods.hasOwnProperty(i)) {
v = mods[i];
if (typeof v === "string") {
v = { name: i, fullpath: v };
}
v.group = name;
self.addModule(v, i);
}
}
}
},
/**
* Add a new module to the component metadata.
* @method addModule
* @param {Object} config An object containing the module data.
* @param {String} config.name Required, the component name
* @param {String} config.type Required, the component type (js or css)
* @param {String} config.path Required, the path to the script from `base`
* @param {Array} config.requires Array of modules required by this component
* @param {Array} [config.optional] Array of optional modules for this component
* @param {Array} [config.supersedes] Array of the modules this component replaces
* @param {Array} [config.after] Array of modules the components which, if present, should be sorted above this one
* @param {Object} [config.after_map] Faster alternative to 'after' -- supply a hash instead of an array
* @param {Number} [config.rollup] The number of superseded modules required for automatic rollup
* @param {String} [config.fullpath] If `fullpath` is specified, this is used instead of the configured `base + path`
* @param {Boolean} [config.skinnable] Flag to determine if skin assets should automatically be pulled in
* @param {Object} [config.submodules] Hash of submodules
* @param {String} [config.group] The group the module belongs to -- this is set automatically when it is added as part of a group configuration.
* @param {Array} [config.lang] Array of BCP 47 language tags of languages for which this module has localized resource bundles, e.g., `["en-GB", "zh-Hans-CN"]`
* @param {Object} [config.condition] Specifies that the module should be loaded automatically if a condition is met. This is an object with up to four fields:
* @param {String} [config.condition.trigger] The name of a module that can trigger the auto-load
* @param {Function} [config.condition.test] A function that returns true when the module is to be loaded.
* @param {String} [config.condition.ua] The UA name of <a href="UA.html">Y.UA</a> object that returns true when the module is to be loaded. e.g., `"ie"`, `"nodejs"`.
* @param {String} [config.condition.when] Specifies the load order of the conditional module
* with regard to the position of the trigger module.
* This should be one of three values: `before`, `after`, or `instead`. The default is `after`.
* @param {Object} [config.testresults] A hash of test results from `Y.Features.all()`
* @param {Function} [config.configFn] A function to exectute when configuring this module
* @param {Object} config.configFn.mod The module config, modifying this object will modify it's config. Returning false will delete the module's config.
* @param {String} [name] The module name, required if not in the module data.
* @return {Object} the module definition or null if the object passed in did not provide all required attributes.
*/
addModule: function (o, name) {
name = name || o.name;
if (typeof o === "string") {
o = { name: name, fullpath: o };
}
var subs,
i,
l,
t,
sup,
s,
smod,
plugins,
plug,
j,
langs,
packName,
supName,
flatSup,
flatLang,
lang,
ret,
overrides,
skinname,
when,
g,
p,
conditions = this.conditions,
trigger;
//Only merge this data if the temp flag is set
//from an earlier pass from a pattern or else
//an override module (YUI_config) can not be used to
//replace a default module.
if (this.moduleInfo[name] && this.moduleInfo[name].temp) {
//This catches temp modules loaded via a pattern
// The module will be added twice, once from the pattern and
// Once from the actual add call, this ensures that properties
// that were added to the module the first time around (group: gallery)
// are also added the second time around too.
o = Y.merge(this.moduleInfo[name], o);
}
o.name = name;
if (!o || !o.name) {
return null;
}
if (!o.type) {
//Always assume it's javascript unless the CSS pattern is matched.
o.type = JS;
p = o.path || o.fullpath;
if (p && this.REGEX_CSS.test(p)) {
o.type = CSS;
}
}
if (!o.path && !o.fullpath) {
o.path = _path(name, name, o.type);
}
o.supersedes = o.supersedes || o.use;
o.ext = "ext" in o ? o.ext : this._internal ? false : true;
// Handle submodule logic
subs = o.submodules;
this.moduleInfo[name] = o;
o.requires = o.requires || [];
/*
Only allowing the cascade of requires information, since
optional and supersedes are far more fine grained than
a blanket requires is.
*/
if (this.requires) {
for (i = 0; i < this.requires.length; i++) {
o.requires.push(this.requires[i]);
}
}
if (o.group && this.groups && this.groups[o.group]) {
g = this.groups[o.group];
if (g.requires) {
for (i = 0; i < g.requires.length; i++) {
o.requires.push(g.requires[i]);
}
}
}
if (!o.defaults) {
o.defaults = {
requires: o.requires ? [].concat(o.requires) : null,
supersedes: o.supersedes ? [].concat(o.supersedes) : null,
optional: o.optional ? [].concat(o.optional) : null,
};
}
if (o.skinnable && o.ext && o.temp) {
skinname = this._addSkin(this.skin.defaultSkin, name);
o.requires.unshift(skinname);
}
if (o.requires.length) {
o.requires = this.filterRequires(o.requires) || [];
}
if (!o.langPack && o.lang) {
langs = yArray(o.lang);
for (j = 0; j < langs.length; j++) {
lang = langs[j];
packName = this.getLangPackName(lang, name);
smod = this.moduleInfo[packName];
if (!smod) {
smod = this._addLangPack(lang, o, packName);
}
}
}
if (subs) {
sup = o.supersedes || [];
l = 0;
for (i in subs) {
if (subs.hasOwnProperty(i)) {
s = subs[i];
s.path = s.path || _path(name, i, o.type);
s.pkg = name;
s.group = o.group;
if (s.supersedes) {
sup = sup.concat(s.supersedes);
}
smod = this.addModule(s, i);
sup.push(i);
if (smod.skinnable) {
o.skinnable = true;
overrides = this.skin.overrides;
if (overrides && overrides[i]) {
for (j = 0; j < overrides[i].length; j++) {
skinname = this._addSkin(overrides[i][j], i, name);
sup.push(skinname);
}
}
skinname = this._addSkin(this.skin.defaultSkin, i, name);
sup.push(skinname);
}
// looks like we are expected to work out the metadata
// for the parent module language packs from what is
// specified in the child modules.
if (s.lang && s.lang.length) {
langs = yArray(s.lang);
for (j = 0; j < langs.length; j++) {
lang = langs[j];
packName = this.getLangPackName(lang, name);
supName = this.getLangPackName(lang, i);
smod = this.moduleInfo[packName];
if (!smod) {
smod = this._addLangPack(lang, o, packName);
}
flatSup = flatSup || yArray.hash(smod.supersedes);
if (!(supName in flatSup)) {
smod.supersedes.push(supName);
}
o.lang = o.lang || [];
flatLang = flatLang || yArray.hash(o.lang);
if (!(lang in flatLang)) {
o.lang.push(lang);
}
// Add rollup file, need to add to supersedes list too
// default packages
packName = this.getLangPackName(ROOT_LANG, name);
supName = this.getLangPackName(ROOT_LANG, i);
smod = this.moduleInfo[packName];
if (!smod) {
smod = this._addLangPack(lang, o, packName);
}
if (!(supName in flatSup)) {
smod.supersedes.push(supName);
}
// Add rollup file, need to add to supersedes list too
}
}
l++;
}
}
//o.supersedes = YObject.keys(yArray.hash(sup));
o.supersedes = yArray.dedupe(sup);
if (this.allowRollup) {
o.rollup = l < 4 ? l : Math.min(l - 1, 4);
}
}
plugins = o.plugins;
if (plugins) {
for (i in plugins) {
if (plugins.hasOwnProperty(i)) {
plug = plugins[i];
plug.pkg = name;
plug.path = plug.path || _path(name, i, o.type);
plug.requires = plug.requires || [];
plug.group = o.group;
this.addModule(plug, i);
if (o.skinnable) {
this._addSkin(this.skin.defaultSkin, i, name);
}
}
}
}
if (o.condition) {
t = o.condition.trigger;
if (YUI.Env.aliases[t]) {
t = YUI.Env.aliases[t];
}
if (!Y.Lang.isArray(t)) {
t = [t];
}
for (i = 0; i < t.length; i++) {
trigger = t[i];
when = o.condition.when;
conditions[trigger] = conditions[trigger] || {};
conditions[trigger][name] = o.condition;
// the 'when' attribute can be 'before', 'after', or 'instead'
// the default is after.
if (when && when !== "after") {
if (when === "instead") {
// replace the trigger
o.supersedes = o.supersedes || [];
o.supersedes.push(trigger);
}
// before the trigger
// the trigger requires the conditional mod,
// so it should appear before the conditional
// mod if we do not intersede.
} else {
// after the trigger
o.after = o.after || [];
o.after.push(trigger);
}
}
}
if (o.supersedes) {
o.supersedes = this.filterRequires(o.supersedes);
}
if (o.after) {
o.after = this.filterRequires(o.after);
o.after_map = yArray.hash(o.after);
}
// this.dirty = true;
if (o.configFn) {
ret = o.configFn(o);
if (ret === false) {
delete this.moduleInfo[name];
delete GLOBAL_ENV._renderedMods[name];
o = null;
}
}
//Add to global cache
if (o) {
if (!GLOBAL_ENV._renderedMods) {
GLOBAL_ENV._renderedMods = {};
}
GLOBAL_ENV._renderedMods[name] = Y.mix(
GLOBAL_ENV._renderedMods[name] || {},
o,
);
GLOBAL_ENV._conditions = conditions;
}
return o;
},
/**
* Add a requirement for one or more module
* @method require
* @param {string[] | string*} what the modules to load.
*/
require: function (what) {
var a = typeof what === "string" ? yArray(arguments) : what;
this.dirty = true;
this.required = Y.merge(
this.required,
yArray.hash(this.filterRequires(a)),
);
this._explodeRollups();
},
/**
* Grab all the items that were asked for, check to see if the Loader
* meta-data contains a "use" array. If it doesm remove the asked item and replace it with
* the content of the "use".
* This will make asking for: "dd"
* Actually ask for: "dd-ddm-base,dd-ddm,dd-ddm-drop,dd-drag,dd-proxy,dd-constrain,dd-drop,dd-scroll,dd-drop-plugin"
* @private
* @method _explodeRollups
*/
_explodeRollups: function () {
var self = this,
m,
m2,
i,
a,
v,
len,
len2,
r = self.required;
if (!self.allowRollup) {
for (i in r) {
if (r.hasOwnProperty(i)) {
m = self.getModule(i);
if (m && m.use) {
len = m.use.length;
for (a = 0; a < len; a++) {
m2 = self.getModule(m.use[a]);
if (m2 && m2.use) {
len2 = m2.use.length;
for (v = 0; v < len2; v++) {
r[m2.use[v]] = true;
}
} else {
r[m.use[a]] = true;
}
}
}
}
}
self.required = r;
}
},
/**
* Explodes the required array to remove aliases and replace them with real modules
* @method filterRequires
* @param {Array} r The original requires array
* @return {Array} The new array of exploded requirements
*/
filterRequires: function (r) {
if (r) {
if (!Y.Lang.isArray(r)) {
r = [r];
}
r = Y.Array(r);
var c = [],
i,
mod,
o,
m;
for (i = 0; i < r.length; i++) {
mod = this.getModule(r[i]);
if (mod && mod.use) {
for (o = 0; o < mod.use.length; o++) {
//Must walk the other modules in case a module is a rollup of rollups (datatype)
m = this.getModule(mod.use[o]);
if (m && m.use && m.name !== mod.name) {
c = Y.Array.dedupe([].concat(c, this.filterRequires(m.use)));
} else {
c.push(mod.use[o]);
}
}
} else {
c.push(r[i]);
}
}
r = c;
}
return r;
},
/**
* Returns an object containing properties for all modules required
* in order to load the requested module
* @method getRequires
* @param {object} mod The module definition from moduleInfo.
* @return {array} the expanded requirement list.
*/
getRequires: function (mod) {
if (!mod) {
//console.log('returning no reqs for ' + mod.name);
return NO_REQUIREMENTS;
}
if (mod._parsed) {
//console.log('returning requires for ' + mod.name, mod.requires);
return mod.expanded || NO_REQUIREMENTS;
}
//TODO add modue cache here out of scope..
var i,
m,
j,
add,
packName,
lang,
testresults = this.testresults,
name = mod.name,
cond,
adddef = ON_PAGE[name] && ON_PAGE[name].details,
d,
go,
def,
r,
old_mod,
o,
skinmod,
skindef,
skinpar,
skinname,
intl = mod.lang || mod.intl,
info = this.moduleInfo,
ftests = Y.Features && Y.Features.tests.load,
hash,
reparse;
// console.log(name);
// pattern match leaves module stub that needs to be filled out
if (mod.temp && adddef) {
old_mod = mod;
mod = this.addModule(adddef, name);
mod.group = old_mod.group;
mod.pkg = old_mod.pkg;
delete mod.expanded;
}
// console.log('cache: ' + mod.langCache + ' == ' + this.lang);
//If a skin or a lang is different, reparse..
reparse = !(
(!this.lang || mod.langCache === this.lang) &&
mod.skinCache === this.skin.defaultSkin
);
if (mod.expanded && !reparse) {
return mod.expanded;
}
d = [];
hash = {};
r = this.filterRequires(mod.requires);
if (mod.lang) {
//If a module has a lang attribute, auto add the intl requirement.
d.unshift("intl");
r.unshift("intl");
intl = true;
}
o = this.filterRequires(mod.optional);
mod._parsed = true;
mod.langCache = this.lang;
mod.skinCache = this.skin.defaultSkin;
for (i = 0; i < r.length; i++) {
if (!hash[r[i]]) {
d.push(r[i]);
hash[r[i]] = true;
m = this.getModule(r[i]);
if (m) {
add = this.getRequires(m);
intl = intl || (m.expanded_map && INTL in m.expanded_map);
for (j = 0; j < add.length; j++) {
d.push(add[j]);
}
}
}
}
// get the requirements from superseded modules, if any
r = this.filterRequires(mod.supersedes);
if (r) {
for (i = 0; i < r.length; i++) {
if (!hash[r[i]]) {
// if this module has submodules, the requirements list is
// expanded to include the submodules. This is so we can
// prevent dups when a submodule is already loaded and the
// parent is requested.
if (mod.submodules) {
d.push(r[i]);
}
hash[r[i]] = true;
m = this.getModule(r[i]);
if (m) {
add = this.getRequires(m);
intl = intl || (m.expanded_map && INTL in m.expanded_map);
for (j = 0; j < add.length; j++) {
d.push(add[j]);
}
}
}
}
}
if (o && this.loadOptional) {
for (i = 0; i < o.length; i++) {
if (!hash[o[i]]) {
d.push(o[i]);
hash[o[i]] = true;
m = info[o[i]];
if (m) {
add = this.getRequires(m);
intl = intl || (m.expanded_map && INTL in m.expanded_map);
for (j = 0; j < add.length; j++) {
d.push(add[j]);
}
}
}
}
}
cond = this.conditions[name];
if (cond) {
//Set the module to not parsed since we have conditionals and this could change the dependency tree.
mod._parsed = false;
if (testresults && ftests) {
oeach(testresults, function (result, id) {
var condmod = ftests[id].name;
if (!hash[condmod] && ftests[id].trigger === name) {
if (result && ftests[id]) {
hash[condmod] = true;
d.push(condmod);
}
}
});
} else {
for (i in cond) {
if (cond.hasOwnProperty(i)) {
if (!hash[i]) {
def = cond[i];
//first see if they've specfied a ua check
//then see if they've got a test fn & if it returns true
//otherwise just having a condition block is enough
go =
def &&
((!def.ua && !def.test) ||
(def.ua && Y.UA[def.ua]) ||
(def.test && def.test(Y, r)));
if (go) {
hash[i] = true;
d.push(i);
m = this.getModule(i);
if (m) {
add = this.getRequires(m);
for (j = 0; j < add.length; j++) {
d.push(add[j]);
}
}
}
}
}
}
}
}
// Create skin modules
if (mod.skinnable) {
skindef = this.skin.overrides;
for (i in YUI.Env.aliases) {
if (YUI.Env.aliases.hasOwnProperty(i)) {
if (Y.Array.indexOf(YUI.Env.aliases[i], name) > -1) {
skinpar = i;
}
}
}
if (skindef && (skindef[name] || (skinpar && skindef[skinpar]))) {
skinname = name;
if (skindef[skinpar]) {
skinname = skinpar;
}
for (i = 0; i < skindef[skinname].length; i++) {
skinmod = this._addSkin(skindef[skinname][i], name);
if (!this.isCSSLoaded(skinmod, this._boot)) {
d.push(skinmod);
}
}
} else {
skinmod = this._addSkin(this.skin.defaultSkin, name);
if (!this.isCSSLoaded(skinmod, this._boot)) {
d.push(skinmod);
}
}
}
mod._parsed = false;
if (intl) {
if (mod.lang && !mod.langPack && Y.Intl) {
lang = Y.Intl.lookupBestLang(this.lang || ROOT_LANG, mod.lang);
packName = this.getLangPackName(lang, name);
if (packName) {
d.unshift(packName);
}
}
d.unshift(INTL);
}
mod.expanded_map = yArray.hash(d);
mod.expanded = YObject.keys(mod.expanded_map);
return mod.expanded;
},
/**
* Check to see if named css module is already loaded on the page
* @method isCSSLoaded
* @param {String} name The name of the css file
* @return Boolean
*/
isCSSLoaded: function (name, skip) {
//TODO - Make this call a batching call with name being an array
if (!name || !YUI.Env.cssStampEl || (!skip && this.ignoreRegistered)) {
return false;
}
var el = YUI.Env.cssStampEl,
ret = false,
mod = YUI.Env._cssLoaded[name],
style = el.currentStyle; //IE
if (mod !== undefined) {
return mod;
}
//Add the classname to the element
el.className = name;
if (!style) {
style = Y.config.doc.defaultView.getComputedStyle(el, null);
}
if (style && style.display === "none") {
ret = true;
}
el.className = ""; //Reset the classname to ''
YUI.Env._cssLoaded[name] = ret;
return ret;
},
/**
* Returns a hash of module names the supplied module satisfies.
* @method getProvides
* @param {string} name The name of the module.
* @return {object} what this module provides.
*/
getProvides: function (name) {
var m = this.getModule(name),
o,
s;
// supmap = this.provides;
if (!m) {
return NOT_FOUND;
}
if (m && !m.provides) {
o = {};
s = m.supersedes;
if (s) {
yArray.each(
s,
function (v) {
Y.mix(o, this.getProvides(v));
},
this,
);
}
o[name] = true;
m.provides = o;
}
return m.provides;
},
/**
* Calculates the dependency tree, the result is stored in the sorted
* property.
* @method calculate
* @param {object} o optional options object.
* @param {string} type optional argument to prune modules.
*/
calculate: function (o, type) {
if (o || type || this.dirty) {
if (o) {
this._config(o);
}
if (!this._init) {
this._setup();
}
this._explode();
if (this.allowRollup) {
this._rollup();
} else {
this._explodeRollups();
}
this._reduce();
this._sort();
}
},
/**
* Creates a "psuedo" package for languages provided in the lang array
* @method _addLangPack
* @private
* @param {String} lang The language to create
* @param {Object} m The module definition to create the language pack around
* @param {String} packName The name of the package (e.g: lang/datatype-date-en-US)
* @return {Object} The module definition
*/
_addLangPack: function (lang, m, packName) {
var name = m.name,
packPath,
conf,
existing = this.moduleInfo[packName];
if (!existing) {
packPath = _path(m.pkg || name, packName, JS, true);
conf = {
path: packPath,
intl: true,
langPack: true,
ext: m.ext,
group: m.group,
supersedes: [],
};
if (m.root) {
conf.root = m.root;
}
if (m.base) {
conf.base = m.base;
}
if (m.configFn) {
conf.configFn = m.configFn;
}
this.addModule(conf, packName);
if (lang) {
Y.Env.lang = Y.Env.lang || {};
Y.Env.lang[lang] = Y.Env.lang[lang] || {};
Y.Env.lang[lang][name] = true;
}
}
return this.moduleInfo[packName];
},
/**
* Investigates the current YUI configuration on the page. By default,
* modules already detected will not be loaded again unless a force
* option is encountered. Called by calculate()
* @method _setup
* @private
*/
_setup: function () {
var info = this.moduleInfo,
name,
i,
j,
m,
l,
packName;
for (name in info) {
if (info.hasOwnProperty(name)) {
m = info[name];
if (m) {
// remove dups
//m.requires = YObject.keys(yArray.hash(m.requires));
m.requires = yArray.dedupe(m.requires);
// Create lang pack modules
//if (m.lang && m.lang.length) {
if (m.lang) {
// Setup root package if the module has lang defined,
// it needs to provide a root language pack
packName = this.getLangPackName(ROOT_LANG, name);
this._addLangPack(null, m, packName);
}
}
}
}
//l = Y.merge(this.inserted);
l = {};
// available modules
if (!this.ignoreRegistered) {
Y.mix(l, GLOBAL_ENV.mods);
}
// add the ignore list to the list of loaded packages
if (this.ignore) {
Y.mix(l, yArray.hash(this.ignore));
}
// expand the list to include superseded modules
for (j in l) {
if (l.hasOwnProperty(j)) {
Y.mix(l, this.getProvides(j));
}
}
// remove modules on the force list from the loaded list
if (this.force) {
for (i = 0; i < this.force.length; i++) {
if (this.force[i] in l) {
delete l[this.force[i]];
}
}
}
Y.mix(this.loaded, l);
this._init = true;
},
/**
* Builds a module name for a language pack
* @method getLangPackName
* @param {string} lang the language code.
* @param {string} mname the module to build it for.
* @return {string} the language pack module name.
*/
getLangPackName: function (lang, mname) {
return "lang/" + mname + (lang ? "_" + lang : "");
},
/**
* Inspects the required modules list looking for additional
* dependencies. Expands the required list to include all
* required modules. Called by calculate()
* @method _explode
* @private
*/
_explode: function () {
//TODO Move done out of scope
var r = this.required,
m,
reqs,
done = {},
self = this,
name,
expound;
// the setup phase is over, all modules have been created
self.dirty = false;
self._explodeRollups();
r = self.required;
for (name in r) {
if (r.hasOwnProperty(name)) {
if (!done[name]) {
done[name] = true;
m = self.getModule(name);
if (m) {
expound = m.expound;
if (expound) {
r[expound] = self.getModule(expound);
reqs = self.getRequires(r[expound]);
Y.mix(r, yArray.hash(reqs));
}
reqs = self.getRequires(m);
Y.mix(r, yArray.hash(reqs));
}
}
}
}
},
/**
* The default method used to test a module against a pattern
* @method _patternTest
* @private
* @param {String} mname The module being tested
* @param {String} pname The pattern to match
*/
_patternTest: function (mname, pname) {
return mname.indexOf(pname) > -1;
},
/**
* Get's the loader meta data for the requested module
* @method getModule
* @param {String} mname The module name to get
* @return {Object} The module metadata
*/
getModule: function (mname) {
//TODO: Remove name check - it's a quick hack to fix pattern WIP
if (!mname) {
return null;
}
var p,
found,
pname,
m = this.moduleInfo[mname],
patterns = this.patterns;
// check the patterns library to see if we should automatically add
// the module with defaults
if (!m || (m && m.ext)) {
for (pname in patterns) {
if (patterns.hasOwnProperty(pname)) {
p = patterns[pname];
//There is no test method, create a default one that tests
// the pattern against the mod name
if (!p.test) {
p.test = this._patternTest;
}
if (p.test(mname, pname)) {
// use the metadata supplied for the pattern
// as the module definition.
found = p;
break;
}
}
}
}
if (!m) {
if (found) {
if (p.action) {
p.action.call(this, mname, pname);
} else {
// ext true or false?
m = this.addModule(Y.merge(found), mname);
if (found.configFn) {
m.configFn = found.configFn;
}
m.temp = true;
}
}
} else {
if (found && m && found.configFn && !m.configFn) {
m.configFn = found.configFn;
m.configFn(m);
}
}
return m;
},
// impl in rollup submodule
_rollup: function () {},
/**
* Remove superceded modules and loaded modules. Called by
* calculate() after we have the mega list of all dependencies
* @method _reduce
* @return {object} the reduced dependency hash.
* @private
*/
_reduce: function (r) {
r = r || this.required;
var i,
j,
s,
m,
type = this.loadType,
ignore = this.ignore ? yArray.hash(this.ignore) : false;
for (i in r) {
if (r.hasOwnProperty(i)) {
m = this.getModule(i);
// remove if already loaded
if (
((this.loaded[i] || ON_PAGE[i]) &&
!this.forceMap[i] &&
!this.ignoreRegistered) ||
(type && m && m.type !== type)
) {
delete r[i];
}
if (ignore && ignore[i]) {
delete r[i];
}
// remove anything this module supersedes
s = m && m.supersedes;
if (s) {
for (j = 0; j < s.length; j++) {
if (s[j] in r) {
delete r[s[j]];
}
}
}
}
}
return r;
},
/**
* Handles the queue when a module has been loaded for all cases
* @method _finish
* @private
* @param {String} msg The message from Loader
* @param {Boolean} success A boolean denoting success or failure
*/
_finish: function (msg, success) {
_queue.running = false;
var onEnd = this.onEnd;
if (onEnd) {
onEnd.call(this.context, {
msg: msg,
data: this.data,
success: success,
});
}
this._continue();
},
/**
* The default Loader onSuccess handler, calls this.onSuccess with a payload
* @method _onSuccess
* @private
*/
_onSuccess: function () {
var self = this,
skipped = Y.merge(self.skipped),
fn,
failed = [],
rreg = self.requireRegistration,
success,
msg,
i,
mod;
for (i in skipped) {
if (skipped.hasOwnProperty(i)) {
delete self.inserted[i];
}
}
self.skipped = {};
for (i in self.inserted) {
if (self.inserted.hasOwnProperty(i)) {
mod = self.getModule(i);
if (mod && rreg && mod.type === JS && !(i in YUI.Env.mods)) {
failed.push(i);
} else {
Y.mix(self.loaded, self.getProvides(i));
}
}
}
fn = self.onSuccess;
msg = failed.length ? "notregistered" : "success";
success = !failed.length;
if (fn) {
fn.call(self.context, {
msg: msg,
data: self.data,
success: success,
failed: failed,
skipped: skipped,
});
}
self._finish(msg, success);
},
/**
* The default Loader onProgress handler, calls this.onProgress with a payload
* @method _onProgress
* @private
*/
_onProgress: function (e) {
var self = this,
i;
//set the internal cache to what just came in.
if (e.data && e.data.length) {
for (i = 0; i < e.data.length; i++) {
e.data[i] = self.getModule(e.data[i].name);
}
}
if (self.onProgress) {
self.onProgress.call(self.context, {
name: e.url,
data: e.data,
});
}
},
/**
* The default Loader onFailure handler, calls this.onFailure with a payload
* @method _onFailure
* @private
*/
_onFailure: function (o) {
var f = this.onFailure,
msg = [],
i = 0,
len = o.errors.length;
for (i; i < len; i++) {
msg.push(o.errors[i].error);
}
msg = msg.join(",");
if (f) {
f.call(this.context, {
msg: msg,
data: this.data,
success: false,
});
}
this._finish(msg, false);
},
/**
* The default Loader onTimeout handler, calls this.onTimeout with a payload
* @method _onTimeout
* @param {Get.Transaction} transaction The Transaction object from `Y.Get`
* @private
*/
_onTimeout: function (transaction) {
var f = this.onTimeout;
if (f) {
f.call(this.context, {
msg: "timeout",
data: this.data,
success: false,
transaction: transaction,
});
}
},
/**
* Sorts the dependency tree. The last step of calculate()
* @method _sort
* @private
*/
_sort: function () {
// create an indexed list
var s = YObject.keys(this.required),
// loaded = this.loaded,
//TODO Move this out of scope
done = {},
p = 0,
l,
a,
b,
j,
k,
moved,
doneKey;
// keep going until we make a pass without moving anything
for (;;) {
l = s.length;
moved = false;
// start the loop after items that are already sorted
for (j = p; j < l; j++) {
// check the next module on the list to see if its
// dependencies have been met
a = s[j];
// check everything below current item and move if we
// find a requirement for the current item
for (k = j + 1; k < l; k++) {
doneKey = a + s[k];
if (!done[doneKey] && this._requires(a, s[k])) {
// extract the dependency so we can move it up
b = s.splice(k, 1);
// insert the dependency above the item that
// requires it
s.splice(j, 0, b[0]);
// only swap two dependencies once to short circut
// circular dependencies
done[doneKey] = true;
// keep working
moved = true;
break;
}
}
// jump out of loop if we moved something
if (moved) {
break;
// this item is sorted, move our pointer and keep going
} else {
p++;
}
}
// when we make it here and moved is false, we are
// finished sorting
if (!moved) {
break;
}
}
this.sorted = s;
},
/**
* Handles the actual insertion of script/link tags
* @method _insert
* @private
* @param {Object} source The YUI instance the request came from
* @param {Object} o The metadata to include
* @param {String} type JS or CSS
* @param {Boolean} [skipcalc=false] Do a Loader.calculate on the meta
*/
_insert: function (source, o, type, skipcalc) {
// restore the state at the time of the request
if (source) {
this._config(source);
}
// build the dependency list
// don't include type so we can process CSS and script in
// one pass when the type is not specified.
var modules = this.resolve(!skipcalc),
self = this,
comp = 0,
actions = 0,
mods = {},
deps,
complete;
self._refetch = [];
if (type) {
//Filter out the opposite type and reset the array so the checks later work
modules[type === JS ? CSS : JS] = [];
}
if (!self.fetchCSS) {
modules.css = [];
}
if (modules.js.length) {
comp++;
}
if (modules.css.length) {
comp++;
}
//console.log('Resolved Modules: ', modules);
complete = function (d) {
actions++;
var errs = {},
i = 0,
o = 0,
u = "",
fn,
modName,
resMods;
if (d && d.errors) {
for (i = 0; i < d.errors.length; i++) {
if (d.errors[i].request) {
u = d.errors[i].request.url;
} else {
u = d.errors[i];
}
errs[u] = u;
}
}
if (d && d.data && d.data.length && d.type === "success") {
for (i = 0; i < d.data.length; i++) {
self.inserted[d.data[i].name] = true;
//If the external module has a skin or a lang, reprocess it
if (d.data[i].lang || d.data[i].skinnable) {
delete self.inserted[d.data[i].name];
self._refetch.push(d.data[i].name);
}
}
}
if (actions === comp) {
self._loading = null;
if (self._refetch.length) {
//Get the deps for the new meta-data and reprocess
for (i = 0; i < self._refetch.length; i++) {
deps = self.getRequires(self.getModule(self._refetch[i]));
for (o = 0; o < deps.length; o++) {
if (!self.inserted[deps[o]]) {
//We wouldn't be to this point without the module being here
mods[deps[o]] = deps[o];
}
}
}
mods = Y.Object.keys(mods);
if (mods.length) {
self.require(mods);
resMods = self.resolve(true);
if (resMods.cssMods.length) {
for (i = 0; i < resMods.cssMods.length; i++) {
modName = resMods.cssMods[i].name;
delete YUI.Env._cssLoaded[modName];
if (self.isCSSLoaded(modName)) {
self.inserted[modName] = true;
delete self.required[modName];
}
}
self.sorted = [];
self._sort();
}
d = null; //bail
self._insert(); //insert the new deps
}
}
if (d && d.fn) {
fn = d.fn;
delete d.fn;
fn.call(self, d);
}
}
};
this._loading = true;
if (!modules.js.length && !modules.css.length) {
actions = -1;
complete({
fn: self._onSuccess,
});
return;
}
if (modules.css.length) {
//Load CSS first
Y.Get.css(modules.css, {
data: modules.cssMods,
attributes: self.cssAttributes,
insertBefore: self.insertBefore,
charset: self.charset,
timeout: self.timeout,
context: self,
onProgress: function (e) {
self._onProgress.call(self, e);
},
onTimeout: function (d) {
self._onTimeout.call(self, d);
},
onSuccess: function (d) {
d.type = "success";
d.fn = self._onSuccess;
complete.call(self, d);
},
onFailure: function (d) {
d.type = "failure";
d.fn = self._onFailure;
complete.call(self, d);
},
});
}
if (modules.js.length) {
Y.Get.js(modules.js, {
data: modules.jsMods,
insertBefore: self.insertBefore,
attributes: self.jsAttributes,
charset: self.charset,
timeout: self.timeout,
autopurge: false,
context: self,
async: self.async,
onProgress: function (e) {
self._onProgress.call(self, e);
},
onTimeout: function (d) {
self._onTimeout.call(self, d);
},
onSuccess: function (d) {
d.type = "success";
d.fn = self._onSuccess;
complete.call(self, d);
},
onFailure: function (d) {
d.type = "failure";
d.fn = self._onFailure;
complete.call(self, d);
},
});
}
},
/**
* Once a loader operation is completely finished, process any additional queued items.
* @method _continue
* @private
*/
_continue: function () {
if (!_queue.running && _queue.size() > 0) {
_queue.running = true;
_queue.next()();
}
},
/**
* inserts the requested modules and their dependencies.
* <code>type</code> can be "js" or "css". Both script and
* css are inserted if type is not provided.
* @method insert
* @param {object} o optional options object.
* @param {string} type the type of dependency to insert.
*/
insert: function (o, type, skipsort) {
var self = this,
copy = Y.merge(this);
delete copy.require;
delete copy.dirty;
_queue.add(function () {
self._insert(copy, o, type, skipsort);
});
this._continue();
},
/**
* Executed every time a module is loaded, and if we are in a load
* cycle, we attempt to load the next script. Public so that it
* is possible to call this if using a method other than
* Y.register to determine when scripts are fully loaded
* @method loadNext
* @deprecated
* @param {string} mname optional the name of the module that has
* been loaded (which is usually why it is time to load the next
* one).
*/
loadNext: function () {
return;
},
/**
* Apply filter defined for this instance to a url/path
* @method _filter
* @param {string} u the string to filter.
* @param {string} name the name of the module, if we are processing
* a single module as opposed to a combined url.
* @return {string} the filtered string.
* @private
*/
_filter: function (u, name, group) {
var f = this.filter,
hasFilter = name && name in this.filters,
modFilter = hasFilter && this.filters[name],
groupName =
group ||
(this.moduleInfo[name] ? this.moduleInfo[name].group : null);
if (
groupName &&
this.groups[groupName] &&
this.groups[groupName].filter
) {
modFilter = this.groups[groupName].filter;
hasFilter = true;
}
if (u) {
if (hasFilter) {
f = L.isString(modFilter)
? this.FILTER_DEFS[modFilter.toUpperCase()] || null
: modFilter;
}
if (f) {
u = u.replace(new RegExp(f.searchExp, "g"), f.replaceStr);
}
}
return u;
},
/**
* Generates the full url for a module
* @method _url
* @param {string} path the path fragment.
* @param {String} name The name of the module
* @param {String} [base=self.base] The base url to use
* @return {string} the full url.
* @private
*/
_url: function (path, name, base) {
return this._filter((base || this.base || "") + path, name);
},
/**
* Returns an Object hash of file arrays built from `loader.sorted` or from an arbitrary list of sorted modules.
* @method resolve
* @param {Boolean} [calc=false] Perform a loader.calculate() before anything else
* @param {Array} [s=loader.sorted] An override for the loader.sorted array
* @return {Object} Object hash (js and css) of two arrays of file lists
* @example This method can be used as an off-line dep calculator
*
* var Y = YUI();
* var loader = new Y.Loader({
* filter: 'debug',
* base: '../../',
* root: 'build/',
* combine: true,
* require: ['node', 'dd', 'console']
* });
* var out = loader.resolve(true);
*
*/
resolve: function (calc, s) {
var len,
i,
m,
url,
group,
groupName,
j,
frag,
comboSource,
comboSources,
mods,
comboBase,
base,
urls,
u = [],
tmpBase,
baseLen,
resCombos = {},
self = this,
comboSep,
maxURLLength,
inserted = self.ignoreRegistered ? {} : self.inserted,
resolved = { js: [], jsMods: [], css: [], cssMods: [] },
type = self.loadType || "js",
addSingle;
if (
self.skin.overrides ||
self.skin.defaultSkin !== DEFAULT_SKIN ||
self.ignoreRegistered
) {
self._resetModules();
}
if (calc) {
self.calculate();
}
s = s || self.sorted;
addSingle = function (m) {
if (m) {
group = (m.group && self.groups[m.group]) || NOT_FOUND;
//Always assume it's async
if (group.async === false) {
m.async = group.async;
}
url = m.fullpath
? self._filter(m.fullpath, s[i])
: self._url(m.path, s[i], group.base || m.base);
if (m.attributes || m.async === false) {
url = {
url: url,
async: m.async,
};
if (m.attributes) {
url.attributes = m.attributes;
}
}
resolved[m.type].push(url);
resolved[m.type + "Mods"].push(m);
} else {
}
};
len = s.length;
// the default combo base
comboBase = self.comboBase;
url = comboBase;
comboSources = {};
for (i = 0; i < len; i++) {
comboSource = comboBase;
m = self.getModule(s[i]);
groupName = m && m.group;
group = self.groups[groupName];
if (groupName && group) {
if (!group.combine || m.fullpath) {
//This is not a combo module, skip it and load it singly later.
addSingle(m);
continue;
}
m.combine = true;
if (group.comboBase) {
comboSource = group.comboBase;
}
if ("root" in group && L.isValue(group.root)) {
m.root = group.root;
}
m.comboSep = group.comboSep || self.comboSep;
m.maxURLLength = group.maxURLLength || self.maxURLLength;
} else {
if (!self.combine) {
//This is not a combo module, skip it and load it singly later.
addSingle(m);
continue;
}
}
comboSources[comboSource] = comboSources[comboSource] || [];
comboSources[comboSource].push(m);
}
for (j in comboSources) {
if (comboSources.hasOwnProperty(j)) {
resCombos[j] = resCombos[j] || {
js: [],
jsMods: [],
css: [],
cssMods: [],
};
url = j;
mods = comboSources[j];
len = mods.length;
if (len) {
for (i = 0; i < len; i++) {
if (inserted[mods[i]]) {
continue;
}
m = mods[i];
// Do not try to combine non-yui JS unless combo def
// is found
if (m && (m.combine || !m.ext)) {
resCombos[j].comboSep = m.comboSep;
resCombos[j].group = m.group;
resCombos[j].maxURLLength = m.maxURLLength;
frag =
(L.isValue(m.root) ? m.root : self.root) +
(m.path || m.fullpath);
frag = self._filter(frag, m.name);
resCombos[j][m.type].push(frag);
resCombos[j][m.type + "Mods"].push(m);
} else {
//Add them to the next process..
if (mods[i]) {
addSingle(mods[i]);
}
}
}
}
}
}
for (j in resCombos) {
if (resCombos.hasOwnProperty(j)) {
base = j;
comboSep = resCombos[base].comboSep || self.comboSep;
maxURLLength = resCombos[base].maxURLLength || self.maxURLLength;
for (type in resCombos[base]) {
if (type === JS || type === CSS) {
urls = resCombos[base][type];
mods = resCombos[base][type + "Mods"];
len = urls.length;
tmpBase = base + urls.join(comboSep);
baseLen = tmpBase.length;
if (maxURLLength <= base.length) {
maxURLLength = MAX_URL_LENGTH;
}
if (len) {
if (baseLen > maxURLLength) {
u = [];
for (s = 0; s < len; s++) {
u.push(urls[s]);
tmpBase = base + u.join(comboSep);
if (tmpBase.length > maxURLLength) {
m = u.pop();
tmpBase = base + u.join(comboSep);
resolved[type].push(
self._filter(tmpBase, null, resCombos[base].group),
);
u = [];
if (m) {
u.push(m);
}
}
}
if (u.length) {
tmpBase = base + u.join(comboSep);
resolved[type].push(
self._filter(tmpBase, null, resCombos[base].group),
);
}
} else {
resolved[type].push(
self._filter(tmpBase, null, resCombos[base].group),
);
}
}
resolved[type + "Mods"] = resolved[type + "Mods"].concat(mods);
}
}
}
}
resCombos = null;
return resolved;
},
/**
Shortcut to calculate, resolve and load all modules.
var loader = new Y.Loader({
ignoreRegistered: true,
modules: {
mod: {
path: 'mod.js'
}
},
requires: [ 'mod' ]
});
loader.load(function() {
console.log('All modules have loaded..');
});
@method load
@param {Callback} cb Executed after all load operations are complete
*/
load: function (cb) {
if (!cb) {
return;
}
var self = this,
out = self.resolve(true);
self.data = out;
self.onEnd = function () {
cb.apply(self.context || self, arguments);
};
self.insert();
},
};
},
"3.12.0",
{ requires: ["get", "features"] },
);
YUI.add(
"loader-rollup",
function (Y, NAME) {
/**
* Optional automatic rollup logic for reducing http connections
* when not using a combo service.
* @module loader
* @submodule rollup
*/
/**
* Look for rollup packages to determine if all of the modules a
* rollup supersedes are required. If so, include the rollup to
* help reduce the total number of connections required. Called
* by calculate(). This is an optional feature, and requires the
* appropriate submodule to function.
* @method _rollup
* @for Loader
* @private
*/
Y.Loader.prototype._rollup = function () {
var i,
j,
m,
s,
r = this.required,
roll,
info = this.moduleInfo,
rolled,
c,
smod;
// find and cache rollup modules
if (this.dirty || !this.rollups) {
this.rollups = {};
for (i in info) {
if (info.hasOwnProperty(i)) {
m = this.getModule(i);
// if (m && m.rollup && m.supersedes) {
if (m && m.rollup) {
this.rollups[i] = m;
}
}
}
}
// make as many passes as needed to pick up rollup rollups
for (;;) {
rolled = false;
// go through the rollup candidates
for (i in this.rollups) {
if (this.rollups.hasOwnProperty(i)) {
// there can be only one, unless forced
if (!r[i] && (!this.loaded[i] || this.forceMap[i])) {
m = this.getModule(i);
s = m.supersedes || [];
roll = false;
// @TODO remove continue
if (!m.rollup) {
continue;
}
c = 0;
// check the threshold
for (j = 0; j < s.length; j++) {
smod = info[s[j]];
// if the superseded module is loaded, we can't
// load the rollup unless it has been forced.
if (this.loaded[s[j]] && !this.forceMap[s[j]]) {
roll = false;
break;
// increment the counter if this module is required.
// if we are beyond the rollup threshold, we will
// use the rollup module
} else if (r[s[j]] && m.type === smod.type) {
c++;
roll = c >= m.rollup;
if (roll) {
break;
}
}
}
if (roll) {
// add the rollup
r[i] = true;
rolled = true;
// expand the rollup's dependencies
this.getRequires(m);
}
}
}
}
// if we made it here w/o rolling up something, we are done
if (!rolled) {
break;
}
}
};
},
"3.12.0",
{ requires: ["loader-base"] },
);
YUI.add(
"loader-yui3",
function (Y, NAME) {
/* This file is auto-generated by (yogi.js loader --mix --yes) */
/*jshint maxlen:900, eqeqeq: false */
/**
* YUI 3 module metadata
* @module loader
* @submodule loader-yui3
*/
YUI.Env[Y.version].modules = YUI.Env[Y.version].modules || {};
Y.mix(YUI.Env[Y.version].modules, {
"align-plugin": {
requires: ["node-screen", "node-pluginhost"],
},
anim: {
use: [
"anim-base",
"anim-color",
"anim-curve",
"anim-easing",
"anim-node-plugin",
"anim-scroll",
"anim-xy",
],
},
"anim-base": {
requires: ["base-base", "node-style"],
},
"anim-color": {
requires: ["anim-base"],
},
"anim-curve": {
requires: ["anim-xy"],
},
"anim-easing": {
requires: ["anim-base"],
},
"anim-node-plugin": {
requires: ["node-pluginhost", "anim-base"],
},
"anim-scroll": {
requires: ["anim-base"],
},
"anim-shape": {
requires: ["anim-base", "anim-easing", "anim-color", "matrix"],
},
"anim-shape-transform": {
use: ["anim-shape"],
},
"anim-xy": {
requires: ["anim-base", "node-screen"],
},
app: {
use: [
"app-base",
"app-content",
"app-transitions",
"lazy-model-list",
"model",
"model-list",
"model-sync-rest",
"router",
"view",
"view-node-map",
],
},
"app-base": {
requires: ["classnamemanager", "pjax-base", "router", "view"],
},
"app-content": {
requires: ["app-base", "pjax-content"],
},
"app-transitions": {
requires: ["app-base"],
},
"app-transitions-css": {
type: "css",
},
"app-transitions-native": {
condition: {
name: "app-transitions-native",
test: function (Y) {
var doc = Y.config.doc,
node = doc ? doc.documentElement : null;
if (node && node.style) {
return (
"MozTransition" in node.style ||
"WebkitTransition" in node.style ||
"transition" in node.style
);
}
return false;
},
trigger: "app-transitions",
},
requires: [
"app-transitions",
"app-transitions-css",
"parallel",
"transition",
],
},
"array-extras": {
requires: ["yui-base"],
},
"array-invoke": {
requires: ["yui-base"],
},
arraylist: {
requires: ["yui-base"],
},
"arraylist-add": {
requires: ["arraylist"],
},
"arraylist-filter": {
requires: ["arraylist"],
},
arraysort: {
requires: ["yui-base"],
},
"async-queue": {
requires: ["event-custom"],
},
attribute: {
use: ["attribute-base", "attribute-complex"],
},
"attribute-base": {
requires: [
"attribute-core",
"attribute-observable",
"attribute-extras",
],
},
"attribute-complex": {
requires: ["attribute-base"],
},
"attribute-core": {
requires: ["oop"],
},
"attribute-events": {
use: ["attribute-observable"],
},
"attribute-extras": {
requires: ["oop"],
},
"attribute-observable": {
requires: ["event-custom"],
},
autocomplete: {
use: [
"autocomplete-base",
"autocomplete-sources",
"autocomplete-list",
"autocomplete-plugin",
],
},
"autocomplete-base": {
optional: ["autocomplete-sources"],
requires: [
"array-extras",
"base-build",
"escape",
"event-valuechange",
"node-base",
],
},
"autocomplete-filters": {
requires: ["array-extras", "text-wordbreak"],
},
"autocomplete-filters-accentfold": {
requires: ["array-extras", "text-accentfold", "text-wordbreak"],
},
"autocomplete-highlighters": {
requires: ["array-extras", "highlight-base"],
},
"autocomplete-highlighters-accentfold": {
requires: ["array-extras", "highlight-accentfold"],
},
"autocomplete-list": {
after: ["autocomplete-sources"],
lang: ["en", "es", "hu", "it"],
requires: [
"autocomplete-base",
"event-resize",
"node-screen",
"selector-css3",
"shim-plugin",
"widget",
"widget-position",
"widget-position-align",
],
skinnable: true,
},
"autocomplete-list-keys": {
condition: {
name: "autocomplete-list-keys",
test: function (Y) {
// Only add keyboard support to autocomplete-list if this doesn't appear to
// be an iOS or Android-based mobile device.
//
// There's currently no feasible way to actually detect whether a device has
// a hardware keyboard, so this sniff will have to do. It can easily be
// overridden by manually loading the autocomplete-list-keys module.
//
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
// doesn't fire the keyboard events used by AutoCompleteList, so there's
// no point loading the -keys module even when a bluetooth keyboard may be
// available.
return !(Y.UA.ios || Y.UA.android);
},
trigger: "autocomplete-list",
},
requires: ["autocomplete-list", "base-build"],
},
"autocomplete-plugin": {
requires: ["autocomplete-list", "node-pluginhost"],
},
"autocomplete-sources": {
optional: ["io-base", "json-parse", "jsonp", "yql"],
requires: ["autocomplete-base"],
},
axes: {
use: ["axis-numeric", "axis-category", "axis-time", "axis-stacked"],
},
"axes-base": {
use: [
"axis-numeric-base",
"axis-category-base",
"axis-time-base",
"axis-stacked-base",
],
},
axis: {
requires: [
"dom",
"widget",
"widget-position",
"widget-stack",
"graphics",
"axis-base",
],
},
"axis-base": {
requires: [
"classnamemanager",
"datatype-number",
"datatype-date",
"base",
"event-custom",
],
},
"axis-category": {
requires: ["axis", "axis-category-base"],
},
"axis-category-base": {
requires: ["axis-base"],
},
"axis-numeric": {
requires: ["axis", "axis-numeric-base"],
},
"axis-numeric-base": {
requires: ["axis-base"],
},
"axis-stacked": {
requires: ["axis-numeric", "axis-stacked-base"],
},
"axis-stacked-base": {
requires: ["axis-numeric-base"],
},
"axis-time": {
requires: ["axis", "axis-time-base"],
},
"axis-time-base": {
requires: ["axis-base"],
},
base: {
use: ["base-base", "base-pluginhost", "base-build"],
},
"base-base": {
requires: ["attribute-base", "base-core", "base-observable"],
},
"base-build": {
requires: ["base-base"],
},
"base-core": {
requires: ["attribute-core"],
},
"base-observable": {
requires: ["attribute-observable"],
},
"base-pluginhost": {
requires: ["base-base", "pluginhost"],
},
button: {
requires: ["button-core", "cssbutton", "widget"],
},
"button-core": {
requires: ["attribute-core", "classnamemanager", "node-base"],
},
"button-group": {
requires: ["button-plugin", "cssbutton", "widget"],
},
"button-plugin": {
requires: ["button-core", "cssbutton", "node-pluginhost"],
},
cache: {
use: ["cache-base", "cache-offline", "cache-plugin"],
},
"cache-base": {
requires: ["base"],
},
"cache-offline": {
requires: ["cache-base", "json"],
},
"cache-plugin": {
requires: ["plugin", "cache-base"],
},
calendar: {
requires: ["calendar-base", "calendarnavigator"],
skinnable: true,
},
"calendar-base": {
lang: [
"de",
"en",
"es",
"es-AR",
"fr",
"hu",
"it",
"ja",
"nb-NO",
"nl",
"pt-BR",
"ru",
"zh-Hans",
"zh-Hans-CN",
"zh-Hant",
"zh-Hant-HK",
"zh-HANT-TW",
],
requires: ["widget", "datatype-date", "datatype-date-math", "cssgrids"],
skinnable: true,
},
calendarnavigator: {
requires: ["plugin", "classnamemanager", "datatype-date", "node"],
skinnable: true,
},
charts: {
use: ["charts-base"],
},
"charts-base": {
requires: [
"dom",
"event-mouseenter",
"event-touch",
"graphics-group",
"axes",
"series-pie",
"series-line",
"series-marker",
"series-area",
"series-spline",
"series-column",
"series-bar",
"series-areaspline",
"series-combo",
"series-combospline",
"series-line-stacked",
"series-marker-stacked",
"series-area-stacked",
"series-spline-stacked",
"series-column-stacked",
"series-bar-stacked",
"series-areaspline-stacked",
"series-combo-stacked",
"series-combospline-stacked",
],
},
"charts-legend": {
requires: ["charts-base"],
},
classnamemanager: {
requires: ["yui-base"],
},
"clickable-rail": {
requires: ["slider-base"],
},
collection: {
use: [
"array-extras",
"arraylist",
"arraylist-add",
"arraylist-filter",
"array-invoke",
],
},
color: {
use: ["color-base", "color-hsl", "color-harmony"],
},
"color-base": {
requires: ["yui-base"],
},
"color-harmony": {
requires: ["color-hsl"],
},
"color-hsl": {
requires: ["color-base"],
},
"color-hsv": {
requires: ["color-base"],
},
console: {
lang: ["en", "es", "hu", "it", "ja"],
requires: ["yui-log", "widget"],
skinnable: true,
},
"console-filters": {
requires: ["plugin", "console"],
skinnable: true,
},
controller: {
use: ["router"],
},
cookie: {
requires: ["yui-base"],
},
"createlink-base": {
requires: ["editor-base"],
},
cssbase: {
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssreset-context",
"cssfonts-context",
"cssgrids-context",
],
type: "css",
},
"cssbase-context": {
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssreset-context",
"cssfonts-context",
"cssgrids-context",
],
type: "css",
},
cssbutton: {
type: "css",
},
cssfonts: {
type: "css",
},
"cssfonts-context": {
type: "css",
},
cssgrids: {
optional: ["cssnormalize"],
type: "css",
},
"cssgrids-base": {
optional: ["cssnormalize"],
type: "css",
},
"cssgrids-responsive": {
optional: ["cssnormalize"],
requires: ["cssgrids", "cssgrids-responsive-base"],
type: "css",
},
"cssgrids-units": {
optional: ["cssnormalize"],
requires: ["cssgrids-base"],
type: "css",
},
cssnormalize: {
type: "css",
},
"cssnormalize-context": {
type: "css",
},
cssreset: {
type: "css",
},
"cssreset-context": {
type: "css",
},
dataschema: {
use: [
"dataschema-base",
"dataschema-json",
"dataschema-xml",
"dataschema-array",
"dataschema-text",
],
},
"dataschema-array": {
requires: ["dataschema-base"],
},
"dataschema-base": {
requires: ["base"],
},
"dataschema-json": {
requires: ["dataschema-base", "json"],
},
"dataschema-text": {
requires: ["dataschema-base"],
},
"dataschema-xml": {
requires: ["dataschema-base"],
},
datasource: {
use: [
"datasource-local",
"datasource-io",
"datasource-get",
"datasource-function",
"datasource-cache",
"datasource-jsonschema",
"datasource-xmlschema",
"datasource-arrayschema",
"datasource-textschema",
"datasource-polling",
],
},
"datasource-arrayschema": {
requires: ["datasource-local", "plugin", "dataschema-array"],
},
"datasource-cache": {
requires: ["datasource-local", "plugin", "cache-base"],
},
"datasource-function": {
requires: ["datasource-local"],
},
"datasource-get": {
requires: ["datasource-local", "get"],
},
"datasource-io": {
requires: ["datasource-local", "io-base"],
},
"datasource-jsonschema": {
requires: ["datasource-local", "plugin", "dataschema-json"],
},
"datasource-local": {
requires: ["base"],
},
"datasource-polling": {
requires: ["datasource-local"],
},
"datasource-textschema": {
requires: ["datasource-local", "plugin", "dataschema-text"],
},
"datasource-xmlschema": {
requires: [
"datasource-local",
"plugin",
"datatype-xml",
"dataschema-xml",
],
},
datatable: {
use: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"datatable-base",
"datatable-column-widths",
"datatable-message",
"datatable-mutable",
"datatable-sort",
"datatable-datasource",
],
},
"datatable-base": {
requires: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"base-build",
"widget",
],
skinnable: true,
},
"datatable-body": {
requires: ["datatable-core", "view", "classnamemanager"],
},
"datatable-column-widths": {
requires: ["datatable-base"],
},
"datatable-core": {
requires: ["escape", "model-list", "node-event-delegate"],
},
"datatable-datasource": {
requires: ["datatable-base", "plugin", "datasource-local"],
},
"datatable-foot": {
requires: ["datatable-core", "view"],
},
"datatable-formatters": {
requires: [
"datatable-body",
"datatype-number-format",
"datatype-date-format",
"escape",
],
},
"datatable-head": {
requires: ["datatable-core", "view", "classnamemanager"],
},
"datatable-message": {
lang: ["en", "fr", "es", "hu", "it"],
requires: ["datatable-base"],
skinnable: true,
},
"datatable-mutable": {
requires: ["datatable-base"],
},
"datatable-paginator": {
lang: ["en"],
requires: [
"model",
"view",
"paginator-core",
"datatable-foot",
"datatable-paginator-templates",
],
skinnable: true,
},
"datatable-paginator-templates": {
requires: ["template"],
},
"datatable-scroll": {
requires: ["datatable-base", "datatable-column-widths", "dom-screen"],
skinnable: true,
},
"datatable-sort": {
lang: ["en", "fr", "es", "hu"],
requires: ["datatable-base"],
skinnable: true,
},
"datatable-table": {
requires: [
"datatable-core",
"datatable-head",
"datatable-body",
"view",
"classnamemanager",
],
},
datatype: {
use: ["datatype-date", "datatype-number", "datatype-xml"],
},
"datatype-date": {
use: [
"datatype-date-parse",
"datatype-date-format",
"datatype-date-math",
],
},
"datatype-date-format": {
lang: [
"ar",
"ar-JO",
"ca",
"ca-ES",
"da",
"da-DK",
"de",
"de-AT",
"de-DE",
"el",
"el-GR",
"en",
"en-AU",
"en-CA",
"en-GB",
"en-IE",
"en-IN",
"en-JO",
"en-MY",
"en-NZ",
"en-PH",
"en-SG",
"en-US",
"es",
"es-AR",
"es-BO",
"es-CL",
"es-CO",
"es-EC",
"es-ES",
"es-MX",
"es-PE",
"es-PY",
"es-US",
"es-UY",
"es-VE",
"fi",
"fi-FI",
"fr",
"fr-BE",
"fr-CA",
"fr-FR",
"hi",
"hi-IN",
"hu",
"id",
"id-ID",
"it",
"it-IT",
"ja",
"ja-JP",
"ko",
"ko-KR",
"ms",
"ms-MY",
"nb",
"nb-NO",
"nl",
"nl-BE",
"nl-NL",
"pl",
"pl-PL",
"pt",
"pt-BR",
"ro",
"ro-RO",
"ru",
"ru-RU",
"sv",
"sv-SE",
"th",
"th-TH",
"tr",
"tr-TR",
"vi",
"vi-VN",
"zh-Hans",
"zh-Hans-CN",
"zh-Hant",
"zh-Hant-HK",
"zh-Hant-TW",
],
},
"datatype-date-math": {
requires: ["yui-base"],
},
"datatype-date-parse": {},
"datatype-number": {
use: ["datatype-number-parse", "datatype-number-format"],
},
"datatype-number-format": {},
"datatype-number-parse": {},
"datatype-xml": {
use: ["datatype-xml-parse", "datatype-xml-format"],
},
"datatype-xml-format": {},
"datatype-xml-parse": {},
dd: {
use: [
"dd-ddm-base",
"dd-ddm",
"dd-ddm-drop",
"dd-drag",
"dd-proxy",
"dd-constrain",
"dd-drop",
"dd-scroll",
"dd-delegate",
],
},
"dd-constrain": {
requires: ["dd-drag"],
},
"dd-ddm": {
requires: ["dd-ddm-base", "event-resize"],
},
"dd-ddm-base": {
requires: ["node", "base", "yui-throttle", "classnamemanager"],
},
"dd-ddm-drop": {
requires: ["dd-ddm"],
},
"dd-delegate": {
requires: ["dd-drag", "dd-drop-plugin", "event-mouseenter"],
},
"dd-drag": {
requires: ["dd-ddm-base"],
},
"dd-drop": {
requires: ["dd-drag", "dd-ddm-drop"],
},
"dd-drop-plugin": {
requires: ["dd-drop"],
},
"dd-gestures": {
condition: {
name: "dd-gestures",
trigger: "dd-drag",
ua: "touchEnabled",
},
requires: ["dd-drag", "event-synthetic", "event-gestures"],
},
"dd-plugin": {
optional: ["dd-constrain", "dd-proxy"],
requires: ["dd-drag"],
},
"dd-proxy": {
requires: ["dd-drag"],
},
"dd-scroll": {
requires: ["dd-drag"],
},
dial: {
lang: ["en", "es", "hu"],
requires: [
"widget",
"dd-drag",
"event-mouseenter",
"event-move",
"event-key",
"transition",
"intl",
],
skinnable: true,
},
dom: {
use: [
"dom-base",
"dom-screen",
"dom-style",
"selector-native",
"selector",
],
},
"dom-base": {
requires: ["dom-core"],
},
"dom-core": {
requires: ["oop", "features"],
},
"dom-deprecated": {
requires: ["dom-base"],
},
"dom-screen": {
requires: ["dom-base", "dom-style"],
},
"dom-style": {
requires: ["dom-base", "color-base"],
},
"dom-style-ie": {
condition: {
name: "dom-style-ie",
test: function (Y) {
var testFeature = Y.Features.test,
addFeature = Y.Features.add,
WINDOW = Y.config.win,
DOCUMENT = Y.config.doc,
DOCUMENT_ELEMENT = "documentElement",
ret = false;
addFeature("style", "computedStyle", {
test: function () {
return WINDOW && "getComputedStyle" in WINDOW;
},
});
addFeature("style", "opacity", {
test: function () {
return (
DOCUMENT && "opacity" in DOCUMENT[DOCUMENT_ELEMENT].style
);
},
});
ret =
!testFeature("style", "opacity") &&
!testFeature("style", "computedStyle");
return ret;
},
trigger: "dom-style",
},
requires: ["dom-style"],
},
dump: {
requires: ["yui-base"],
},
editor: {
use: [
"frame",
"editor-selection",
"exec-command",
"editor-base",
"editor-para",
"editor-br",
"editor-bidi",
"editor-tab",
"createlink-base",
],
},
"editor-base": {
requires: ["base", "frame", "node", "exec-command", "editor-selection"],
},
"editor-bidi": {
requires: ["editor-base"],
},
"editor-br": {
requires: ["editor-base"],
},
"editor-lists": {
requires: ["editor-base"],
},
"editor-para": {
requires: ["editor-para-base"],
},
"editor-para-base": {
requires: ["editor-base"],
},
"editor-para-ie": {
condition: {
name: "editor-para-ie",
trigger: "editor-para",
ua: "ie",
when: "instead",
},
requires: ["editor-para-base"],
},
"editor-selection": {
requires: ["node"],
},
"editor-tab": {
requires: ["editor-base"],
},
escape: {
requires: ["yui-base"],
},
event: {
after: ["node-base"],
use: [
"event-base",
"event-delegate",
"event-synthetic",
"event-mousewheel",
"event-mouseenter",
"event-key",
"event-focus",
"event-resize",
"event-hover",
"event-outside",
"event-touch",
"event-move",
"event-flick",
"event-valuechange",
"event-tap",
],
},
"event-base": {
after: ["node-base"],
requires: ["event-custom-base"],
},
"event-base-ie": {
after: ["event-base"],
condition: {
name: "event-base-ie",
test: function (Y) {
var imp = Y.config.doc && Y.config.doc.implementation;
return imp && !imp.hasFeature("Events", "2.0");
},
trigger: "node-base",
},
requires: ["node-base"],
},
"event-contextmenu": {
requires: ["event-synthetic", "dom-screen"],
},
"event-custom": {
use: ["event-custom-base", "event-custom-complex"],
},
"event-custom-base": {
requires: ["oop"],
},
"event-custom-complex": {
requires: ["event-custom-base"],
},
"event-delegate": {
requires: ["node-base"],
},
"event-flick": {
requires: ["node-base", "event-touch", "event-synthetic"],
},
"event-focus": {
requires: ["event-synthetic"],
},
"event-gestures": {
use: ["event-flick", "event-move"],
},
"event-hover": {
requires: ["event-mouseenter"],
},
"event-key": {
requires: ["event-synthetic"],
},
"event-mouseenter": {
requires: ["event-synthetic"],
},
"event-mousewheel": {
requires: ["node-base"],
},
"event-move": {
requires: ["node-base", "event-touch", "event-synthetic"],
},
"event-outside": {
requires: ["event-synthetic"],
},
"event-resize": {
requires: ["node-base", "event-synthetic"],
},
"event-simulate": {
requires: ["event-base"],
},
"event-synthetic": {
requires: ["node-base", "event-custom-complex"],
},
"event-tap": {
requires: ["node-base", "event-base", "event-touch", "event-synthetic"],
},
"event-touch": {
requires: ["node-base"],
},
"event-valuechange": {
requires: ["event-focus", "event-synthetic"],
},
"exec-command": {
requires: ["frame"],
},
features: {
requires: ["yui-base"],
},
file: {
requires: ["file-flash", "file-html5"],
},
"file-flash": {
requires: ["base"],
},
"file-html5": {
requires: ["base"],
},
frame: {
requires: ["base", "node", "selector-css3", "yui-throttle"],
},
"gesture-simulate": {
requires: ["async-queue", "event-simulate", "node-screen"],
},
get: {
requires: ["yui-base"],
},
graphics: {
requires: [
"node",
"event-custom",
"pluginhost",
"matrix",
"classnamemanager",
],
},
"graphics-canvas": {
condition: {
name: "graphics-canvas",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useCanvas =
Y.config.defaultGraphicEngine &&
Y.config.defaultGraphicEngine == "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return (
(!svg || useCanvas) &&
canvas &&
canvas.getContext &&
canvas.getContext("2d")
);
},
trigger: "graphics",
},
requires: ["graphics"],
},
"graphics-canvas-default": {
condition: {
name: "graphics-canvas-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useCanvas =
Y.config.defaultGraphicEngine &&
Y.config.defaultGraphicEngine == "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return (
(!svg || useCanvas) &&
canvas &&
canvas.getContext &&
canvas.getContext("2d")
);
},
trigger: "graphics",
},
},
"graphics-group": {
requires: ["graphics"],
},
"graphics-svg": {
condition: {
name: "graphics-svg",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useSVG =
!Y.config.defaultGraphicEngine ||
Y.config.defaultGraphicEngine != "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return svg && (useSVG || !canvas);
},
trigger: "graphics",
},
requires: ["graphics"],
},
"graphics-svg-default": {
condition: {
name: "graphics-svg-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
useSVG =
!Y.config.defaultGraphicEngine ||
Y.config.defaultGraphicEngine != "canvas",
canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
svg =
DOCUMENT &&
DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
);
return svg && (useSVG || !canvas);
},
trigger: "graphics",
},
},
"graphics-vml": {
condition: {
name: "graphics-vml",
test: function (Y) {
var DOCUMENT = Y.config.doc,
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (
DOCUMENT &&
!DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
) &&
(!canvas || !canvas.getContext || !canvas.getContext("2d"))
);
},
trigger: "graphics",
},
requires: ["graphics"],
},
"graphics-vml-default": {
condition: {
name: "graphics-vml-default",
test: function (Y) {
var DOCUMENT = Y.config.doc,
canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (
DOCUMENT &&
!DOCUMENT.implementation.hasFeature(
"http://www.w3.org/TR/SVG11/feature#BasicStructure",
"1.1",
) &&
(!canvas || !canvas.getContext || !canvas.getContext("2d"))
);
},
trigger: "graphics",
},
},
handlebars: {
use: ["handlebars-compiler"],
},
"handlebars-base": {
requires: [],
},
"handlebars-compiler": {
requires: ["handlebars-base"],
},
highlight: {
use: ["highlight-base", "highlight-accentfold"],
},
"highlight-accentfold": {
requires: ["highlight-base", "text-accentfold"],
},
"highlight-base": {
requires: [
"array-extras",
"classnamemanager",
"escape",
"text-wordbreak",
],
},
history: {
use: [
"history-base",
"history-hash",
"history-hash-ie",
"history-html5",
],
},
"history-base": {
requires: ["event-custom-complex"],
},
"history-hash": {
after: ["history-html5"],
requires: ["event-synthetic", "history-base", "yui-later"],
},
"history-hash-ie": {
condition: {
name: "history-hash-ie",
test: function (Y) {
var docMode = Y.config.doc && Y.config.doc.documentMode;
return (
Y.UA.ie &&
(!("onhashchange" in Y.config.win) || !docMode || docMode < 8)
);
},
trigger: "history-hash",
},
requires: ["history-hash", "node-base"],
},
"history-html5": {
optional: ["json"],
requires: ["event-base", "history-base", "node-base"],
},
imageloader: {
requires: ["base-base", "node-style", "node-screen"],
},
intl: {
requires: ["intl-base", "event-custom"],
},
"intl-base": {
requires: ["yui-base"],
},
io: {
use: ["io-base", "io-xdr", "io-form", "io-upload-iframe", "io-queue"],
},
"io-base": {
requires: ["event-custom-base", "querystring-stringify-simple"],
},
"io-form": {
requires: ["io-base", "node-base"],
},
"io-nodejs": {
condition: {
name: "io-nodejs",
trigger: "io-base",
ua: "nodejs",
},
requires: ["io-base"],
},
"io-queue": {
requires: ["io-base", "queue-promote"],
},
"io-upload-iframe": {
requires: ["io-base", "node-base"],
},
"io-xdr": {
requires: ["io-base", "datatype-xml-parse"],
},
json: {
use: ["json-parse", "json-stringify"],
},
"json-parse": {
requires: ["yui-base"],
},
"json-parse-shim": {
condition: {
name: "json-parse-shim",
test: function (Y) {
var _JSON = Y.config.global.JSON,
Native =
Object.prototype.toString.call(_JSON) === "[object JSON]" &&
_JSON,
nativeSupport = Y.config.useNativeJSONParse !== false && !!Native;
function workingNative(k, v) {
return k === "ok" ? true : v;
}
// Double check basic functionality. This is mainly to catch early broken
// implementations of the JSON API in Firefox 3.1 beta1 and beta2
if (nativeSupport) {
try {
nativeSupport = Native.parse('{"ok":false}', workingNative).ok;
} catch (e) {
nativeSupport = false;
}
}
return !nativeSupport;
},
trigger: "json-parse",
},
requires: ["json-parse"],
},
"json-stringify": {
requires: ["yui-base"],
},
"json-stringify-shim": {
condition: {
name: "json-stringify-shim",
test: function (Y) {
var _JSON = Y.config.global.JSON,
Native =
Object.prototype.toString.call(_JSON) === "[object JSON]" &&
_JSON,
nativeSupport =
Y.config.useNativeJSONStringify !== false && !!Native;
// Double check basic native functionality. This is primarily to catch broken
// early JSON API implementations in Firefox 3.1 beta1 and beta2.
if (nativeSupport) {
try {
nativeSupport = "0" === Native.stringify(0);
} catch (e) {
nativeSupport = false;
}
}
return !nativeSupport;
},
trigger: "json-stringify",
},
requires: ["json-stringify"],
},
jsonp: {
requires: ["get", "oop"],
},
"jsonp-url": {
requires: ["jsonp"],
},
"lazy-model-list": {
requires: ["model-list"],
},
loader: {
use: ["loader-base", "loader-rollup", "loader-yui3"],
},
"loader-base": {
requires: ["get", "features"],
},
"loader-rollup": {
requires: ["loader-base"],
},
"loader-yui3": {
requires: ["loader-base"],
},
matrix: {
requires: ["yui-base"],
},
model: {
requires: ["base-build", "escape", "json-parse"],
},
"model-list": {
requires: [
"array-extras",
"array-invoke",
"arraylist",
"base-build",
"escape",
"json-parse",
"model",
],
},
"model-sync-rest": {
requires: ["model", "io-base", "json-stringify"],
},
node: {
use: [
"node-base",
"node-event-delegate",
"node-pluginhost",
"node-screen",
"node-style",
],
},
"node-base": {
requires: ["event-base", "node-core", "dom-base", "dom-style"],
},
"node-core": {
requires: ["dom-core", "selector"],
},
"node-deprecated": {
requires: ["node-base"],
},
"node-event-delegate": {
requires: ["node-base", "event-delegate"],
},
"node-event-html5": {
requires: ["node-base"],
},
"node-event-simulate": {
requires: ["node-base", "event-simulate", "gesture-simulate"],
},
"node-flick": {
requires: ["classnamemanager", "transition", "event-flick", "plugin"],
skinnable: true,
},
"node-focusmanager": {
requires: [
"attribute",
"node",
"plugin",
"node-event-simulate",
"event-key",
"event-focus",
],
},
"node-load": {
requires: ["node-base", "io-base"],
},
"node-menunav": {
requires: ["node", "classnamemanager", "plugin", "node-focusmanager"],
skinnable: true,
},
"node-pluginhost": {
requires: ["node-base", "pluginhost"],
},
"node-screen": {
requires: ["dom-screen", "node-base"],
},
"node-scroll-info": {
requires: [
"array-extras",
"base-build",
"event-resize",
"node-pluginhost",
"plugin",
"selector",
],
},
"node-style": {
requires: ["dom-style", "node-base"],
},
oop: {
requires: ["yui-base"],
},
overlay: {
requires: [
"widget",
"widget-stdmod",
"widget-position",
"widget-position-align",
"widget-stack",
"widget-position-constrain",
],
skinnable: true,
},
paginator: {
requires: ["paginator-core"],
},
"paginator-core": {
requires: ["base"],
},
"paginator-url": {
requires: ["paginator"],
},
panel: {
requires: [
"widget",
"widget-autohide",
"widget-buttons",
"widget-modality",
"widget-position",
"widget-position-align",
"widget-position-constrain",
"widget-stack",
"widget-stdmod",
],
skinnable: true,
},
parallel: {
requires: ["yui-base"],
},
pjax: {
requires: ["pjax-base", "pjax-content"],
},
"pjax-base": {
requires: ["classnamemanager", "node-event-delegate", "router"],
},
"pjax-content": {
requires: ["io-base", "node-base", "router"],
},
"pjax-plugin": {
requires: ["node-pluginhost", "pjax", "plugin"],
},
plugin: {
requires: ["base-base"],
},
pluginhost: {
use: ["pluginhost-base", "pluginhost-config"],
},
"pluginhost-base": {
requires: ["yui-base"],
},
"pluginhost-config": {
requires: ["pluginhost-base"],
},
promise: {
requires: ["timers"],
},
querystring: {
use: ["querystring-parse", "querystring-stringify"],
},
"querystring-parse": {
requires: ["yui-base", "array-extras"],
},
"querystring-parse-simple": {
requires: ["yui-base"],
},
"querystring-stringify": {
requires: ["yui-base"],
},
"querystring-stringify-simple": {
requires: ["yui-base"],
},
"queue-promote": {
requires: ["yui-base"],
},
"range-slider": {
requires: ["slider-base", "slider-value-range", "clickable-rail"],
},
recordset: {
use: [
"recordset-base",
"recordset-sort",
"recordset-filter",
"recordset-indexer",
],
},
"recordset-base": {
requires: ["base", "arraylist"],
},
"recordset-filter": {
requires: ["recordset-base", "array-extras", "plugin"],
},
"recordset-indexer": {
requires: ["recordset-base", "plugin"],
},
"recordset-sort": {
requires: ["arraysort", "recordset-base", "plugin"],
},
resize: {
use: ["resize-base", "resize-proxy", "resize-constrain"],
},
"resize-base": {
requires: [
"base",
"widget",
"event",
"oop",
"dd-drag",
"dd-delegate",
"dd-drop",
],
skinnable: true,
},
"resize-constrain": {
requires: ["plugin", "resize-base"],
},
"resize-plugin": {
optional: ["resize-constrain"],
requires: ["resize-base", "plugin"],
},
"resize-proxy": {
requires: ["plugin", "resize-base"],
},
router: {
optional: ["querystring-parse"],
requires: ["array-extras", "base-build", "history"],
},
scrollview: {
requires: ["scrollview-base", "scrollview-scrollbars"],
},
"scrollview-base": {
requires: [
"widget",
"event-gestures",
"event-mousewheel",
"transition",
],
skinnable: true,
},
"scrollview-base-ie": {
condition: {
name: "scrollview-base-ie",
trigger: "scrollview-base",
ua: "ie",
},
requires: ["scrollview-base"],
},
"scrollview-list": {
requires: ["plugin", "classnamemanager"],
skinnable: true,
},
"scrollview-paginator": {
requires: ["plugin", "classnamemanager"],
},
"scrollview-scrollbars": {
requires: ["classnamemanager", "transition", "plugin"],
skinnable: true,
},
selector: {
requires: ["selector-native"],
},
"selector-css2": {
condition: {
name: "selector-css2",
test: function (Y) {
var DOCUMENT = Y.config.doc,
ret = DOCUMENT && !("querySelectorAll" in DOCUMENT);
return ret;
},
trigger: "selector",
},
requires: ["selector-native"],
},
"selector-css3": {
requires: ["selector-native", "selector-css2"],
},
"selector-native": {
requires: ["dom-base"],
},
"series-area": {
requires: ["series-cartesian", "series-fill-util"],
},
"series-area-stacked": {
requires: ["series-stacked", "series-area"],
},
"series-areaspline": {
requires: ["series-area", "series-curve-util"],
},
"series-areaspline-stacked": {
requires: ["series-stacked", "series-areaspline"],
},
"series-bar": {
requires: ["series-marker", "series-histogram-base"],
},
"series-bar-stacked": {
requires: ["series-stacked", "series-bar"],
},
"series-base": {
requires: ["graphics", "axis-base"],
},
"series-candlestick": {
requires: ["series-range"],
},
"series-cartesian": {
requires: ["series-base"],
},
"series-column": {
requires: ["series-marker", "series-histogram-base"],
},
"series-column-stacked": {
requires: ["series-stacked", "series-column"],
},
"series-combo": {
requires: [
"series-cartesian",
"series-line-util",
"series-plot-util",
"series-fill-util",
],
},
"series-combo-stacked": {
requires: ["series-stacked", "series-combo"],
},
"series-combospline": {
requires: ["series-combo", "series-curve-util"],
},
"series-combospline-stacked": {
requires: ["series-combo-stacked", "series-curve-util"],
},
"series-curve-util": {},
"series-fill-util": {},
"series-histogram-base": {
requires: ["series-cartesian", "series-plot-util"],
},
"series-line": {
requires: ["series-cartesian", "series-line-util"],
},
"series-line-stacked": {
requires: ["series-stacked", "series-line"],
},
"series-line-util": {},
"series-marker": {
requires: ["series-cartesian", "series-plot-util"],
},
"series-marker-stacked": {
requires: ["series-stacked", "series-marker"],
},
"series-ohlc": {
requires: ["series-range"],
},
"series-pie": {
requires: ["series-base", "series-plot-util"],
},
"series-plot-util": {},
"series-range": {
requires: ["series-cartesian"],
},
"series-spline": {
requires: ["series-line", "series-curve-util"],
},
"series-spline-stacked": {
requires: ["series-stacked", "series-spline"],
},
"series-stacked": {
requires: ["axis-stacked"],
},
"shim-plugin": {
requires: ["node-style", "node-pluginhost"],
},
slider: {
use: [
"slider-base",
"slider-value-range",
"clickable-rail",
"range-slider",
],
},
"slider-base": {
requires: ["widget", "dd-constrain", "event-key"],
skinnable: true,
},
"slider-value-range": {
requires: ["slider-base"],
},
sortable: {
requires: ["dd-delegate", "dd-drop-plugin", "dd-proxy"],
},
"sortable-scroll": {
requires: ["dd-scroll", "sortable"],
},
stylesheet: {
requires: ["yui-base"],
},
substitute: {
optional: ["dump"],
requires: ["yui-base"],
},
swf: {
requires: ["event-custom", "node", "swfdetect", "escape"],
},
swfdetect: {
requires: ["yui-base"],
},
tabview: {
requires: [
"widget",
"widget-parent",
"widget-child",
"tabview-base",
"node-pluginhost",
"node-focusmanager",
],
skinnable: true,
},
"tabview-base": {
requires: ["node-event-delegate", "classnamemanager"],
},
"tabview-plugin": {
requires: ["tabview-base"],
},
template: {
use: ["template-base", "template-micro"],
},
"template-base": {
requires: ["yui-base"],
},
"template-micro": {
requires: ["escape"],
},
test: {
requires: ["event-simulate", "event-custom", "json-stringify"],
},
"test-console": {
requires: ["console-filters", "test", "array-extras"],
skinnable: true,
},
text: {
use: ["text-accentfold", "text-wordbreak"],
},
"text-accentfold": {
requires: ["array-extras", "text-data-accentfold"],
},
"text-data-accentfold": {
requires: ["yui-base"],
},
"text-data-wordbreak": {
requires: ["yui-base"],
},
"text-wordbreak": {
requires: ["array-extras", "text-data-wordbreak"],
},
timers: {
requires: ["yui-base"],
},
transition: {
requires: ["node-style"],
},
"transition-timer": {
condition: {
name: "transition-timer",
test: function (Y) {
var DOCUMENT = Y.config.doc,
node = DOCUMENT ? DOCUMENT.documentElement : null,
ret = true;
if (node && node.style) {
ret = !(
"MozTransition" in node.style ||
"WebkitTransition" in node.style ||
"transition" in node.style
);
}
return ret;
},
trigger: "transition",
},
requires: ["transition"],
},
tree: {
requires: ["base-build", "tree-node"],
},
"tree-labelable": {
requires: ["tree"],
},
"tree-lazy": {
requires: ["base-pluginhost", "plugin", "tree"],
},
"tree-node": {},
"tree-openable": {
requires: ["tree"],
},
"tree-selectable": {
requires: ["tree"],
},
"tree-sortable": {
requires: ["tree"],
},
uploader: {
requires: ["uploader-html5", "uploader-flash"],
},
"uploader-flash": {
requires: [
"swf",
"widget",
"base",
"cssbutton",
"node",
"event-custom",
"file-flash",
"uploader-queue",
],
},
"uploader-html5": {
requires: [
"widget",
"node-event-simulate",
"file-html5",
"uploader-queue",
],
},
"uploader-queue": {
requires: ["base"],
},
view: {
requires: ["base-build", "node-event-delegate"],
},
"view-node-map": {
requires: ["view"],
},
widget: {
use: [
"widget-base",
"widget-htmlparser",
"widget-skin",
"widget-uievents",
],
},
"widget-anim": {
requires: ["anim-base", "plugin", "widget"],
},
"widget-autohide": {
requires: ["base-build", "event-key", "event-outside", "widget"],
},
"widget-base": {
requires: [
"attribute",
"base-base",
"base-pluginhost",
"classnamemanager",
"event-focus",
"node-base",
"node-style",
],
skinnable: true,
},
"widget-base-ie": {
condition: {
name: "widget-base-ie",
trigger: "widget-base",
ua: "ie",
},
requires: ["widget-base"],
},
"widget-buttons": {
requires: ["button-plugin", "cssbutton", "widget-stdmod"],
},
"widget-child": {
requires: ["base-build", "widget"],
},
"widget-htmlparser": {
requires: ["widget-base"],
},
"widget-locale": {
requires: ["widget-base"],
},
"widget-modality": {
requires: ["base-build", "event-outside", "widget"],
skinnable: true,
},
"widget-parent": {
requires: ["arraylist", "base-build", "widget"],
},
"widget-position": {
requires: ["base-build", "node-screen", "widget"],
},
"widget-position-align": {
requires: ["widget-position"],
},
"widget-position-constrain": {
requires: ["widget-position"],
},
"widget-skin": {
requires: ["widget-base"],
},
"widget-stack": {
requires: ["base-build", "widget"],
skinnable: true,
},
"widget-stdmod": {
requires: ["base-build", "widget"],
},
"widget-uievents": {
requires: ["node-event-delegate", "widget-base"],
},
yql: {
requires: ["oop"],
},
"yql-jsonp": {
condition: {
name: "yql-jsonp",
test: function (Y) {
/* Only load the JSONP module when not in nodejs or winjs
TODO Make the winjs module a CORS module
*/
return !Y.UA.nodejs && !Y.UA.winjs;
},
trigger: "yql",
when: "after",
},
requires: ["jsonp", "jsonp-url"],
},
"yql-nodejs": {
condition: {
name: "yql-nodejs",
trigger: "yql",
ua: "nodejs",
when: "after",
},
},
"yql-winjs": {
condition: {
name: "yql-winjs",
trigger: "yql",
ua: "winjs",
when: "after",
},
},
yui: {},
"yui-base": {},
"yui-later": {
requires: ["yui-base"],
},
"yui-log": {
requires: ["yui-base"],
},
"yui-throttle": {
requires: ["yui-base"],
},
});
YUI.Env[Y.version].md5 = "fd7c67956df50e445f40d1668dd1dc80";
},
"3.12.0",
{ requires: ["loader-base"] },
);
YUI.add("yui", function (Y, NAME) {}, "3.12.0", {
use: [
"yui-base",
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3",
],
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/angular-1.2.5.js | JavaScript | !/**
* @license AngularJS v1.2.5
* (c) 2010-2014 Google, Inc. http://angularjs.org
* License: MIT
*/ function(window1, document1, undefined) {
"use strict";
/**
* @description
*
* This object provides a utility for producing rich Error messages within
* Angular. It can be called as follows:
*
* var exampleMinErr = minErr('example');
* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
*
* The above creates an instance of minErr in the example namespace. The
* resulting error will have a namespaced error code of example.one. The
* resulting error will replace {0} with the value of foo, and {1} with the
* value of bar. The object is not restricted in the number of arguments it can
* take.
*
* If fewer arguments are specified than necessary for interpolation, the extra
* interpolation markers will be preserved in the final string.
*
* Since data will be parsed statically during a build step, some restrictions
* are applied with respect to how minErr instances are created and called.
* Instances should have names of the form namespaceMinErr for a minErr created
* using minErr('namespace') . Error codes, namespaces and template strings
* should all be static strings, not variables or general expressions.
*
* @param {string} module The namespace to use for the new minErr instance.
* @returns {function(string, string, ...): Error} instance
*/ function minErr(module) {
return function() {
var obj, message, i, code = arguments[0], template = arguments[1], templateArgs = arguments;
for(i = 2, message = (message = "[" + (module ? module + ":" : "") + code + "] " + template.replace(/\{\d+\}/g, function(match) {
var arg, index = +match.slice(1, -1);
if (index + 2 < templateArgs.length) return "function" == typeof (arg = templateArgs[index + 2]) ? arg.toString().replace(/ ?\{[\s\S]*$/, "") : void 0 === arg ? "undefined" : "string" != typeof arg ? toJson(arg) : arg;
return match;
})) + "\nhttp://errors.angularjs.org/1.2.5/" + (module ? module + "/" : "") + code; i < arguments.length; i++){
message = message + (2 == i ? "?" : "&") + "p" + (i - 2) + "=" + encodeURIComponent((obj = arguments[i], "function" == typeof obj ? obj.toString().replace(/ \{[\s\S]*$/, "") : void 0 === obj ? "undefined" : "string" != typeof obj ? JSON.stringify(obj) : obj));
}
return Error(message);
};
}
/* We need to tell jshint what variables are being exported */ /* global
-angular,
-msie,
-jqLite,
-jQuery,
-slice,
-push,
-toString,
-ngMinErr,
-_angular,
-angularModule,
-nodeName_,
-uid,
-lowercase,
-uppercase,
-manualLowercase,
-manualUppercase,
-nodeName_,
-isArrayLike,
-forEach,
-sortedKeys,
-forEachSorted,
-reverseParams,
-nextUid,
-setHashKey,
-extend,
-int,
-inherit,
-noop,
-identity,
-valueFn,
-isUndefined,
-isDefined,
-isObject,
-isString,
-isNumber,
-isDate,
-isArray,
-isFunction,
-isRegExp,
-isWindow,
-isScope,
-isFile,
-isBoolean,
-trim,
-isElement,
-makeMap,
-map,
-size,
-includes,
-indexOf,
-arrayRemove,
-isLeafNode,
-copy,
-shallowCopy,
-equals,
-csp,
-concat,
-sliceArgs,
-bind,
-toJsonReplacer,
-toJson,
-fromJson,
-toBoolean,
-startingTag,
-tryDecodeURIComponent,
-parseKeyValue,
-toKeyValue,
-encodeUriSegment,
-encodeUriQuery,
-angularInit,
-bootstrap,
-snake_case,
-bindJQuery,
-assertArg,
-assertArgFn,
-assertNotHasOwnProperty,
-getter,
-getBlockElements,
*/ ////////////////////////////////////
/**
* @ngdoc function
* @name angular.lowercase
* @function
*
* @description Converts the specified string to lowercase.
* @param {string} string String to be converted to lowercase.
* @returns {string} Lowercased string.
*/ var promiseWarning, /** holds major version number for IE or NaN for real browsers */ msie, jqLite, jQuery, angularModule, nodeName_, lowercase = function(string) {
return isString(string) ? string.toLowerCase() : string;
}, uppercase = function(string) {
return isString(string) ? string.toUpperCase() : string;
}, slice = [].slice, push = [].push, toString = Object.prototype.toString, ngMinErr = minErr("ng"), /** @name angular */ angular1 = (window1.angular, window1.angular || (window1.angular = {})), uid = [
"0",
"0",
"0"
];
/**
* @private
* @param {*} obj
* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
* String ...)
*/ 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;
}
/**
* @ngdoc function
* @name angular.forEach
* @function
*
* @description
* Invokes the `iterator` function once for each item in `obj` collection, which can be either an
* object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`
* is the value of an object property or an array element and `key` is the object property key or
* array element index. Specifying a `context` for the function is optional.
*
* Note: this function was previously known as `angular.foreach`.
*
<pre>
var values = {name: 'misko', gender: 'male'};
var log = [];
angular.forEach(values, function(value, key){
this.push(key + ': ' + value);
}, log);
expect(log).toEqual(['name: misko', 'gender:male']);
</pre>
*
* @param {Object|Array} obj Object to iterate over.
* @param {Function} iterator Iterator function.
* @param {Object=} context Object to become context (`this`) for the iterator function.
* @returns {Object|Array} Reference to `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();
}
/**
* when using forEach the params are value, key, but it is often useful to have key, value.
* @param {function(string, *)} iteratorFn
* @returns {function(*, string)}
*/ function reverseParams(iteratorFn) {
return function(value, key) {
iteratorFn(key, value);
};
}
/**
* A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric
* characters such as '012ABC'. The reason why we are not using simply a number counter is that
* the number string gets longer over time, and it can also overflow, where as the nextId
* will grow much slower, it is a string, and it will never overflow.
*
* @returns an unique alpha-numeric string
*/ function nextUid() {
for(var digit, index = uid.length; index;){
if (57 /*'9'*/ == (digit = uid[--index].charCodeAt(0))) return uid[index] = "A", uid.join("");
if (90 /*'Z'*/ != digit) return uid[index] = String.fromCharCode(digit + 1), uid.join("");
uid[index] = "0";
}
return uid.unshift("0"), uid.join("");
}
/**
* Set or clear the hashkey for an object.
* @param obj object
* @param h the hashkey (!truthy to delete the hashkey)
*/ function setHashKey(obj, h) {
h ? obj.$$hashKey = h : delete obj.$$hashKey;
}
/**
* @ngdoc function
* @name angular.extend
* @function
*
* @description
* Extends the destination object `dst` by copying all of the properties from the `src` object(s)
* to `dst`. You can specify multiple `src` objects.
*
* @param {Object} dst Destination object.
* @param {...Object} src Source object(s).
* @returns {Object} Reference to `dst`.
*/ 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);
}
/**
* @ngdoc function
* @name angular.noop
* @function
*
* @description
* A function that performs no operations. This function can be useful when writing code in the
* functional style.
<pre>
function foo(callback) {
var result = calculateResult();
(callback || angular.noop)(result);
}
</pre>
*/ function noop() {}
/**
* @ngdoc function
* @name angular.identity
* @function
*
* @description
* A function that returns its first argument. This function is useful when writing code in the
* functional style.
*
<pre>
function transformer(transformationFn, value) {
return (transformationFn || angular.identity)(value);
};
</pre>
*/ function identity($) {
return $;
}
function valueFn(value) {
return function() {
return value;
};
}
/**
* @ngdoc function
* @name angular.isUndefined
* @function
*
* @description
* Determines if a reference is undefined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is undefined.
*/ function isUndefined(value) {
return void 0 === value;
}
/**
* @ngdoc function
* @name angular.isDefined
* @function
*
* @description
* Determines if a reference is defined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is defined.
*/ function isDefined(value) {
return void 0 !== value;
}
/**
* @ngdoc function
* @name angular.isObject
* @function
*
* @description
* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
* considered to be objects.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Object` but not `null`.
*/ function isObject(value) {
return null != value && "object" == typeof value;
}
/**
* @ngdoc function
* @name angular.isString
* @function
*
* @description
* Determines if a reference is a `String`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `String`.
*/ function isString(value) {
return "string" == typeof value;
}
/**
* @ngdoc function
* @name angular.isNumber
* @function
*
* @description
* Determines if a reference is a `Number`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Number`.
*/ function isNumber(value) {
return "number" == typeof value;
}
/**
* @ngdoc function
* @name angular.isDate
* @function
*
* @description
* Determines if a value is a date.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Date`.
*/ function isDate(value) {
return "[object Date]" === toString.call(value);
}
/**
* @ngdoc function
* @name angular.isArray
* @function
*
* @description
* Determines if a reference is an `Array`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Array`.
*/ function isArray(value) {
return "[object Array]" === toString.call(value);
}
/**
* @ngdoc function
* @name angular.isFunction
* @function
*
* @description
* Determines if a reference is a `Function`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Function`.
*/ function isFunction(value) {
return "function" == typeof value;
}
/**
* Determines if a value is a regular expression object.
*
* @private
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `RegExp`.
*/ function isRegExp(value) {
return "[object RegExp]" === toString.call(value);
}
/**
* Checks if `obj` is a window object.
*
* @private
* @param {*} obj Object to check
* @returns {boolean} True if `obj` is a window obj.
*/ function isWindow(obj) {
return obj && obj.document && obj.location && obj.alert && obj.setInterval;
}
function isScope(obj) {
return obj && obj.$evalAsync && obj.$watch;
}
isNaN(/**
* IE 11 changed the format of the UserAgent string.
* See http://msdn.microsoft.com/en-us/library/ms537503.aspx
*/ msie = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1])) && (msie = int((/trident\/.*; rv:(\d+)/.exec(lowercase(navigator.userAgent)) || [])[1])), noop.$inject = [], identity.$inject = [];
var trim = // native trim is way faster: http://jsperf.com/angular-trim-test
// but IE doesn't have it... :-(
// TODO: we should move this into IE/ES5 polyfill
String.prototype.trim ? function(value) {
return isString(value) ? value.trim() : value;
} : function(value) {
return isString(value) ? value.replace(/^\s\s*/, "").replace(/\s\s*$/, "") : value;
};
/**
* @ngdoc function
* @name angular.isElement
* @function
*
* @description
* Determines if a reference is a DOM element (or wrapped jQuery element).
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
*/ function isElement(node) {
return !!(node && (node.nodeName || // we are a direct element
node.on && node.find)); // we have an on and find method part of jQuery API
}
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;
}
/**
* @ngdoc function
* @name angular.copy
* @function
*
* @description
* Creates a deep copy of `source`, which should be an object or an array.
*
* * If no destination is supplied, a copy of the object or array is created.
* * If a destination is provided, all of its elements (for array) or properties (for objects)
* are deleted and then all elements/properties from the source are copied to it.
* * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
* * If `source` is identical to 'destination' an exception will be thrown.
*
* @param {*} source The source that will be used to make a copy.
* Can be any type, including primitives, `null`, and `undefined`.
* @param {(Object|Array)=} destination Destination into which the source is copied. If
* provided, must be of the same type as `source`.
* @returns {*} The copy or updated `destination`, if `destination` was specified.
*
* @example
<doc:example>
<doc:source>
<div ng-controller="Controller">
<form novalidate class="simple-form">
Name: <input type="text" ng-model="user.name" /><br />
E-mail: <input type="email" ng-model="user.email" /><br />
Gender: <input type="radio" ng-model="user.gender" value="male" />male
<input type="radio" ng-model="user.gender" value="female" />female<br />
<button ng-click="reset()">RESET</button>
<button ng-click="update(user)">SAVE</button>
</form>
<pre>form = {{user | json}}</pre>
<pre>master = {{master | json}}</pre>
</div>
<script>
function Controller($scope) {
$scope.master= {};
$scope.update = function(user) {
// Example with 1 argument
$scope.master= angular.copy(user);
};
$scope.reset = function() {
// Example with 2 arguments
angular.copy($scope.master, $scope.user);
};
$scope.reset();
}
</script>
</doc:source>
</doc:example>
*/ 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;
}
/**
* @ngdoc function
* @name angular.equals
* @function
*
* @description
* Determines if two objects or two values are equivalent. Supports value types, regular
* expressions, arrays and objects.
*
* Two objects or values are considered equivalent if at least one of the following is true:
*
* * Both objects or values pass `===` comparison.
* * Both objects or values are of the same type and all of their properties are equal by
* comparing them with `angular.equals`.
* * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
* * Both values represent the same regular expression (In JavasScript,
* /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
* representation matches).
*
* During a property comparison, properties of `function` type and properties with names
* that begin with `$` are ignored.
*
* Scope and DOMWindow objects are being compared only by identify (`===`).
*
* @param {*} o1 Object or value to compare.
* @param {*} o2 Object or value to compare.
* @returns {boolean} True if arguments are equal.
*/ function equals(o1, o2) {
if (o1 === o2) return !0;
if (null === o1 || null === o2) return !1;
if (o1 != o1 && o2 != o2) return !0; // NaN === NaN
var length, key, keySet, t1 = typeof o1;
if (t1 == typeof o2 && "object" == t1) {
if (isArray(o1)) {
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;
}
} else {
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) && o2[key] !== undefined && !isFunction(o2[key])) return !1;
return !0;
}
}
return !1;
}
function csp() {
return document1.securityPolicy && document1.securityPolicy.isActive || document1.querySelector && !!(document1.querySelector("[ng-csp]") || document1.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);
}
/* jshint -W101 */ /**
* @ngdoc function
* @name angular.bind
* @function
*
* @description
* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
* `fn`). You can supply optional `args` that are prebound to the function. This feature is also
* known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
* distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
*
* @param {Object} self Context which `fn` should be evaluated in.
* @param {function()} fn Function to be bound.
* @param {...*} args Optional arguments to be prebound to the `fn` function call.
* @returns {function()} Function that wraps the `fn` with all the specified bindings.
*/ /* jshint +W101 */ 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 && document1 === value ? val = "$DOCUMENT" : isScope(value) && (val = "$SCOPE"), val;
}
/**
* @ngdoc function
* @name angular.toJson
* @function
*
* @description
* Serializes input into a JSON-formatted string. Properties with leading $ characters will be
* stripped since angular uses this notation internally.
*
* @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
* @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.
* @returns {string|undefined} JSON-ified string representing `obj`.
*/ function toJson(obj, pretty) {
return void 0 === obj ? undefined : JSON.stringify(obj, toJsonReplacer, pretty ? " " : null);
}
/**
* @ngdoc function
* @name angular.fromJson
* @function
*
* @description
* Deserializes a JSON string.
*
* @param {string} json JSON string to deserialize.
* @returns {Object|Array|Date|string|number} Deserialized thingy.
*/ 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;
}
/**
* @returns {string} Returns the string representation of the element.
*/ function startingTag(element) {
element = jqLite(element).clone();
try {
// turns out IE does not let you set .html() on elements which
// are not allowed to have children. So we just ignore it.
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);
}
}
/////////////////////////////////////////////////
/**
* Tries to decode the URI component without throwing an exception.
*
* @private
* @param str value potential URI component to check.
* @returns {boolean} True if `value` can be decoded
* with the decodeURIComponent function.
*/ function tryDecodeURIComponent(value) {
try {
return decodeURIComponent(value);
} catch (e) {
// Ignore any invalid uri component
}
}
/**
* Parses an escaped url query string into key-value pairs.
* @returns Object.<(string|boolean)>
*/ function parseKeyValue(/**string*/ keyValue) {
var key_value, key, obj = {};
return forEach((keyValue || "").split("&"), function(keyValue) {
if (keyValue && isDefined(key = tryDecodeURIComponent((key_value = keyValue.split("="))[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("&") : "";
}
/**
* We need our custom method because encodeURIComponent is too aggressive and doesn't follow
* http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
* segments:
* segment = *pchar
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* pct-encoded = "%" HEXDIG HEXDIG
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/ function encodeUriSegment(val) {
return encodeUriQuery(val, !0).replace(/%26/gi, "&").replace(/%3D/gi, "=").replace(/%2B/gi, "+");
}
/**
* This method is intended for encoding *key* or *value* parts of query component. We need a custom
* method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
* encoded per http://tools.ietf.org/html/rfc3986:
* query = *( pchar / "/" / "?" )
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* pct-encoded = "%" HEXDIG HEXDIG
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/ function encodeUriQuery(val, pctEncodeSpaces) {
return encodeURIComponent(val).replace(/%40/gi, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, pctEncodeSpaces ? "%20" : "+");
}
/**
* @ngdoc function
* @name angular.bootstrap
* @description
* Use this function to manually start up angular application.
*
* See: {@link guide/bootstrap Bootstrap}
*
* Note that ngScenario-based end-to-end tests cannot use this function to bootstrap manually.
* They must use {@link api/ng.directive:ngApp ngApp}.
*
* @param {Element} element DOM element which is the root of angular application.
* @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
* Each item in the array should be the name of a predefined module or a (DI annotated)
* function that will be invoked by the injector as a run block.
* See: {@link angular.module modules}
* @returns {AUTO.$injector} Returns the newly created injector for this app.
*/ function bootstrap(element, modules) {
var doBootstrap = function() {
if ((element = jqLite(element)).injector()) throw ngMinErr("btstrpd", "App Already Bootstrapped with this Element '{0}'", element[0] === document1 ? "document" : startingTag(element));
(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 (window1 && !NG_DEFER_BOOTSTRAP.test(window1.name)) return doBootstrap();
window1.name = window1.name.replace(NG_DEFER_BOOTSTRAP, ""), angular1.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();
});
}
/**
* throw error if the argument is falsy.
*/ 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;
}
/**
* throw error if the name given is hasOwnProperty
* @param {String} name the name to test
* @param {String} context the context in which the name is used, such as module or directive
*/ function assertNotHasOwnProperty(name, context) {
if ("hasOwnProperty" === name) throw ngMinErr("badname", "hasOwnProperty is not a valid {0} name", context);
}
/**
* Return the value accessible from the object by path. Any undefined traversals are ignored
* @param {Object} obj starting object
* @param {string} path path to traverse
* @param {boolean=true} bindFnToScope
* @returns value as accessible by path
*/ //TODO(misko): this function needs to be removed
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;
}
/**
* Return the DOM siblings between the first and last node in the given array.
* @param {Array} array like object
* @returns jQlite object containing the elements
*/ 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);
}
/* global
angularModule: true,
version: true,
$LocaleProvider,
$CompileProvider,
htmlAnchorDirective,
inputDirective,
inputDirective,
formDirective,
scriptDirective,
selectDirective,
styleDirective,
optionDirective,
ngBindDirective,
ngBindHtmlDirective,
ngBindTemplateDirective,
ngClassDirective,
ngClassEvenDirective,
ngClassOddDirective,
ngCspDirective,
ngCloakDirective,
ngControllerDirective,
ngFormDirective,
ngHideDirective,
ngIfDirective,
ngIncludeDirective,
ngIncludeFillContentDirective,
ngInitDirective,
ngNonBindableDirective,
ngPluralizeDirective,
ngRepeatDirective,
ngShowDirective,
ngStyleDirective,
ngSwitchDirective,
ngSwitchWhenDirective,
ngSwitchDefaultDirective,
ngOptionsDirective,
ngTranscludeDirective,
ngModelDirective,
ngListDirective,
ngChangeDirective,
requiredDirective,
requiredDirective,
ngValueDirective,
ngAttributeAliasDirectives,
ngEventDirectives,
$AnchorScrollProvider,
$AnimateProvider,
$BrowserProvider,
$CacheFactoryProvider,
$ControllerProvider,
$DocumentProvider,
$ExceptionHandlerProvider,
$FilterProvider,
$InterpolateProvider,
$IntervalProvider,
$HttpProvider,
$HttpBackendProvider,
$LocationProvider,
$LogProvider,
$ParseProvider,
$RootScopeProvider,
$QProvider,
$$SanitizeUriProvider,
$SceProvider,
$SceDelegateProvider,
$SnifferProvider,
$TemplateCacheProvider,
$TimeoutProvider,
$WindowProvider
*/ /**
* @ngdoc property
* @name angular.version
* @description
* An object that contains information about the current AngularJS version. This object has the
* following properties:
*
* - `full` – `{string}` – Full version string, such as "0.9.18".
* - `major` – `{number}` – Major version number, such as "0".
* - `minor` – `{number}` – Minor version number, such as "9".
* - `dot` – `{number}` – Dot version number, such as "18".
* - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
*/ var version = {
full: "1.2.5",
major: 1,
minor: 2,
dot: 5,
codeName: "singularity-expansion"
}, jqCache = JQLite.cache = {}, jqName = JQLite.expando = "ng-" + new Date().getTime(), jqId = 1, addEventListenerFn = window1.document.addEventListener ? function(element, type, fn) {
element.addEventListener(type, fn, !1);
} : function(element, type, fn) {
element.attachEvent("on" + type, fn);
}, removeEventListenerFn = window1.document.removeEventListener ? function(element, type, fn) {
element.removeEventListener(type, fn, !1);
} : function(element, type, fn) {
element.detachEvent("on" + type, fn);
}, SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g, MOZ_HACK_REGEXP = /^moz([A-Z])/, jqLiteMinErr = minErr("jqLite");
/**
* Converts snake_case to camelCase.
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/ function camelCase(name) {
return name.replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
return offset ? letter.toUpperCase() : letter;
}).replace(MOZ_HACK_REGEXP, "Moz$1");
}
/////////////////////////////////////////////
// jQuery mutation patch
//
// In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a
// $destroy event on all DOM nodes being removed.
//
/////////////////////////////////////////////
function jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments) {
var originalJqFn = jQuery.fn[name];
function removePatch(param) {
// jshint -W040
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);
}
removePatch.$original = originalJqFn = originalJqFn.$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 = document1.createElement("div");
// Read about the NoScope elements here:
// http://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
div.innerHTML = "<div> </div>" + element, div.removeChild(div.firstChild), jqLiteAddNodes(this, div.childNodes), jqLite(document1.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);
})); //no listeners registered
}
function jqLiteRemoveData(element, name) {
var expandoId = element[jqName], expandoStore = jqCache[expandoId];
if (expandoStore) {
if (name) {
delete jqCache[expandoId].data[name];
return;
}
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) // don't create data in this case.
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) {
// if element is the document object work with the html element instead
// this makes $(document).scope() possible
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 ((value = element.data(names[i])) !== undefined) 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);
}
//////////////////////////////////////////
// Functions which are declared directly.
//////////////////////////////////////////
var JQLitePrototype = JQLite.prototype = {
ready: function(fn) {
var fired = !1;
function trigger() {
fired || (fired = !0, fn());
}
// check if document already is loaded
"complete" === document1.readyState ? setTimeout(trigger) : (this.on("DOMContentLoaded", trigger), // we can not use jqLite since we are not done loading and jQuery could be loaded later.
// jshint -W064
JQLite(window1).on("load", trigger));
},
toString: function() {
var value = [];
return forEach(this, function(e) {
value.push("" + e);
}), "[" + value.join(", ") + "]";
},
eq: function(index) {
return index >= 0 ? jqLite(this[index]) : jqLite(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) {
// check dom last since we will most likely fail on name
var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
// booleanAttr is here twice to minimize DOM access
return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;
}
/**
* Computes a hash of an 'obj'.
* Hash of a:
* string is string
* number is number as string
* object is either result of calling $$hashKey function on the object or uniquely generated id,
* that is also assigned to the $$hashKey property of the object.
*
* @param obj
* @returns {string} hash string such that the same input will have the same hash string.
* The resulting string key is in 'type:hashKey' format.
*/ function hashKey(obj) {
var key, objType = typeof obj;
return "object" == objType && null !== obj ? "function" == typeof (key = obj.$$hashKey) ? // must invoke on object to keep the right this
key = obj.$$hashKey() : undefined === key && (key = obj.$$hashKey = nextUid()) : key = obj, objType + ":" + key;
}
/**
* HashMap which can use objects as keys
*/ 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) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
return jqLite(element).data("$scope") || jqLiteInheritedData(element.parentNode || element, [
"$isolateScope",
"$scope"
]);
},
isolateScope: function(element) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
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) {
if (name = camelCase(name), isDefined(value)) element.style[name] = value;
else {
var val;
return msie <= 8 && "" === // this is some IE specific weirdness that jQuery 1.6.4 does not sure why
(val = element.currentStyle && element.currentStyle[name]) && (val = "auto"), val = val || element.style[name], msie <= 8 && // jquery weirdness :-/
(val = "" === val ? undefined : val), val;
}
},
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) {
// the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
// some elements (e.g. Document) don't have get attribute, so return undefined
var ret = element.getAttribute(name, 2);
// normalize non-existing attributes to undefined (as jQuery)
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] = /** Element **/ 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) {
/**
* Properties: writes return selection, reads return first value
*/ JQLite.prototype[name] = function(arg1, arg2) {
var i, key;
// jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
// in a way that survives minification.
// jqLiteEmpty takes no arguments but is a setter.
if (fn !== jqLiteEmpty && (2 == fn.length && fn !== jqLiteHasClass && fn !== jqLiteController ? arg1 : arg2) === undefined) {
if (isObject(arg1)) {
// we are a write, but the object properties are the key/values
for(i = 0; i < this.length; i++)if (fn === jqLiteData) // data() takes the whole object in jQuery
fn(this[i], arg1);
else for(key in arg1)fn(this[i], key, arg1[key]);
// return self for chaining
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;
}
// we are a write, so apply to all children
for(i = 0; i < this.length; i++)fn(this[i], arg1, arg2);
// return self for chaining
return this;
};
}), //////////////////////////////////////////
// Functions iterating traversal.
// These functions chain results into a single
// selector.
//////////////////////////////////////////
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, eventHandler, events1 = jqLiteExpandoStore(element, "events"), handle = jqLiteExpandoStore(element, "handle");
events1 || jqLiteExpandoStore(element, "events", events1 = {}), !handle && jqLiteExpandoStore(element, "handle", (events = events1, (eventHandler = function(event, type) {
if (event.preventDefault || (event.preventDefault = function() {
event.returnValue = !1; //ie
}), event.stopPropagation || (event.stopPropagation = function() {
event.cancelBubble = !0; //ie
}), event.target || (event.target = event.srcElement || document1), 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 ? (// IE7/8 does not allow to delete property on native object
event.preventDefault = null, event.stopPropagation = null, event.isDefaultPrevented = null) : (// It shouldn't affect normal browsers (native methods are defined on prototype).
delete event.preventDefault, delete event.stopPropagation, delete event.isDefaultPrevented);
}).elem = element, handle = eventHandler)), forEach(type.split(" "), function(type) {
var eventFns = events1[type];
if (!eventFns) {
if ("mouseenter" == type || "mouseleave" == type) {
var contains = document1.body.contains || document1.body.compareDocumentPosition ? function(a, b) {
// jshint bitwise: false
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;
};
events1[type] = [], onFn(element, {
mouseleave: "mouseout",
mouseenter: "mouseover"
}[type], function(event) {
var related = event.relatedTarget;
// For mousenter/leave call the handler if related is outside the target.
// NB: No relatedTarget if the mouse left/entered the browser window
related && (related === this || contains(this, related)) || handle(event, type);
});
} else addEventListenerFn(element, type, handle), events1[type] = [];
eventFns = events1[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(// IE8 doesn't have nextElementSibling
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) {
/**
* chaining functions
*/ 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)) && // any function which returns a value needs to be wrapped
(value = jqLite(value)) : jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
return isDefined(value) ? value : this;
}, // bind legacy bind/unbind to on/off
JQLite.prototype.bind = JQLite.prototype.on, JQLite.prototype.unbind = JQLite.prototype.off;
}), HashMap.prototype = {
/**
* Store key value pair
* @param key key to store can be any type
* @param value value to store can be any type
*/ put: function(key, value) {
this[hashKey(key)] = value;
},
/**
* @param key
* @returns the value for the key
*/ get: function(key) {
return this[hashKey(key)];
},
/**
* Remove the key/value pair
* @param key
*/ remove: function(key) {
var value = this[key = hashKey(key)];
return delete this[key], value;
}
};
/**
* @ngdoc function
* @name angular.injector
* @function
*
* @description
* Creates an injector function that can be used for retrieving services as well as for
* dependency injection (see {@link guide/di dependency injection}).
*
* @param {Array.<string|Function>} modules A list of module functions or their aliases. See
* {@link angular.module}. The `ng` module must be explicitly added.
* @returns {function()} Injector function. See {@link AUTO.$injector $injector}.
*
* @example
* Typical usage
* <pre>
* // create an injector
* var $injector = angular.injector(['ng']);
*
* // use the injector to kick off your application
* // use the type inference to auto inject arguments, or use implicit injection
* $injector.invoke(function($rootScope, $compile, $document){
* $compile($document)($rootScope);
* $rootScope.$digest();
* });
* </pre>
*
* Sometimes you want to get access to the injector of a currently running Angular app
* from outside Angular. Perhaps, you want to inject and compile some markup after the
* application has been bootstrapped. You can do this using extra `injector()` added
* to JQuery/jqLite elements. See {@link angular.element}.
*
* *This is fairly rare but could be the case if a third party library is injecting the
* markup.*
*
* In the following example a new block of HTML containing a `ng-controller`
* directive is added to the end of the document body by JQuery. We then compile and link
* it into the current AngularJS scope.
*
* <pre>
* var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
* $(document.body).append($div);
*
* angular.element(document).injector().invoke(function($compile) {
* var scope = angular.element($div).scope();
* $compile($div)(scope);
* });
* </pre>
*/ /**
* @ngdoc overview
* @name AUTO
* @description
*
* Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
*/ 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) ? (last = fn.length - 1, assertArgFn(fn[last], "fn"), $inject = fn.slice(0, last)) : assertArgFn(fn, "fn", !0), $inject;
}
///////////////////////////////////////
/**
* @ngdoc object
* @name AUTO.$injector
* @function
*
* @description
*
* `$injector` is used to retrieve object instances as defined by
* {@link AUTO.$provide provider}, instantiate types, invoke methods,
* and load modules.
*
* The following always holds true:
*
* <pre>
* var $injector = angular.injector();
* expect($injector.get('$injector')).toBe($injector);
* expect($injector.invoke(function($injector){
* return $injector;
* }).toBe($injector);
* </pre>
*
* # Injection Function Annotation
*
* JavaScript does not have annotations, and annotations are needed for dependency injection. The
* following are all valid ways of annotating function with injection arguments and are equivalent.
*
* <pre>
* // inferred (only works if code not minified/obfuscated)
* $injector.invoke(function(serviceA){});
*
* // annotated
* function explicit(serviceA) {};
* explicit.$inject = ['serviceA'];
* $injector.invoke(explicit);
*
* // inline
* $injector.invoke(['serviceA', function(serviceA){}]);
* </pre>
*
* ## Inference
*
* In JavaScript calling `toString()` on a function returns the function definition. The definition
* can then be parsed and the function arguments can be extracted. *NOTE:* This does not work with
* minification, and obfuscation tools since these tools change the argument names.
*
* ## `$inject` Annotation
* By adding a `$inject` property onto a function the injection parameters can be specified.
*
* ## Inline
* As an array of injection names, where the last item in the array is the function to call.
*/ /**
* @ngdoc method
* @name AUTO.$injector#get
* @methodOf AUTO.$injector
*
* @description
* Return an instance of the service.
*
* @param {string} name The name of the instance to retrieve.
* @return {*} The instance.
*/ /**
* @ngdoc method
* @name AUTO.$injector#invoke
* @methodOf AUTO.$injector
*
* @description
* Invoke the method and supply the method arguments from the `$injector`.
*
* @param {!function} fn The function to invoke. Function parameters are injected according to the
* {@link guide/di $inject Annotation} rules.
* @param {Object=} self The `this` for the invoked method.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {*} the value returned by the invoked `fn` function.
*/ /**
* @ngdoc method
* @name AUTO.$injector#has
* @methodOf AUTO.$injector
*
* @description
* Allows the user to query if the particular service exist.
*
* @param {string} Name of the service to query.
* @returns {boolean} returns true if injector has given service.
*/ /**
* @ngdoc method
* @name AUTO.$injector#instantiate
* @methodOf AUTO.$injector
* @description
* Create a new instance of JS type. The method takes a constructor function invokes the new
* operator and supplies all of the arguments to the constructor function as specified by the
* constructor annotation.
*
* @param {function} Type Annotated constructor function.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {Object} new instance of `Type`.
*/ /**
* @ngdoc method
* @name AUTO.$injector#annotate
* @methodOf AUTO.$injector
*
* @description
* Returns an array of service names which the function is requesting for injection. This API is
* used by the injector to determine which services need to be injected into the function when the
* function is invoked. There are three ways in which the function can be annotated with the needed
* dependencies.
*
* # Argument names
*
* The simplest form is to extract the dependencies from the arguments of the function. This is done
* by converting the function into a string using `toString()` method and extracting the argument
* names.
* <pre>
* // Given
* function MyController($scope, $route) {
* // ...
* }
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* This method does not work with code minification / obfuscation. For this reason the following
* annotation strategies are supported.
*
* # The `$inject` property
*
* If a function has an `$inject` property and its value is an array of strings, then the strings
* represent names of services to be injected into the function.
* <pre>
* // Given
* var MyController = function(obfuscatedScope, obfuscatedRoute) {
* // ...
* }
* // Define function dependencies
* MyController['$inject'] = ['$scope', '$route'];
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* # The array notation
*
* It is often desirable to inline Injected functions and that's when setting the `$inject` property
* is very inconvenient. In these situations using the array notation to specify the dependencies in
* a way that survives minification is a better choice:
*
* <pre>
* // We wish to write this (not minification / obfuscation safe)
* injector.invoke(function($compile, $rootScope) {
* // ...
* });
*
* // We are forced to write break inlining
* var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
* // ...
* };
* tmpFn.$inject = ['$compile', '$rootScope'];
* injector.invoke(tmpFn);
*
* // To better support inline function the inline annotation is supported
* injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
* // ...
* }]);
*
* // Therefore
* expect(injector.annotate(
* ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
* ).toEqual(['$compile', '$rootScope']);
* </pre>
*
* @param {function|Array.<string|Function>} fn Function for which dependent service names need to
* be retrieved as described above.
*
* @returns {Array.<string>} The names of the services which the function requires.
*/ /**
* @ngdoc object
* @name AUTO.$provide
*
* @description
*
* The {@link AUTO.$provide $provide} service has a number of methods for registering components
* with the {@link AUTO.$injector $injector}. Many of these functions are also exposed on
* {@link angular.Module}.
*
* An Angular **service** is a singleton object created by a **service factory**. These **service
* factories** are functions which, in turn, are created by a **service provider**.
* The **service providers** are constructor functions. When instantiated they must contain a
* property called `$get`, which holds the **service factory** function.
*
* When you request a service, the {@link AUTO.$injector $injector} is responsible for finding the
* correct **service provider**, instantiating it and then calling its `$get` **service factory**
* function to get the instance of the **service**.
*
* Often services have no configuration options and there is no need to add methods to the service
* provider. The provider will be no more than a constructor function with a `$get` property. For
* these cases the {@link AUTO.$provide $provide} service has additional helper methods to register
* services without specifying a provider.
*
* * {@link AUTO.$provide#methods_provider provider(provider)} - registers a **service provider** with the
* {@link AUTO.$injector $injector}
* * {@link AUTO.$provide#methods_constant constant(obj)} - registers a value/object that can be accessed by
* providers and services.
* * {@link AUTO.$provide#methods_value value(obj)} - registers a value/object that can only be accessed by
* services, not providers.
* * {@link AUTO.$provide#methods_factory factory(fn)} - registers a service **factory function**, `fn`,
* that will be wrapped in a **service provider** object, whose `$get` property will contain the
* given factory function.
* * {@link AUTO.$provide#methods_service service(class)} - registers a **constructor function**, `class` that
* that will be wrapped in a **service provider** object, whose `$get` property will instantiate
* a new object using the given constructor function.
*
* See the individual methods for more information and examples.
*/ /**
* @ngdoc method
* @name AUTO.$provide#provider
* @methodOf AUTO.$provide
* @description
*
* Register a **provider function** with the {@link AUTO.$injector $injector}. Provider functions
* are constructor functions, whose instances are responsible for "providing" a factory for a
* service.
*
* Service provider names start with the name of the service they provide followed by `Provider`.
* For example, the {@link ng.$log $log} service has a provider called
* {@link ng.$logProvider $logProvider}.
*
* Service provider objects can have additional methods which allow configuration of the provider
* and its service. Importantly, you can configure what kind of service is created by the `$get`
* method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
* method {@link ng.$logProvider#debugEnabled debugEnabled}
* which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
* console or not.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name +
'Provider'` key.
* @param {(Object|function())} provider If the provider is:
*
* - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
* {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be
* created.
* - `Constructor`: a new instance of the provider will be created using
* {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as
* `object`.
*
* @returns {Object} registered provider instance
* @example
*
* The following example shows how to create a simple event tracking service and register it using
* {@link AUTO.$provide#methods_provider $provide.provider()}.
*
* <pre>
* // Define the eventTracker provider
* function EventTrackerProvider() {
* var trackingUrl = '/track';
*
* // A provider method for configuring where the tracked events should been saved
* this.setTrackingUrl = function(url) {
* trackingUrl = url;
* };
*
* // The service factory function
* this.$get = ['$http', function($http) {
* var trackedEvents = {};
* return {
* // Call this to track an event
* event: function(event) {
* var count = trackedEvents[event] || 0;
* count += 1;
* trackedEvents[event] = count;
* return count;
* },
* // Call this to save the tracked events to the trackingUrl
* save: function() {
* $http.post(trackingUrl, trackedEvents);
* }
* };
* }];
* }
*
* describe('eventTracker', function() {
* var postSpy;
*
* beforeEach(module(function($provide) {
* // Register the eventTracker provider
* $provide.provider('eventTracker', EventTrackerProvider);
* }));
*
* beforeEach(module(function(eventTrackerProvider) {
* // Configure eventTracker provider
* eventTrackerProvider.setTrackingUrl('/custom-track');
* }));
*
* it('tracks events', inject(function(eventTracker) {
* expect(eventTracker.event('login')).toEqual(1);
* expect(eventTracker.event('login')).toEqual(2);
* }));
*
* it('saves to the tracking url', inject(function(eventTracker, $http) {
* postSpy = spyOn($http, 'post');
* eventTracker.event('login');
* eventTracker.save();
* expect(postSpy).toHaveBeenCalled();
* expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
* expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
* expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
* }));
* });
* </pre>
*/ /**
* @ngdoc method
* @name AUTO.$provide#factory
* @methodOf AUTO.$provide
* @description
*
* Register a **service factory**, which will be called to return the service instance.
* This is short for registering a service where its provider consists of only a `$get` property,
* which is the given service factory function.
* You should use {@link AUTO.$provide#factory $provide.factory(getFn)} if you do not need to
* configure your service in a provider.
*
* @param {string} name The name of the instance.
* @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand
* for `$provide.provider(name, {$get: $getFn})`.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service
* <pre>
* $provide.factory('ping', ['$http', function($http) {
* return function ping() {
* return $http.send('/ping');
* };
* }]);
* </pre>
* You would then inject and use this service like this:
* <pre>
* someModule.controller('Ctrl', ['ping', function(ping) {
* ping();
* }]);
* </pre>
*/ /**
* @ngdoc method
* @name AUTO.$provide#service
* @methodOf AUTO.$provide
* @description
*
* Register a **service constructor**, which will be invoked with `new` to create the service
* instance.
* This is short for registering a service where its provider's `$get` property is the service
* constructor function that will be used to instantiate the service instance.
*
* You should use {@link AUTO.$provide#methods_service $provide.service(class)} if you define your service
* as a type/class. This is common when using {@link http://coffeescript.org CoffeeScript}.
*
* @param {string} name The name of the instance.
* @param {Function} constructor A class (constructor function) that will be instantiated.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service using
* {@link AUTO.$provide#methods_service $provide.service(class)} that is defined as a CoffeeScript class.
* <pre>
* class Ping
* constructor: (@$http)->
* send: ()=>
* @$http.get('/ping')
*
* $provide.service('ping', ['$http', Ping])
* </pre>
* You would then inject and use this service like this:
* <pre>
* someModule.controller 'Ctrl', ['ping', (ping)->
* ping.send()
* ]
* </pre>
*/ /**
* @ngdoc method
* @name AUTO.$provide#value
* @methodOf AUTO.$provide
* @description
*
* Register a **value service** with the {@link AUTO.$injector $injector}, such as a string, a
* number, an array, an object or a function. This is short for registering a service where its
* provider's `$get` property is a factory function that takes no arguments and returns the **value
* service**.
*
* Value services are similar to constant services, except that they cannot be injected into a
* module configuration function (see {@link angular.Module#config}) but they can be overridden by
* an Angular
* {@link AUTO.$provide#decorator decorator}.
*
* @param {string} name The name of the instance.
* @param {*} value The value.
* @returns {Object} registered provider instance
*
* @example
* Here are some examples of creating value services.
* <pre>
* $provide.value('ADMIN_USER', 'admin');
*
* $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
*
* $provide.value('halfOf', function(value) {
* return value / 2;
* });
* </pre>
*/ /**
* @ngdoc method
* @name AUTO.$provide#constant
* @methodOf AUTO.$provide
* @description
*
* Register a **constant service**, such as a string, a number, an array, an object or a function,
* with the {@link AUTO.$injector $injector}. Unlike {@link AUTO.$provide#value value} it can be
* injected into a module configuration function (see {@link angular.Module#config}) and it cannot
* be overridden by an Angular {@link AUTO.$provide#decorator decorator}.
*
* @param {string} name The name of the constant.
* @param {*} value The constant value.
* @returns {Object} registered instance
*
* @example
* Here a some examples of creating constants:
* <pre>
* $provide.constant('SHARD_HEIGHT', 306);
*
* $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
*
* $provide.constant('double', function(value) {
* return value * 2;
* });
* </pre>
*/ /**
* @ngdoc method
* @name AUTO.$provide#decorator
* @methodOf AUTO.$provide
* @description
*
* Register a **service decorator** with the {@link AUTO.$injector $injector}. A service decorator
* intercepts the creation of a service, allowing it to override or modify the behaviour of the
* service. The object returned by the decorator may be the original service, or a new service
* object which replaces or wraps and delegates to the original service.
*
* @param {string} name The name of the service to decorate.
* @param {function()} decorator This function will be invoked when the service needs to be
* instantiated and should return the decorated service instance. The function is called using
* the {@link AUTO.$injector#invoke injector.invoke} method and is therefore fully injectable.
* Local injection arguments:
*
* * `$delegate` - The original service instance, which can be monkey patched, configured,
* decorated or delegated to.
*
* @example
* Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
* calls to {@link ng.$log#error $log.warn()}.
* <pre>
* $provider.decorator('$log', ['$delegate', function($delegate) {
* $delegate.warn = $delegate.error;
* return $delegate;
* }]);
* </pre>
*/ function createInjector(modulesToLoad) {
var INSTANTIATING = {}, providerSuffix = "Provider", 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 + providerSuffix), 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 + providerSuffix);
return instanceInjector.invoke(provider.$get, provider);
});
return forEach(////////////////////////////////////
// Module Loading
////////////////////////////////////
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) ? runBlocks.push(providerInjector.invoke(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) && // Safari & FF's stack traces don't contain error.message content
// unlike those of Chrome and IE
// So if stack doesn't contain message, we create a new string that contains both.
// Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
/* jshint -W022 */ (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;
////////////////////////////////////
// $provider
////////////////////////////////////
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 + providerSuffix] = provider_;
}
function factory(name, factoryFn) {
return provider(name, {
$get: factoryFn
});
}
////////////////////////////////////
// internal Injector
////////////////////////////////////
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));
}
// http://jsperf.com/angularjs-invoke-apply-vs-switch
// #5388
return fn.$inject || // this means that we must be an array.
(fn = fn[length]), fn.apply(self, args);
}
return {
invoke: invoke,
instantiate: function(Type, locals) {
var instance, returnedValue, Constructor = function() {};
return(// Check if Type is annotated and use just the given function at n-1 as parameter
// e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
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 + providerSuffix) || cache.hasOwnProperty(name);
}
};
}
}
/**
* @ngdoc function
* @name ng.$anchorScroll
* @requires $window
* @requires $location
* @requires $rootScope
*
* @description
* When called, it checks current value of `$location.hash()` and scroll to related element,
* according to rules specified in
* {@link http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document Html5 spec}.
*
* It also watches the `$location.hash()` and scrolls whenever it changes to match any anchor.
* This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
*
* @example
<example>
<file name="index.html">
<div id="scrollArea" ng-controller="ScrollCtrl">
<a ng-click="gotoBottom()">Go to bottom</a>
<a id="bottom"></a> You're at the bottom!
</div>
</file>
<file name="script.js">
function ScrollCtrl($scope, $location, $anchorScroll) {
$scope.gotoBottom = function (){
// set the location.hash to the id of
// the element you wish to scroll to.
$location.hash('bottom');
// call $anchorScroll()
$anchorScroll();
}
}
</file>
<file name="style.css">
#scrollArea {
height: 350px;
overflow: auto;
}
#bottom {
display: block;
margin-top: 2000px;
}
</file>
</example>
*/ function $AnchorScrollProvider() {
var autoScrollingEnabled = !0;
this.disableAutoScrolling = function() {
autoScrollingEnabled = !1;
}, this.$get = [
"$window",
"$location",
"$rootScope",
function($window, $location, $rootScope) {
var document1 = $window.document;
function scroll() {
var list, result, elm, hash = $location.hash();
// empty hash, scroll to the top of the page
hash ? (elm = document1.getElementById(hash)) ? elm.scrollIntoView() : (list = document1.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 = {}, /**
* @ngdoc function
* @name ng.$animateProvider#register
* @methodOf ng.$animateProvider
*
* @description
* Registers a new injectable animation factory function. The factory function produces the
* animation object which contains callback functions for each event that is expected to be
* animated.
*
* * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`
* must be called once the element animation is complete. If a function is returned then the
* animation service will use this function to cancel the animation whenever a cancel event is
* triggered.
*
*
*<pre>
* return {
* eventFn : function(element, done) {
* //code to run the animation
* //once complete, then run done()
* return function cancellationFunction() {
* //code to cancel the animation
* }
* }
* }
*</pre>
*
* @param {string} name The name of the animation.
* @param {function} factory The factory function that will be executed to return the animation
* object.
*/ 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) {
/**
*
* @ngdoc object
* @name ng.$animate
* @description The $animate service provides rudimentary DOM manipulation functions to
* insert, remove and move elements within the DOM, as well as adding and removing classes.
* This service is the core service used by the ngAnimate $animator service which provides
* high-level animation hooks for CSS and JavaScript.
*
* $animate is available in the AngularJS core, however, the ngAnimate module must be included
* to enable full out animation support. Otherwise, $animate will only perform simple DOM
* manipulation operations.
*
* To learn more about enabling animation support, click here to visit the {@link ngAnimate
* ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service
* page}.
*/ return {
/**
*
* @ngdoc function
* @name ng.$animate#enter
* @methodOf ng.$animate
* @function
* @description Inserts the element into the DOM either after the `after` element or within
* the `parent` element. Once complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will be inserted into the DOM
* @param {jQuery/jqLite element} parent the parent element which will append the element as
* a child (if the after element is not present)
* @param {jQuery/jqLite element} after the sibling element which will append the element
* after itself
* @param {function=} done callback function that will be called after the element has been
* inserted into the DOM
*/ enter: function(element, parent, after, done) {
after ? after.after(element) : (parent && parent[0] || (parent = after.parent()), parent.append(element)), done && $timeout(done, 0, !1);
},
/**
*
* @ngdoc function
* @name ng.$animate#leave
* @methodOf ng.$animate
* @function
* @description Removes the element from the DOM. Once complete, the done() callback will be
* fired (if provided).
* @param {jQuery/jqLite element} element the element which will be removed from the DOM
* @param {function=} done callback function that will be called after the element has been
* removed from the DOM
*/ leave: function(element, done) {
element.remove(), done && $timeout(done, 0, !1);
},
/**
*
* @ngdoc function
* @name ng.$animate#move
* @methodOf ng.$animate
* @function
* @description Moves the position of the provided element within the DOM to be placed
* either after the `after` element or inside of the `parent` element. Once complete, the
* done() callback will be fired (if provided).
*
* @param {jQuery/jqLite element} element the element which will be moved around within the
* DOM
* @param {jQuery/jqLite element} parent the parent element where the element will be
* inserted into (if the after element is not present)
* @param {jQuery/jqLite element} after the sibling element where the element will be
* positioned next to
* @param {function=} done the callback function (if provided) that will be fired after the
* element has been moved to its new position
*/ move: function(element, parent, after, done) {
// Do not remove element before insert. Removing will cause data associated with the
// element to be dropped. Insert will implicitly do the remove.
this.enter(element, parent, after, done);
},
/**
*
* @ngdoc function
* @name ng.$animate#addClass
* @methodOf ng.$animate
* @function
* @description Adds the provided className CSS class value to the provided element. Once
* complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will have the className value
* added to it
* @param {string} className the CSS class which will be added to the element
* @param {function=} done the callback function (if provided) that will be fired after the
* className value has been added to the element
*/ 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);
},
/**
*
* @ngdoc function
* @name ng.$animate#removeClass
* @methodOf ng.$animate
* @function
* @description Removes the provided className CSS class value from the provided element.
* Once complete, the done() callback will be fired (if provided).
* @param {jQuery/jqLite element} element the element which will have the className value
* removed from it
* @param {string} className the CSS class which will be removed from the element
* @param {function=} done the callback function (if provided) that will be fired after the
* className value has been removed from the element
*/ 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
};
}
];
}
];
/**
* ! This is a private undocumented service !
*
* @name ng.$browser
* @requires $log
* @description
* This object has two goals:
*
* - hide all the global state in the browser caused by the window object
* - abstract away all the browser specific features and inconsistencies
*
* For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
* service, which can be used for convenient testing of the application without the interaction with
* the real browser apis.
*/ /**
* @param {object} window The global window object.
* @param {object} document jQuery wrapped document.
* @param {function()} XHR XMLHttpRequest constructor.
* @param {object} $log console.log or an object with the same interface.
* @param {object} $sniffer $sniffer service
*/ function Browser(window1, document1, $log, $sniffer) {
var self = this, rawDocument = document1[0], location = window1.location, history = window1.history, setTimeout1 = window1.setTimeout, clearTimeout = window1.clearTimeout, pendingDeferIds = {};
self.isMock = !1;
var outstandingRequestCount = 0, outstandingRequestCallbacks = [];
/**
* Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`
* counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.
*/ 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);
}
}
}
// TODO(vojta): remove this temporary api
self.$$completeOutstandingRequest = completeOutstandingRequest, self.$$incOutstandingRequestCount = function() {
outstandingRequestCount++;
}, /**
* @private
* Note: this method is used only by scenario runner
* TODO(vojta): prefix this method with $$ ?
* @param {function()} callback Function that will be called when no outstanding request
*/ self.notifyWhenNoOutstandingRequests = function(callback) {
// force browser to execute all pollFns - this is needed so that cookies and other pollers fire
// at some deterministic time in respect to the test runner's actions. Leaving things up to the
// regular poller would result in flaky tests.
forEach(pollFns, function(pollFn) {
pollFn();
}), 0 === outstandingRequestCount ? callback() : outstandingRequestCallbacks.push(callback);
};
//////////////////////////////////////////////////////////////
// Poll Watcher API
//////////////////////////////////////////////////////////////
var pollTimeout, pollFns = [];
/**
* @name ng.$browser#addPollFn
* @methodOf ng.$browser
*
* @param {function()} fn Poll function to add
*
* @description
* Adds a function to the list of functions that poller periodically executes,
* and starts polling if not started yet.
*
* @returns {function()} the added function
*/ self.addPollFn = function(fn) {
var interval, setTimeout2;
return isUndefined(pollTimeout) && (interval = 100, setTimeout2 = setTimeout1, function check() {
forEach(pollFns, function(pollFn) {
pollFn();
}), pollTimeout = setTimeout2(check, 100);
}()), pollFns.push(fn), fn;
};
//////////////////////////////////////////////////////////////
// URL API
//////////////////////////////////////////////////////////////
var lastBrowserUrl = location.href, baseElement = document1.find("base"), newLocation = null;
/**
* @name ng.$browser#url
* @methodOf ng.$browser
*
* @description
* GETTER:
* Without any argument, this method just returns current value of location.href.
*
* SETTER:
* With at least one argument, this method sets url to new value.
* If html5 history api supported, pushState/replaceState is used, otherwise
* location.href/location.replace is used.
* Returns its own instance to allow chaining
*
* NOTE: this api is intended for use only by the $location service. Please use the
* {@link ng.$location $location service} to change url.
*
* @param {string} url New url (when used as setter)
* @param {boolean=} replace Should new url replace current history record ?
*/ self.url = function(url, replace) {
return(// setter
(location !== window1.location && (location = window1.location), url) ? lastBrowserUrl != url ? (lastBrowserUrl = url, $sniffer.history ? replace ? history.replaceState(null, "", url) : (history.pushState(null, "", url), // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462
baseElement.attr("href", baseElement.attr("href"))) : (newLocation = url, replace ? location.replace(url) : location.href = url), self) : void 0 : 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());
}));
}
/**
* @name ng.$browser#onUrlChange
* @methodOf ng.$browser
* @TODO(vojta): refactor to use node's syntax for events
*
* @description
* Register callback function that will be called, when url changes.
*
* It's only called when the url is changed by outside of angular:
* - user types different url into address bar
* - user clicks on history (forward/back) button
* - user clicks on a link
*
* It's not called when url is changed by $browser.url() method
*
* The listener gets called with new url as parameter.
*
* NOTE: this api is intended for use only by the $location service. Please use the
* {@link ng.$location $location service} to monitor url changes in angular apps.
*
* @param {function(string)} listener Listener function to be called when url changes.
* @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
*/ self.onUrlChange = function(callback) {
return urlChangeInit || ($sniffer.history && jqLite(window1).on("popstate", fireUrlChange), $sniffer.hashchange ? jqLite(window1).on("hashchange", fireUrlChange) : self.addPollFn(fireUrlChange), urlChangeInit = !0), urlChangeListeners.push(callback), callback;
}, //////////////////////////////////////////////////////////////
// Misc API
//////////////////////////////////////////////////////////////
/**
* @name ng.$browser#baseHref
* @methodOf ng.$browser
*
* @description
* Returns current <base href>
* (always relative - without domain)
*
* @returns {string=} current <base href>
*/ self.baseHref = function() {
var href = baseElement.attr("href");
return href ? href.replace(/^https?\:\/\/[^\/]*/, "") : "";
};
//////////////////////////////////////////////////////////////
// Cookies API
//////////////////////////////////////////////////////////////
var lastCookies = {}, lastCookieString = "", cookiePath = self.baseHref();
/**
* @name ng.$browser#cookies
* @methodOf ng.$browser
*
* @param {string=} name Cookie name
* @param {string=} value Cookie value
*
* @description
* The cookies method provides a 'private' low level access to browser cookies.
* It is not meant to be used directly, use the $cookie service instead.
*
* The return values vary depending on the arguments that the method was called with as follows:
*
* - cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify
* it
* - cookies(name, value) -> set name to value, if value is undefined delete the cookie
* - cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that
* way)
*
* @returns {Object} Hash of all cookies (if called without any parameter)
*/ self.cookies = function(name, value) {
/* global escape: false, unescape: false */ var cookieLength, cookieArray, cookie, i, index;
if (name) 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)!");
else {
if (rawDocument.cookie !== lastCookieString) for(i = 0, cookieArray = (lastCookieString = rawDocument.cookie).split("; "), lastCookies = {}; i < cookieArray.length; i++)(index = (cookie = cookieArray[i]).indexOf("=")) > 0 && lastCookies[//ignore nameless cookies
name = unescape(cookie.substring(0, index))] === undefined && (lastCookies[name] = unescape(cookie.substring(index + 1)));
return lastCookies;
}
}, /**
* @name ng.$browser#defer
* @methodOf ng.$browser
* @param {function()} fn A function, who's execution should be deferred.
* @param {number=} [delay=0] of milliseconds to defer the function execution.
* @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
*
* @description
* Executes a fn asynchronously via `setTimeout(fn, delay)`.
*
* Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
* `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
* via `$browser.defer.flush()`.
*
*/ self.defer = function(fn, delay) {
var timeoutId;
return outstandingRequestCount++, pendingDeferIds[timeoutId = setTimeout1(function() {
delete pendingDeferIds[timeoutId], completeOutstandingRequest(fn);
}, delay || 0)] = !0, timeoutId;
}, /**
* @name ng.$browser#defer.cancel
* @methodOf ng.$browser.defer
*
* @description
* Cancels a deferred task identified with `deferId`.
*
* @param {*} deferId Token returned by the `$browser.defer` function.
* @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
* canceled.
*/ 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);
}
];
}
/**
* @ngdoc object
* @name ng.$cacheFactory
*
* @description
* Factory that constructs cache objects and gives access to them.
*
* <pre>
*
* var cache = $cacheFactory('cacheId');
* expect($cacheFactory.get('cacheId')).toBe(cache);
* expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
*
* cache.put("key", "value");
* cache.put("another key", "another value");
*
* // We've specified no options on creation
* expect(cache.info()).toEqual({id: 'cacheId', size: 2});
*
* </pre>
*
*
* @param {string} cacheId Name or id of the newly created cache.
* @param {object=} options Options object that specifies the cache behavior. Properties:
*
* - `{number=}` `capacity` — turns the cache into LRU cache.
*
* @returns {object} Newly created cache object with the following set of methods:
*
* - `{object}` `info()` — Returns id, size, and options of cache.
* - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns
* it.
* - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
* - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
* - `{void}` `removeAll()` — Removes all cached values.
* - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
*
*/ 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
});
}
};
/**
* makes the `entry` the freshEnd of the LRU linked list
*/ 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);
}
/**
* bidirectionally links two entries of the LRU linked list
*/ function link(nextEntry, prevEntry) {
nextEntry != prevEntry && (nextEntry && (nextEntry.p = prevEntry), prevEntry && (prevEntry.n = nextEntry));
}
}
return(/**
* @ngdoc method
* @name ng.$cacheFactory#info
* @methodOf ng.$cacheFactory
*
* @description
* Get information about all the of the caches that have been created
*
* @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info`
*/ cacheFactory.info = function() {
var info = {};
return forEach(caches, function(cache, cacheId) {
info[cacheId] = cache.info();
}), info;
}, /**
* @ngdoc method
* @name ng.$cacheFactory#get
* @methodOf ng.$cacheFactory
*
* @description
* Get access to a cache object by the `cacheId` used when it was created.
*
* @param {string} cacheId Name or id of a cache to access.
* @returns {object} Cache object identified by the cacheId or undefined if no such cache.
*/ cacheFactory.get = function(cacheId) {
return caches[cacheId];
}, cacheFactory);
};
}
/**
* @ngdoc object
* @name ng.$templateCache
*
* @description
* The first time a template is used, it is loaded in the template cache for quick retrieval. You
* can load templates directly into the cache in a `script` tag, or by consuming the
* `$templateCache` service directly.
*
* Adding via the `script` tag:
* <pre>
* <html ng-app>
* <head>
* <script type="text/ng-template" id="templateId.html">
* This is the content of the template
* </script>
* </head>
* ...
* </html>
* </pre>
*
* **Note:** the `script` tag containing the template does not need to be included in the `head` of
* the document, but it must be below the `ng-app` definition.
*
* Adding via the $templateCache service:
*
* <pre>
* var myApp = angular.module('myApp', []);
* myApp.run(function($templateCache) {
* $templateCache.put('templateId.html', 'This is the content of the template');
* });
* </pre>
*
* To retrieve the template later, simply use it in your HTML:
* <pre>
* <div ng-include=" 'templateId.html' "></div>
* </pre>
*
* or get it via Javascript:
* <pre>
* $templateCache.get('templateId.html')
* </pre>
*
* See {@link ng.$cacheFactory $cacheFactory}.
*
*/ function $TemplateCacheProvider() {
this.$get = [
"$cacheFactory",
function($cacheFactory) {
return $cacheFactory("templates");
}
];
}
/* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!
*
* DOM-related variables:
*
* - "node" - DOM Node
* - "element" - DOM Element or Node
* - "$node" or "$element" - jqLite-wrapped node or element
*
*
* Compiler related stuff:
*
* - "linkFn" - linking fn of a single directive
* - "nodeLinkFn" - function that aggregates all linking fns for a particular node
* - "childLinkFn" - function that aggregates all linking fns for child nodes of a particular node
* - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList)
*/ /**
* @ngdoc function
* @name ng.$compile
* @function
*
* @description
* Compiles a piece of HTML string or DOM into a template and produces a template function, which
* can then be used to link {@link ng.$rootScope.Scope `scope`} and the template together.
*
* The compilation is a process of walking the DOM tree and matching DOM elements to
* {@link ng.$compileProvider#methods_directive directives}.
*
* <div class="alert alert-warning">
* **Note:** This document is an in-depth reference of all directive options.
* For a gentle introduction to directives with examples of common use cases,
* see the {@link guide/directive directive guide}.
* </div>
*
* ## Comprehensive Directive API
*
* There are many different options for a directive.
*
* The difference resides in the return value of the factory function.
* You can either return a "Directive Definition Object" (see below) that defines the directive properties,
* or just the `postLink` function (all other properties will have the default values).
*
* <div class="alert alert-success">
* **Best Practice:** It's recommended to use the "directive definition object" form.
* </div>
*
* Here's an example directive declared with a Directive Definition Object:
*
* <pre>
* var myModule = angular.module(...);
*
* myModule.directive('directiveName', function factory(injectables) {
* var directiveDefinitionObject = {
* priority: 0,
* template: '<div></div>', // or // function(tElement, tAttrs) { ... },
* // or
* // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... },
* replace: false,
* transclude: false,
* restrict: 'A',
* scope: false,
* controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
* require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],
* compile: function compile(tElement, tAttrs, transclude) {
* return {
* pre: function preLink(scope, iElement, iAttrs, controller) { ... },
* post: function postLink(scope, iElement, iAttrs, controller) { ... }
* }
* // or
* // return function postLink( ... ) { ... }
* },
* // or
* // link: {
* // pre: function preLink(scope, iElement, iAttrs, controller) { ... },
* // post: function postLink(scope, iElement, iAttrs, controller) { ... }
* // }
* // or
* // link: function postLink( ... ) { ... }
* };
* return directiveDefinitionObject;
* });
* </pre>
*
* <div class="alert alert-warning">
* **Note:** Any unspecified options will use the default value. You can see the default values below.
* </div>
*
* Therefore the above can be simplified as:
*
* <pre>
* var myModule = angular.module(...);
*
* myModule.directive('directiveName', function factory(injectables) {
* var directiveDefinitionObject = {
* link: function postLink(scope, iElement, iAttrs) { ... }
* };
* return directiveDefinitionObject;
* // or
* // return function postLink(scope, iElement, iAttrs) { ... }
* });
* </pre>
*
*
*
* ### Directive Definition Object
*
* The directive definition object provides instructions to the {@link api/ng.$compile
* compiler}. The attributes are:
*
* #### `priority`
* When there are multiple directives defined on a single DOM element, sometimes it
* is necessary to specify the order in which the directives are applied. The `priority` is used
* to sort the directives before their `compile` functions get called. Priority is defined as a
* number. Directives with greater numerical `priority` are compiled first. Pre-link functions
* are also run in priority order, but post-link functions are run in reverse order. The order
* of directives with the same priority is undefined. The default priority is `0`.
*
* #### `terminal`
* If set to true then the current `priority` will be the last set of directives
* which will execute (any directives at the current priority will still execute
* as the order of execution on same `priority` is undefined).
*
* #### `scope`
* **If set to `true`,** then a new scope will be created for this directive. If multiple directives on the
* same element request a new scope, only one new scope is created. The new scope rule does not
* apply for the root of the template since the root of the template always gets a new scope.
*
* **If set to `{}` (object hash),** then a new "isolate" scope is created. The 'isolate' scope differs from
* normal scope in that it does not prototypically inherit from the parent scope. This is useful
* when creating reusable components, which should not accidentally read or modify data in the
* parent scope.
*
* The 'isolate' scope takes an object hash which defines a set of local scope properties
* derived from the parent scope. These local properties are useful for aliasing values for
* templates. Locals definition is a hash of local scope property to its source:
*
* * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is
* always a string since DOM attributes are strings. If no `attr` name is specified then the
* attribute name is assumed to be the same as the local name.
* Given `<widget my-attr="hello {{name}}">` and widget definition
* of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect
* the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the
* `localName` property on the widget scope. The `name` is read from the parent scope (not
* component scope).
*
* * `=` or `=attr` - set up bi-directional binding between a local scope property and the
* parent scope property of name defined via the value of the `attr` attribute. If no `attr`
* name is specified then the attribute name is assumed to be the same as the local name.
* Given `<widget my-attr="parentModel">` and widget definition of
* `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the
* value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
* in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent
* scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You
* can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional.
*
* * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.
* If no `attr` name is specified then the attribute name is assumed to be the same as the
* local name. Given `<widget my-attr="count = count + value">` and widget definition of
* `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to
* a function wrapper for the `count = count + value` expression. Often it's desirable to
* pass data from the isolated scope via an expression and to the parent scope, this can be
* done by passing a map of local variable names and values into the expression wrapper fn.
* For example, if the expression is `increment(amount)` then we can specify the amount value
* by calling the `localFn` as `localFn({amount: 22})`.
*
*
*
* #### `controller`
* Controller constructor function. The controller is instantiated before the
* pre-linking phase and it is shared with other directives (see
* `require` attribute). This allows the directives to communicate with each other and augment
* each other's behavior. The controller is injectable (and supports bracket notation) with the following locals:
*
* * `$scope` - Current scope associated with the element
* * `$element` - Current element
* * `$attrs` - Current attributes object for the element
* * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope.
* The scope can be overridden by an optional first argument.
* `function([scope], cloneLinkingFn)`.
*
*
* #### `require`
* Require another directive and inject its controller as the fourth argument to the linking function. The
* `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the
* injected argument will be an array in corresponding order. If no such directive can be
* found, or if the directive does not have a controller, then an error is raised. The name can be prefixed with:
*
* * (no prefix) - Locate the required controller on the current element. Throw an error if not found.
* * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.
* * `^` - Locate the required controller by searching the element's parents. Throw an error if not found.
* * `?^` - Attempt to locate the required controller by searching the element's parents or pass `null` to the
* `link` fn if not found.
*
*
* #### `controllerAs`
* Controller alias at the directive scope. An alias for the controller so it
* can be referenced at the directive template. The directive needs to define a scope for this
* configuration to be used. Useful in the case when directive is used as component.
*
*
* #### `restrict`
* String of subset of `EACM` which restricts the directive to a specific directive
* declaration style. If omitted, the default (attributes only) is used.
*
* * `E` - Element name: `<my-directive></my-directive>`
* * `A` - Attribute (default): `<div my-directive="exp"></div>`
* * `C` - Class: `<div class="my-directive: exp;"></div>`
* * `M` - Comment: `<!-- directive: my-directive exp -->`
*
*
* #### `template`
* replace the current element with the contents of the HTML. The replacement process
* migrates all of the attributes / classes from the old element to the new one. See the
* {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive
* Directives Guide} for an example.
*
* You can specify `template` as a string representing the template or as a function which takes
* two arguments `tElement` and `tAttrs` (described in the `compile` function api below) and
* returns a string value representing the template.
*
*
* #### `templateUrl`
* Same as `template` but the template is loaded from the specified URL. Because
* the template loading is asynchronous the compilation/linking is suspended until the template
* is loaded.
*
* You can specify `templateUrl` as a string representing the URL or as a function which takes two
* arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns
* a string value representing the url. In either case, the template URL is passed through {@link
* api/ng.$sce#methods_getTrustedResourceUrl $sce.getTrustedResourceUrl}.
*
*
* #### `replace`
* specify where the template should be inserted. Defaults to `false`.
*
* * `true` - the template will replace the current element.
* * `false` - the template will replace the contents of the current element.
*
*
* #### `transclude`
* compile the content of the element and make it available to the directive.
* Typically used with {@link api/ng.directive:ngTransclude
* ngTransclude}. The advantage of transclusion is that the linking function receives a
* transclusion function which is pre-bound to the correct scope. In a typical setup the widget
* creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate`
* scope. This makes it possible for the widget to have private state, and the transclusion to
* be bound to the parent (pre-`isolate`) scope.
*
* * `true` - transclude the content of the directive.
* * `'element'` - transclude the whole element including any directives defined at lower priority.
*
*
* #### `compile`
*
* <pre>
* function compile(tElement, tAttrs, transclude) { ... }
* </pre>
*
* The compile function deals with transforming the template DOM. Since most directives do not do
* template transformation, it is not used often. Examples that require compile functions are
* directives that transform template DOM, such as {@link
* api/ng.directive:ngRepeat ngRepeat}, or load the contents
* asynchronously, such as {@link api/ngRoute.directive:ngView ngView}. The
* compile function takes the following arguments.
*
* * `tElement` - template element - The element where the directive has been declared. It is
* safe to do template transformation on the element and child elements only.
*
* * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared
* between all directive compile functions.
*
* * `transclude` - [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)`
*
* <div class="alert alert-warning">
* **Note:** The template instance and the link instance may be different objects if the template has
* been cloned. For this reason it is **not** safe to do anything other than DOM transformations that
* apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration
* should be done in a linking function rather than in a compile function.
* </div>
*
* <div class="alert alert-error">
* **Note:** The `transclude` function that is passed to the compile function is deprecated, as it
* e.g. does not know about the right outer scope. Please use the transclude function that is passed
* to the link function instead.
* </div>
* A compile function can have a return value which can be either a function or an object.
*
* * returning a (post-link) function - is equivalent to registering the linking function via the
* `link` property of the config object when the compile function is empty.
*
* * returning an object with function(s) registered via `pre` and `post` properties - allows you to
* control when a linking function should be called during the linking phase. See info about
* pre-linking and post-linking functions below.
*
*
* #### `link`
* This property is used only if the `compile` property is not defined.
*
* <pre>
* function link(scope, iElement, iAttrs, controller, transcludeFn) { ... }
* </pre>
*
* The link function is responsible for registering DOM listeners as well as updating the DOM. It is
* executed after the template has been cloned. This is where most of the directive logic will be
* put.
*
* * `scope` - {@link api/ng.$rootScope.Scope Scope} - The scope to be used by the
* directive for registering {@link api/ng.$rootScope.Scope#methods_$watch watches}.
*
* * `iElement` - instance element - The element where the directive is to be used. It is safe to
* manipulate the children of the element only in `postLink` function since the children have
* already been linked.
*
* * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared
* between all directive linking functions.
*
* * `controller` - a controller instance - A controller instance if at least one directive on the
* element defines a controller. The controller is shared among all the directives, which allows
* the directives to use the controllers as a communication channel.
*
* * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
* The scope can be overridden by an optional first argument. This is the same as the `$transclude`
* parameter of directive controllers.
* `function([scope], cloneLinkingFn)`.
*
*
* #### Pre-linking function
*
* Executed before the child elements are linked. Not safe to do DOM transformation since the
* compiler linking function will fail to locate the correct elements for linking.
*
* #### Post-linking function
*
* Executed after the child elements are linked. It is safe to do DOM transformation in the post-linking function.
*
* <a name="Attributes"></a>
* ### Attributes
*
* The {@link api/ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the
* `link()` or `compile()` functions. It has a variety of uses.
*
* accessing *Normalized attribute names:*
* Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'.
* the attributes object allows for normalized access to
* the attributes.
*
* * *Directive inter-communication:* All directives share the same instance of the attributes
* object which allows the directives to use the attributes object as inter directive
* communication.
*
* * *Supports interpolation:* Interpolation attributes are assigned to the attribute object
* allowing other directives to read the interpolated value.
*
* * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes
* that contain interpolation (e.g. `src="{{bar}}"`). Not only is this very efficient but it's also
* the only way to easily get the actual value because during the linking phase the interpolation
* hasn't been evaluated yet and so the value is at this time set to `undefined`.
*
* <pre>
* function linkingFn(scope, elm, attrs, ctrl) {
* // get the attribute value
* console.log(attrs.ngModel);
*
* // change the attribute
* attrs.$set('ngModel', 'new value');
*
* // observe changes to interpolated attribute
* attrs.$observe('ngModel', function(value) {
* console.log('ngModel has changed value to ' + value);
* });
* }
* </pre>
*
* Below is an example using `$compileProvider`.
*
* <div class="alert alert-warning">
* **Note**: Typically directives are registered with `module.directive`. The example below is
* to illustrate how `$compile` works.
* </div>
*
<doc:example module="compile">
<doc:source>
<script>
angular.module('compile', [], function($compileProvider) {
// configure new 'compile' directive by passing a directive
// factory function. The factory function injects the '$compile'
$compileProvider.directive('compile', function($compile) {
// directive factory creates a link function
return function(scope, element, attrs) {
scope.$watch(
function(scope) {
// watch the 'compile' expression for changes
return scope.$eval(attrs.compile);
},
function(value) {
// when the 'compile' expression changes
// assign it into the current DOM
element.html(value);
// compile the new DOM and link it to the current
// scope.
// NOTE: we only compile .childNodes so that
// we don't get into infinite loop compiling ourselves
$compile(element.contents())(scope);
}
);
};
})
});
function Ctrl($scope) {
$scope.name = 'Angular';
$scope.html = 'Hello {{name}}';
}
</script>
<div ng-controller="Ctrl">
<input ng-model="name"> <br>
<textarea ng-model="html"></textarea> <br>
<div compile="html"></div>
</div>
</doc:source>
<doc:scenario>
it('should auto compile', function() {
expect(element('div[compile]').text()).toBe('Hello Angular');
input('html').enter('{{name}}!');
expect(element('div[compile]').text()).toBe('Angular!');
});
</doc:scenario>
</doc:example>
*
*
* @param {string|DOMElement} element Element or HTML string to compile into a template function.
* @param {function(angular.Scope[, cloneAttachFn]} transclude function available to directives.
* @param {number} maxPriority only apply directives lower then given priority (Only effects the
* root element(s), not their children)
* @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template
* (a DOM element/tree) to a scope. Where:
*
* * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
* * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
* `template` and call the `cloneAttachFn` function allowing the caller to attach the
* cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
* called as: <br> `cloneAttachFn(clonedElement, scope)` where:
*
* * `clonedElement` - is a clone of the original `element` passed into the compiler.
* * `scope` - is the current scope with which the linking function is working with.
*
* Calling the linking function returns the element of the template. It is either the original
* element passed in, or the clone of the element if the `cloneAttachFn` is provided.
*
* After linking the view is not updated until after a call to $digest which typically is done by
* Angular automatically.
*
* If you need access to the bound view, there are two ways to do it:
*
* - If you are not asking the linking function to clone the template, create the DOM element(s)
* before you send them to the compiler and keep this reference around.
* <pre>
* var element = $compile('<p>{{total}}</p>')(scope);
* </pre>
*
* - if on the other hand, you need the element to be cloned, the view reference from the original
* example would not point to the clone, but rather to the original template that was cloned. In
* this case, you can access the clone via the cloneAttachFn:
* <pre>
* var templateHTML = angular.element('<p>{{total}}</p>'),
* scope = ....;
*
* var clonedElement = $compile(templateHTML)(scope, function(clonedElement, scope) {
* //attach the clone to DOM document at the right place
* });
*
* //now we have reference to the cloned DOM via `clone`
* </pre>
*
*
* For information on how the compiler works, see the
* {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.
*/ var $compileMinErr = minErr("$compile");
function $CompileProvider($provide, $$sanitizeUriProvider) {
var hasDirectives = {}, Suffix = "Directive", COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/, CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/, EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
/**
* @ngdoc function
* @name ng.$compileProvider#directive
* @methodOf ng.$compileProvider
* @function
*
* @description
* Register a new directive with the compiler.
*
* @param {string|Object} name Name of the directive in camel-case (i.e. <code>ngBind</code> which
* will match as <code>ng-bind</code>), or an object map of directives where the keys are the
* names and the values are the factories.
* @param {function|Array} directiveFactory An injectable directive factory function. See
* {@link guide/directive} for more info.
* @returns {ng.$compileProvider} Self for chaining.
*/ this.directive = function registerDirective(name, directiveFactory) {
return assertNotHasOwnProperty(name, "directive"), isString(name) ? (assertArg(directiveFactory, "directiveFactory"), hasDirectives.hasOwnProperty(name) || (hasDirectives[name] = [], $provide.factory(name + Suffix, [
"$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;
}, /**
* @ngdoc function
* @name ng.$compileProvider#aHrefSanitizationWhitelist
* @methodOf ng.$compileProvider
* @function
*
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during a[href] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to a[href] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/ this.aHrefSanitizationWhitelist = function(regexp) {
return isDefined(regexp) ? ($$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp), this) : $$sanitizeUriProvider.aHrefSanitizationWhitelist();
}, /**
* @ngdoc function
* @name ng.$compileProvider#imgSrcSanitizationWhitelist
* @methodOf ng.$compileProvider
* @function
*
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during img[src] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to img[src] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/ 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,
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$addClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Adds the CSS class value specified by the classVal parameter to the element. If animations
* are enabled then an animation will be triggered for the class addition.
*
* @param {string} classVal The className value that will be added to the element
*/ $addClass: function(classVal) {
classVal && classVal.length > 0 && $animate.addClass(this.$$element, classVal);
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$removeClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Removes the CSS class value specified by the classVal parameter from the element. If
* animations are enabled then an animation will be triggered for the class removal.
*
* @param {string} classVal The className value that will be removed from the element
*/ $removeClass: function(classVal) {
classVal && classVal.length > 0 && $animate.removeClass(this.$$element, classVal);
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$updateClass
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Adds and removes the appropriate CSS class values to the element based on the difference
* between the new and old CSS class values (specified as newClasses and oldClasses).
*
* @param {string} newClasses The current CSS className value
* @param {string} oldClasses The former CSS className value
*/ $updateClass: function(newClasses, oldClasses) {
this.$removeClass(tokenDifference(oldClasses, newClasses)), this.$addClass(tokenDifference(newClasses, oldClasses));
},
/**
* Set a normalized attribute on the element in a way such that all directives
* can share the attribute. This function properly handles boolean attributes.
* @param {string} key Normalized key. (ie ngAttribute)
* @param {string|boolean} value The value to set. If `null` attribute will be deleted.
* @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
* Defaults to true.
* @param {string=} attrName Optional none normalized name. Defaults to key.
*/ $set: function(key, value, writeAttr, attrName) {
// TODO: decide whether or not to throw an error if "class"
//is set through this function since it may cause $updateClass to
//become unstable.
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));
// fire observers
var $$observers = this.$$observers;
$$observers && forEach($$observers[key], function(fn) {
try {
fn(value);
} catch (e) {
$exceptionHandler(e);
}
});
},
/**
* @ngdoc function
* @name ng.$compile.directive.Attributes#$observe
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Observes an interpolated attribute.
*
* The observer function will be invoked once during the next `$digest` following
* compilation. The observer is then invoked whenever the interpolated value
* changes.
*
* @param {string} key Normalized key. (ie ngAttribute) .
* @param {function(interpolatedValue)} fn Function that will be called whenever
the interpolated value of the attribute changes.
* See the {@link guide/directive#Attributes Directives} guide for more info.
* @returns {function()} the `fn` parameter.
*/ $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 || // no one registered attribute interpolation function, so lets call it manually
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 || // jquery always rewraps, whereas we need to preserve the original selector so that we can
// modify it.
($compileNodes = jqLite($compileNodes)), // We can not compile top level text elements since text nodes can be merged and we will
// not be able to attach scope data to them, so we will wrap them in <span>
forEach($compileNodes, function(node, index) {
3 /* text node */ == 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");
// important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
// and sometimes changes the structure of the DOM.
var $linkNode = cloneConnectFn ? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!
: $compileNodes;
forEach(transcludeControllers, function(instance, name) {
$linkNode.data("$" + name + "Controller", instance);
});
// Attach scope only to non-text nodes.
for(var i = 0, ii = $linkNode.length; i < ii; i++){
var node = $linkNode[i];
(1 /* element */ == node.nodeType || 9 /* document */ == 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) {
// ignore, since it means that we are trying to set class on
// SVG element, where class name is read-only.
}
}
/**
* Compile function matches each node in nodeList against the directives. Once all directives
* for a particular node are collected their compile functions are executed. The compile
* functions return values - the linking functions - are combined into a composite linking
* function, which is the a linking function for the node.
*
* @param {NodeList} nodeList an array of nodes or NodeList to compile
* @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
* scope argument is auto-generated to the new child of the transcluded parent scope.
* @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then
* the rootElement must be set the jqLite collection of the compile root. This is
* needed so that the jqLite collection items can be replaced with widgets.
* @param {number=} max directive priority
* @returns {?function} A composite linking function of all of the matched directives or null.
*/ 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 = // we must always refer to nodeList[i] since the nodes can be replaced underneath us.
(directives = collectDirectives(nodeList[i], [], attrs, 0 === i ? maxPriority : undefined, ignoreDirective)).length ? /**
* Once the directives have been collected, their compile functions are executed. This method
* is responsible for inlining directive templates as well as terminating the application
* of the directives if the terminal directive has been reached.
*
* @param {Array} directives Array of collected directives to execute their compile function.
* this needs to be pre-sorted by priority order.
* @param {Node} compileNode The raw DOM node to apply the compile functions to
* @param {Object} templateAttrs The shared attribute function
* @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
* scope argument is auto-generated to the new
* child of the transcluded parent scope.
* @param {JQLite} jqCollection If we are working on the root of the compile tree then this
* argument has the root jqLite array so that we can replace nodes
* on it.
* @param {Object=} originalReplaceDirective An optional directive that will be ignored when
* compiling the transclusion.
* @param {Array.<Function>} preLinkFns
* @param {Array.<Function>} postLinkFns
* @param {Object} previousCompileContext Context used for previous compilation of the current
* node
* @returns linkFn
*/ function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, jqCollection, originalReplaceDirective, preLinkFns, postLinkFns, previousCompileContext) {
// executes all directives on the current element
for(var newScopeDirective, directive, directiveName, $template, linkFn, directiveValue, terminalPriority = -Number.MAX_VALUE, controllerDirectives = (previousCompileContext = 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; // prevent further processing of directives
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 = ($compileNode = templateAttrs.$$element = jqLite(document1.createComment(" " + directiveName + ": " + templateAttrs[directiveName] + " ")))[0], replaceWith(jqCollection, jqLite(sliceArgs($template)), compileNode), childTranscludeFn = compile($template, transcludeFn, terminalPriority, replaceDirective && replaceDirective.name, {
// Don't pass in:
// - controllerDirectives - otherwise we'll create duplicates controllers
// - newIsolateScopeDirective or templateDirective - combining templates with
// element transclusion doesn't make sense.
//
// We need only nonTlbTranscludeDirective so that we prevent putting transclusion
// on the same element more than once.
nonTlbTranscludeDirective: nonTlbTranscludeDirective
})) : ($template = jqLite(jqLiteClone(compileNode)).contents(), $compileNode.empty(), childTranscludeFn = compile($template, transcludeFn))), directive.template) {
if (assertNoDuplicate("template", templateDirective, directive, $compileNode), templateDirective = directive, directiveValue = denormalizeTemplate(directiveValue = isFunction(directive.template) ? directive.template($compileNode, templateAttrs) : directive.template), directive.replace) {
if (replaceDirective = directive, compileNode = ($template = jqLite("<div>" + trim(directiveValue) + "</div>").contents())[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 = function(directives, $compileNode, tAttrs, $rootElement, childTranscludeFn, preLinkFns, postLinkFns, previousCompileContext) {
var afterTemplateNodeLinkFn, afterTemplateChildLinkFn, linkQueue = [], beforeTemplateCompileNode = $compileNode[0], origAsyncDirective = directives.shift(), // The fact that we have to copy and patch the directive seems wrong!
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 (compileNode = ($template = jqLite("<div>" + trim(content) + "</div>").contents())[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 && (// it was cloned therefore we have to clone as well.
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);
};
}(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 {
linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn), isFunction(linkFn) ? 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));
}
// might be normal or delayed nodeLinkFn depending on if templateUrl is present
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);
} else isArray(require) && (value = [], forEach(require, function(require) {
value.push(getControllers(require, $element, elementControllers));
}));
return value;
}
function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
var attrs, $element, i, ii, linkFn, controller, isolateScope, transcludeFn, elementControllers = {};
if ($element = (attrs = compileNode === linkNode ? templateAttrs : /**
* Create a shallow copy of an object
*/ function(src, dst) {
for(var key in dst = dst || {}, src)// shallowCopy is only ever called by $compile nodeLinkFn, which has control over src
// so we don't need to worry about using our custom hasOwnProperty here
src.hasOwnProperty(key) && "$$" !== key.substr(0, 2) && (dst[key] = src[key]);
return dst;
}(templateAttrs, new Attributes(jqLite(linkNode), templateAttrs.$attr))).$$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] && // If the attribute has been provided then we trigger an interpolation to ensure
// the value is there for use in the link fn
(isolateScope[scopeName] = $interpolate(attrs[attrName])(scope));
break;
case "=":
if (optional && !attrs[attrName]) return;
compare = (parentGet = $parse(attrs[attrName])).literal ? equals : function(a, b) {
return a === b;
}, parentSet = parentGet.assign || function() {
throw(// reset the change, or we will throw this exception on every $digest
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) ? // if the parent can be assigned then do so
parentSet(scope, parentValue = isolateScope[scopeName]) : // parent changed and it has precedence
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);
}
});
}
// PRELINKING
for(transcludeFn = boundTranscludeFn && // This is the function that is injected as `$transclude`.
function(scope, cloneAttachFn) {
var transcludeControllers;
return arguments.length < 2 && (cloneAttachFn = scope, scope = undefined), hasElementTranscludeDirective && (transcludeControllers = elementControllers), 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), // For directives with element transclusion the element is a comment,
// but jQuery .data doesn't support attaching data to comment nodes as it's hard to
// clean up (http://bugs.jquery.com/ticket/8335).
// Instead, we save the controllers for the element in a local hash and attach to .data
// later, once we have the actual element.
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));
}
// RECURSION
// We only pass the isolate scope, if the isolate directive has a template,
// otherwise the child elements do not belong to the isolate directive.
var scopeToChild = scope;
// POSTLINKING
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));
}
}
}(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, //use the previous context only for the first element in the virtual group
previousCompileContext = null;
// return a linking function if we have found anything, null otherwise
return linkFnFound ? function(scope, nodeList, $rootElement, boundTranscludeFn) {
// copy nodeList so that linking doesn't break due to live list updates.
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;
};
}
/**
* Looks for directives on the given node and adds them to the directive collection which is
* sorted.
*
* @param node Node to search.
* @param directives An array to which the directives are added to. This array is sorted before
* the function returns.
* @param attrs The shared attrs object which is used to populate the normalized attributes.
* @param {number=} maxPriority Max directive priority.
*/ function collectDirectives(node, directives, attrs, maxPriority, ignoreDirective) {
var directives1, interpolateFn, match, className, nodeType = node.nodeType, attrsMap = attrs.$attr;
switch(nodeType){
case 1 /* Element */ :
// use the node name: <directive>
addDirective(directives, directiveNormalize(nodeName_(node).toLowerCase()), "E", maxPriority, ignoreDirective);
// iterate over the attributes
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) {
// support ngAttr attribute binding
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), function(node, directives, value, name) {
var interpolateFn = $interpolate(value, !0);
// no interpolation found -> ignore
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.");
// if attribute was updated so that there is no interpolation going on we don't want to
// register any observers
// we need to interpolate again, in case the attribute value has been updated
// (e.g. by another directive's compile function)
(interpolateFn = $interpolate(attr[name], !0, function(node, attrNormalizedName) {
if ("srcdoc" == attrNormalizedName) return $sce.HTML;
var tag = nodeName_(node);
// maction[xlink:href] can source SVG. It's not limited to <maction>.
if ("xlinkHref" == attrNormalizedName || "FORM" == tag && "action" == attrNormalizedName || "IMG" != tag && ("src" == attrNormalizedName || "ngSrc" == attrNormalizedName)) return $sce.RESOURCE_URL;
}(node, name))) && (// TODO(i): this should likely be attr.$set(name, iterpolateFn(scope) so that we reset the
// actual attr value
attr[name] = interpolateFn(scope), ($$observers[name] || ($$observers[name] = [])).$$inter = !0, (attr.$$observers && attr.$$observers[name].$$scope || scope).$watch(interpolateFn, function(newValue, oldValue) {
//special case for class attribute addition + removal
//so that class changes can tap into the animation
//hooks provided by the $animate service. Be sure to
//skip animations when the first digest occurs (when
//both the new and the old values are the same) since
//the CSS classes are the non-interpolated values
"class" === name && newValue != oldValue ? attr.$updateClass(newValue, oldValue) : attr.$set(name, newValue);
}));
}
};
}
});
}
}(node, directives, value, nName), addDirective(directives, nName, "A", maxPriority, ignoreDirective, attrStartName, attrEndName);
}
}
if (isString(// use class as directive
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 /* Text Node */ :
directives1 = directives, (interpolateFn = $interpolate(node.nodeValue, !0)) && directives1.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;
});
})
});
break;
case 8 /* Comment */ :
try {
(match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue)) && (nName = directiveNormalize(match[1]), addDirective(directives, nName, "M", maxPriority, ignoreDirective) && (attrs[nName] = trim(match[2])));
} catch (e) {
// turns out that under some circumstances IE9 throws errors when one attempts to read
// comment's node value.
// Just ignore it and continue. (Can't seem to reproduce in test case.)
}
}
return directives.sort(byPriority), directives;
}
/**
* Given a node with an directive-start it collects all of the siblings until it finds
* directive-end.
* @param node
* @param attrStart
* @param attrEnd
* @returns {*}
*/ 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 /** Element **/ == 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);
}
/**
* Wrapper for linking function which converts normal linking function into a grouped
* linking function.
* @param linkFn
* @param attrStart
* @param attrEnd
* @returns {Function}
*/ function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {
return function(scope, element, attrs, controllers, transcludeFn) {
return linkFn(scope, element = groupScan(element[0], attrStart, attrEnd), attrs, controllers, transcludeFn);
};
}
function markDirectivesAsIsolate(directives) {
// mark all directives as needing isolate scope.
for(var j = 0, jj = directives.length; j < jj; j++)directives[j] = inherit(directives[j], {
$$isolateScope: !0
});
}
/**
* looks up the directive and decorates it with exception handling and proper parameters. We
* call this the boundDirective.
*
* @param {string} name name of the directive to look up.
* @param {string} location The directive must be found in specific format.
* String containing any of theses characters:
*
* * `E`: element name
* * `A': attribute
* * `C`: class
* * `M`: comment
* @returns true if directive was added.
*/ 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 + Suffix), 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;
}
/**
* When the element is replaced with HTML template then the new attributes
* on the template need to be merged with the existing attributes in the DOM.
* The desired effect is to have both of the attributes present.
*
* @param {object} dst destination attributes (original DOM)
* @param {object} src source attributes (from the directive template)
*/ function mergeTemplateAttributes(dst, src) {
var srcAttr = src.$attr, dstAttr = dst.$attr, $element = dst.$$element;
// reapply the old attributes to the new element
forEach(dst, function(value, key) {
"$" != key.charAt(0) && (src[key] && (value += ("style" === key ? ";" : " ") + src[key]), dst.$set(key, value, !0, srcAttr[key]));
}), // copy the new attributes on the old attrs object
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]);
});
}
/**
* Sorting function for bound directives.
*/ 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));
}
/**
* This is a special jqLite.replaceWith, which can replace items which
* have no parents, provided that the containing jqLite collection is provided.
*
* @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes
* in the root of the tree.
* @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep
* the shell, but replace its DOM node reference.
* @param {Node} newNode The new DOM node.
*/ 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 = document1.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);
}
}
];
}
/**
* @ngdoc service
* @name ng.$compileProvider
* @function
*
* @description
*/ $CompileProvider.$inject = [
"$provide",
"$$sanitizeUriProvider"
];
var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;
/**
* Converts all accepted directives format into proper directive name.
* All of these will become 'myDirective':
* my:Directive
* my-directive
* x-my-directive
* data-my:directive
*
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/ 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;
}
/**
* @ngdoc object
* @name ng.$controllerProvider
* @description
* The {@link ng.$controller $controller service} is used by Angular to create new
* controllers.
*
* This provider allows controller registration via the
* {@link ng.$controllerProvider#methods_register register} method.
*/ function $ControllerProvider() {
var controllers = {}, CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
/**
* @ngdoc function
* @name ng.$controllerProvider#register
* @methodOf ng.$controllerProvider
* @param {string|Object} name Controller name, or an object map of controllers where the keys are
* the names and the values are the constructors.
* @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
* annotations in the array notation).
*/ this.register = function(name, constructor) {
assertNotHasOwnProperty(name, "controller"), isObject(name) ? extend(controllers, name) : controllers[name] = constructor;
}, this.$get = [
"$injector",
"$window",
function($injector, $window) {
/**
* @ngdoc function
* @name ng.$controller
* @requires $injector
*
* @param {Function|string} constructor If called with a function then it's considered to be the
* controller constructor function. Otherwise it's considered to be a string which is used
* to retrieve the controller constructor using the following steps:
*
* * check if a controller with given name is registered via `$controllerProvider`
* * check if evaluating the string on the current scope returns a constructor
* * check `window[constructor]` on the global `window` object
*
* @param {Object} locals Injection locals for Controller.
* @return {Object} Instance of given controller.
*
* @description
* `$controller` service is responsible for instantiating controllers.
*
* It's just a simple call to {@link AUTO.$injector $injector}, but extracted into
* a service, so that one can override this service with {@link https://gist.github.com/1649788
* BC version}.
*/ 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;
};
}
];
}
/**
* @ngdoc object
* @name ng.$document
* @requires $window
*
* @description
* A {@link angular.element jQuery (lite)}-wrapped reference to the browser's `window.document`
* element.
*/ function $DocumentProvider() {
this.$get = [
"$window",
function(window1) {
return jqLite(window1.document);
}
];
}
/**
* @ngdoc function
* @name ng.$exceptionHandler
* @requires $log
*
* @description
* Any uncaught exception in angular expressions is delegated to this service.
* The default implementation simply delegates to `$log.error` which logs it into
* the browser console.
*
* In unit tests, if `angular-mocks.js` is loaded, this service is overridden by
* {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
*
* ## Example:
*
* <pre>
* angular.module('exceptionOverride', []).factory('$exceptionHandler', function () {
* return function (exception, cause) {
* exception.message += ' (caused by "' + cause + '")';
* throw exception;
* };
* });
* </pre>
*
* This example will override the normal action of `$exceptionHandler`, to make angular
* exceptions fail hard when they happen, instead of just logging to the console.
*
* @param {Error} exception Exception associated with the error.
* @param {string=} cause optional information about the context in which
* the error was thrown.
*
*/ function $ExceptionHandlerProvider() {
this.$get = [
"$log",
function($log) {
return function(exception, cause) {
$log.error.apply($log, arguments);
};
}
];
}
/**
* Parse headers into key value object
*
* @param {string} headers Raw headers as a string
* @returns {Object} Parsed headers as key value object
*/ 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;
}
/**
* Returns a function that provides access to parsed headers.
*
* Headers are lazy parsed when first requested.
* @see parseHeaders
*
* @param {(string|Object)} headers Headers to provide access to.
* @returns {function(string=)} Returns a getter function which if called with:
*
* - if called with single an argument returns a single header value or null
* - if called with no arguments returns an object containing all headers.
*/ function headersGetter(headers) {
var headersObj = isObject(headers) ? headers : undefined;
return function(name) {
return (headersObj || (headersObj = parseHeaders(headers)), name) ? headersObj[lowercase(name)] || null : headersObj;
};
}
/**
* Chain all given functions
*
* This function is used for both request and response transforming
*
* @param {*} data Data to transform.
* @param {function(string=)} headers Http headers getter fn.
* @param {(function|Array.<function>)} fns Function or an array of functions.
* @returns {*} Transformed data.
*/ 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 = {
// transform incoming response data
transformResponse: [
function(data) {
return isString(data) && (// strip json vulnerability protection prefix
data = data.replace(PROTECTION_PREFIX, ""), JSON_START.test(data) && JSON_END.test(data) && (data = fromJson(data))), data;
}
],
// transform outgoing request data
transformRequest: [
function(d) {
return isObject(d) && "[object File]" !== toString.call(d) ? toJson(d) : d;
}
],
// default headers
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 = [];
/**
* @ngdoc function
* @name ng.$http
* @requires $httpBackend
* @requires $browser
* @requires $cacheFactory
* @requires $rootScope
* @requires $q
* @requires $injector
*
* @description
* The `$http` service is a core Angular service that facilitates communication with the remote
* HTTP servers via the browser's {@link https://developer.mozilla.org/en/xmlhttprequest
* XMLHttpRequest} object or via {@link http://en.wikipedia.org/wiki/JSONP JSONP}.
*
* For unit testing applications that use `$http` service, see
* {@link ngMock.$httpBackend $httpBackend mock}.
*
* For a higher level of abstraction, please check out the {@link ngResource.$resource
* $resource} service.
*
* The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
* the $q service. While for simple usage patterns this doesn't matter much, for advanced usage
* it is important to familiarize yourself with these APIs and the guarantees they provide.
*
*
* # General usage
* The `$http` service is a function which takes a single argument — a configuration object —
* that is used to generate an HTTP request and returns a {@link ng.$q promise}
* with two $http specific methods: `success` and `error`.
*
* <pre>
* $http({method: 'GET', url: '/someUrl'}).
* success(function(data, status, headers, config) {
* // this callback will be called asynchronously
* // when the response is available
* }).
* error(function(data, status, headers, config) {
* // called asynchronously if an error occurs
* // or server returns response with an error status.
* });
* </pre>
*
* Since the returned value of calling the $http function is a `promise`, you can also use
* the `then` method to register callbacks, and these callbacks will receive a single argument –
* an object representing the response. See the API signature and type info below for more
* details.
*
* A response status code between 200 and 299 is considered a success status and
* will result in the success callback being called. Note that if the response is a redirect,
* XMLHttpRequest will transparently follow it, meaning that the error callback will not be
* called for such responses.
*
* # Calling $http from outside AngularJS
* The `$http` service will not actually send the request until the next `$digest()` is
* executed. Normally this is not an issue, since almost all the time your call to `$http` will
* be from within a `$apply()` block.
* If you are calling `$http` from outside Angular, then you should wrap it in a call to
* `$apply` to cause a $digest to occur and also to handle errors in the block correctly.
*
* ```
* $scope.$apply(function() {
* $http(...);
* });
* ```
*
* # Writing Unit Tests that use $http
* When unit testing you are mostly responsible for scheduling the `$digest` cycle. If you do
* not trigger a `$digest` before calling `$httpBackend.flush()` then the request will not have
* been made and `$httpBackend.expect(...)` expectations will fail. The solution is to run the
* code that calls the `$http()` method inside a $apply block as explained in the previous
* section.
*
* ```
* $httpBackend.expectGET(...);
* $scope.$apply(function() {
* $http.get(...);
* });
* $httpBackend.flush();
* ```
*
* # Shortcut methods
*
* Since all invocations of the $http service require passing in an HTTP method and URL, and
* POST/PUT requests require request data to be provided as well, shortcut methods
* were created:
*
* <pre>
* $http.get('/someUrl').success(successCallback);
* $http.post('/someUrl', data).success(successCallback);
* </pre>
*
* Complete list of shortcut methods:
*
* - {@link ng.$http#methods_get $http.get}
* - {@link ng.$http#methods_head $http.head}
* - {@link ng.$http#methods_post $http.post}
* - {@link ng.$http#methods_put $http.put}
* - {@link ng.$http#methods_delete $http.delete}
* - {@link ng.$http#methods_jsonp $http.jsonp}
*
*
* # Setting HTTP Headers
*
* The $http service will automatically add certain HTTP headers to all requests. These defaults
* can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
* object, which currently contains this default configuration:
*
* - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
* - `Accept: application/json, text/plain, * / *`
* - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)
* - `Content-Type: application/json`
* - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)
* - `Content-Type: application/json`
*
* To add or overwrite these defaults, simply add or remove a property from these configuration
* objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
* with the lowercased HTTP method name as the key, e.g.
* `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }.
*
* The defaults can also be set at runtime via the `$http.defaults` object in the same
* fashion. In addition, you can supply a `headers` property in the config object passed when
* calling `$http(config)`, which overrides the defaults without changing them globally.
*
*
* # Transforming Requests and Responses
*
* Both requests and responses can be transformed using transform functions. By default, Angular
* applies these transformations:
*
* Request transformations:
*
* - If the `data` property of the request configuration object contains an object, serialize it
* into JSON format.
*
* Response transformations:
*
* - If XSRF prefix is detected, strip it (see Security Considerations section below).
* - If JSON response is detected, deserialize it using a JSON parser.
*
* To globally augment or override the default transforms, modify the
* `$httpProvider.defaults.transformRequest` and `$httpProvider.defaults.transformResponse`
* properties. These properties are by default an array of transform functions, which allows you
* to `push` or `unshift` a new transformation function into the transformation chain. You can
* also decide to completely override any default transformations by assigning your
* transformation functions to these properties directly without the array wrapper.
*
* Similarly, to locally override the request/response transforms, augment the
* `transformRequest` and/or `transformResponse` properties of the configuration object passed
* into `$http`.
*
*
* # Caching
*
* To enable caching, set the request configuration `cache` property to `true` (to use default
* cache) or to a custom cache object (built with {@link ng.$cacheFactory `$cacheFactory`}).
* When the cache is enabled, `$http` stores the response from the server in the specified
* cache. The next time the same request is made, the response is served from the cache without
* sending a request to the server.
*
* Note that even if the response is served from cache, delivery of the data is asynchronous in
* the same way that real requests are.
*
* If there are multiple GET requests for the same URL that should be cached using the same
* cache, but the cache is not populated yet, only one request to the server will be made and
* the remaining requests will be fulfilled using the response from the first request.
*
* You can change the default cache to a new object (built with
* {@link ng.$cacheFactory `$cacheFactory`}) by updating the
* {@link ng.$http#properties_defaults `$http.defaults.cache`} property. All requests who set
* their `cache` property to `true` will now use this cache object.
*
* If you set the default cache to `false` then only requests that specify their own custom
* cache object will be cached.
*
* # Interceptors
*
* Before you start creating interceptors, be sure to understand the
* {@link ng.$q $q and deferred/promise APIs}.
*
* For purposes of global error handling, authentication, or any kind of synchronous or
* asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
* able to intercept requests before they are handed to the server and
* responses before they are handed over to the application code that
* initiated these requests. The interceptors leverage the {@link ng.$q
* promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.
*
* The interceptors are service factories that are registered with the `$httpProvider` by
* adding them to the `$httpProvider.interceptors` array. The factory is called and
* injected with dependencies (if specified) and returns the interceptor.
*
* There are two kinds of interceptors (and two kinds of rejection interceptors):
*
* * `request`: interceptors get called with http `config` object. The function is free to
* modify the `config` or create a new one. The function needs to return the `config`
* directly or as a promise.
* * `requestError`: interceptor gets called when a previous interceptor threw an error or
* resolved with a rejection.
* * `response`: interceptors get called with http `response` object. The function is free to
* modify the `response` or create a new one. The function needs to return the `response`
* directly or as a promise.
* * `responseError`: interceptor gets called when a previous interceptor threw an error or
* resolved with a rejection.
*
*
* <pre>
* // register the interceptor as a service
* $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
* return {
* // optional method
* 'request': function(config) {
* // do something on success
* return config || $q.when(config);
* },
*
* // optional method
* 'requestError': function(rejection) {
* // do something on error
* if (canRecover(rejection)) {
* return responseOrNewPromise
* }
* return $q.reject(rejection);
* },
*
*
*
* // optional method
* 'response': function(response) {
* // do something on success
* return response || $q.when(response);
* },
*
* // optional method
* 'responseError': function(rejection) {
* // do something on error
* if (canRecover(rejection)) {
* return responseOrNewPromise
* }
* return $q.reject(rejection);
* };
* }
* });
*
* $httpProvider.interceptors.push('myHttpInterceptor');
*
*
* // register the interceptor via an anonymous factory
* $httpProvider.interceptors.push(function($q, dependency1, dependency2) {
* return {
* 'request': function(config) {
* // same as above
* },
* 'response': function(response) {
* // same as above
* }
* };
* });
* </pre>
*
* # Response interceptors (DEPRECATED)
*
* Before you start creating interceptors, be sure to understand the
* {@link ng.$q $q and deferred/promise APIs}.
*
* For purposes of global error handling, authentication or any kind of synchronous or
* asynchronous preprocessing of received responses, it is desirable to be able to intercept
* responses for http requests before they are handed over to the application code that
* initiated these requests. The response interceptors leverage the {@link ng.$q
* promise apis} to fulfil this need for both synchronous and asynchronous preprocessing.
*
* The interceptors are service factories that are registered with the $httpProvider by
* adding them to the `$httpProvider.responseInterceptors` array. The factory is called and
* injected with dependencies (if specified) and returns the interceptor — a function that
* takes a {@link ng.$q promise} and returns the original or a new promise.
*
* <pre>
* // register the interceptor as a service
* $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
* return function(promise) {
* return promise.then(function(response) {
* // do something on success
* return response;
* }, function(response) {
* // do something on error
* if (canRecover(response)) {
* return responseOrNewPromise
* }
* return $q.reject(response);
* });
* }
* });
*
* $httpProvider.responseInterceptors.push('myHttpInterceptor');
*
*
* // register the interceptor via an anonymous factory
* $httpProvider.responseInterceptors.push(function($q, dependency1, dependency2) {
* return function(promise) {
* // same as above
* }
* });
* </pre>
*
*
* # Security Considerations
*
* When designing web applications, consider security threats from:
*
* - {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
* JSON vulnerability}
* - {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF}
*
* Both server and the client must cooperate in order to eliminate these threats. Angular comes
* pre-configured with strategies that address these issues, but for this to work backend server
* cooperation is required.
*
* ## JSON Vulnerability Protection
*
* A {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
* JSON vulnerability} allows third party website to turn your JSON resource URL into
* {@link http://en.wikipedia.org/wiki/JSONP JSONP} request under some conditions. To
* counter this your server can prefix all JSON requests with following string `")]}',\n"`.
* Angular will automatically strip the prefix before processing it as JSON.
*
* For example if your server needs to return:
* <pre>
* ['one','two']
* </pre>
*
* which is vulnerable to attack, your server can return:
* <pre>
* )]}',
* ['one','two']
* </pre>
*
* Angular will strip the prefix, before processing the JSON.
*
*
* ## Cross Site Request Forgery (XSRF) Protection
*
* {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF} is a technique by which
* an unauthorized site can gain your user's private data. Angular provides a mechanism
* to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
* (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only
* JavaScript that runs on your domain could read the cookie, your server can be assured that
* the XHR came from JavaScript running on your domain. The header will not be set for
* cross-domain requests.
*
* To take advantage of this, your server needs to set a token in a JavaScript readable session
* cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
* server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure
* that only JavaScript running on your domain could have sent the request. The token must be
* unique for each user and must be verifiable by the server (to prevent the JavaScript from
* making up its own tokens). We recommend that the token is a digest of your site's
* authentication cookie with a {@link https://en.wikipedia.org/wiki/Salt_(cryptography) salt}
* for added security.
*
* The name of the headers can be specified using the xsrfHeaderName and xsrfCookieName
* properties of either $httpProvider.defaults, or the per-request config object.
*
*
* @param {object} config Object describing the request to be made and how it should be
* processed. The object has following properties:
*
* - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
* - **url** – `{string}` – Absolute or relative URL of the resource that is being requested.
* - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be turned
* to `?key1=value1&key2=value2` after the url. If the value is not a string, it will be
* JSONified.
* - **data** – `{string|Object}` – Data to be sent as the request message data.
* - **headers** – `{Object}` – Map of strings or functions which return strings representing
* HTTP headers to send to the server. If the return value of a function is null, the
* header will not be sent.
* - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.
* - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
* - **transformRequest** –
* `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
* transform function or an array of such functions. The transform function takes the http
* request body and headers and returns its transformed (typically serialized) version.
* - **transformResponse** –
* `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
* transform function or an array of such functions. The transform function takes the http
* response body and headers and returns its transformed (typically deserialized) version.
* - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
* GET request, otherwise if a cache instance built with
* {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
* caching.
* - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
* that should abort the request when resolved.
* - **withCredentials** - `{boolean}` - whether to to set the `withCredentials` flag on the
* XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
* requests with credentials} for more information.
* - **responseType** - `{string}` - see {@link
* https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType requestType}.
*
* @returns {HttpPromise} Returns a {@link ng.$q promise} object with the
* standard `then` method and two http specific methods: `success` and `error`. The `then`
* method takes two arguments a success and an error callback which will be called with a
* response object. The `success` and `error` methods take a single argument - a function that
* will be called when the request succeeds or fails respectively. The arguments passed into
* these functions are destructured representation of the response object passed into the
* `then` method. The response object has these properties:
*
* - **data** – `{string|Object}` – The response body transformed with the transform
* functions.
* - **status** – `{number}` – HTTP status code of the response.
* - **headers** – `{function([headerName])}` – Header getter function.
* - **config** – `{Object}` – The configuration object that was used to generate the request.
*
* @property {Array.<Object>} pendingRequests Array of config objects for currently pending
* requests. This is primarily meant to be used for debugging purposes.
*
*
* @example
<example>
<file name="index.html">
<div ng-controller="FetchCtrl">
<select ng-model="method">
<option>GET</option>
<option>JSONP</option>
</select>
<input type="text" ng-model="url" size="80"/>
<button ng-click="fetch()">fetch</button><br>
<button ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button>
<button
ng-click="updateModel('JSONP',
'http://angularjs.org/greet.php?callback=JSON_CALLBACK&name=Super%20Hero')">
Sample JSONP
</button>
<button
ng-click="updateModel('JSONP', 'http://angularjs.org/doesntexist&callback=JSON_CALLBACK')">
Invalid JSONP
</button>
<pre>http status code: {{status}}</pre>
<pre>http response data: {{data}}</pre>
</div>
</file>
<file name="script.js">
function FetchCtrl($scope, $http, $templateCache) {
$scope.method = 'GET';
$scope.url = 'http-hello.html';
$scope.fetch = function() {
$scope.code = null;
$scope.response = null;
$http({method: $scope.method, url: $scope.url, cache: $templateCache}).
success(function(data, status) {
$scope.status = status;
$scope.data = data;
}).
error(function(data, status) {
$scope.data = data || "Request failed";
$scope.status = status;
});
};
$scope.updateModel = function(method, url) {
$scope.method = method;
$scope.url = url;
};
}
</file>
<file name="http-hello.html">
Hello, $http!
</file>
<file name="scenario.js">
it('should make an xhr GET request', function() {
element(':button:contains("Sample GET")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('200');
expect(binding('data')).toMatch(/Hello, \$http!/);
});
it('should make a JSONP request to angularjs.org', function() {
element(':button:contains("Sample JSONP")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('200');
expect(binding('data')).toMatch(/Super Hero!/);
});
it('should make JSONP request to invalid URL and invoke the error handler',
function() {
element(':button:contains("Invalid JSONP")').click();
element(':button:contains("fetch")').click();
expect(binding('status')).toBe('0');
expect(binding('data')).toBe('Request failed');
});
</file>
</example>
*/ 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);
// execute if header value is function
execHeaders(defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)])), execHeaders(reqHeaders);
// using for-in instead of forEach to avoid unecessary iteration after header has been found
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);
// send request
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), /**
* Makes the request.
*
* !!! ACCESSES CLOSURE VARS:
* $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
*/ (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(void 0, 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);
if ($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), cache) {
if (isDefined(cachedResp = cache.get(url))) {
if (cachedResp.then) return(// cached request has already been sent, but there is no response yet
cachedResp.then(removePendingReq, removePendingReq), cachedResp);
// serving from cache
isArray(cachedResp) ? resolvePromise(cachedResp[1], cachedResp[0], copy(cachedResp[2])) : resolvePromise(cachedResp, 200, {});
} else // put the promise for the non-transformed response into cache as a placeholder
cache.put(url, promise);
}
return isUndefined(cachedResp) && $httpBackend(config.method, url, reqData, /**
* Callback registered to $httpBackend():
* - caches the response if desired
* - resolves the raw $http promise
* - calls $apply
*/ function(status, response, headersString) {
cache && (isSuccess(status) ? cache.put(url, [
status,
response,
parseHeaders(headersString)
]) : // remove promise from the cache
cache.remove(url)), resolvePromise(response, status, headersString), $rootScope.$$phase || $rootScope.$apply();
}, reqHeaders, config.timeout, config.withCredentials, config.responseType), promise;
/**
* Resolves the raw $http promise.
*/ function resolvePromise(response, status, headers) {
(isSuccess(// normalize internal statuses to 0
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(// apply interceptors
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) {
// make a copy since the response must be cacheable
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);
/**
* Response interceptors go before "around" interceptors (no real reason, just
* had to pick one.) But they are already reversed, so we can't use unshift, hence
* the splice.
*/ reversedInterceptors.splice(index, 0, {
response: function(response) {
return responseFn($q.when(response));
},
responseError: function(response) {
return responseFn($q.reject(response));
}
});
}), $http.pendingRequests = [], /**
* @ngdoc method
* @name ng.$http#get
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `GET` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ /**
* @ngdoc method
* @name ng.$http#delete
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `DELETE` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ /**
* @ngdoc method
* @name ng.$http#head
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `HEAD` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ /**
* @ngdoc method
* @name ng.$http#jsonp
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `JSONP` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request.
* Should contain `JSON_CALLBACK` string.
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ function(names) {
forEach(arguments, function(name) {
$http[name] = function(url, config) {
return $http(extend(config || {}, {
method: name,
url: url
}));
};
});
}("get", "delete", "head", "jsonp"), /**
* @ngdoc method
* @name ng.$http#post
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `POST` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {*} data Request content
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ /**
* @ngdoc method
* @name ng.$http#put
* @methodOf ng.$http
*
* @description
* Shortcut method to perform `PUT` request.
*
* @param {string} url Relative or absolute URL specifying the destination of the request
* @param {*} data Request content
* @param {Object=} config Optional configuration object
* @returns {HttpPromise} Future object
*/ function(name) {
forEach(arguments, function(name) {
$http[name] = function(url, data, config) {
return $http(extend(config || {}, {
method: name,
url: url,
data: data
}));
};
});
}("post", "put"), /**
* @ngdoc property
* @name ng.$http#defaults
* @propertyOf ng.$http
*
* @description
* Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
* default headers, withCredentials as well as request and response transformations.
*
* See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
*/ $http.defaults = defaults, $http;
}
];
}
var XHR = window1.XMLHttpRequest || function() {
/* global ActiveXObject */ 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.");
};
/**
* @ngdoc object
* @name ng.$httpBackend
* @requires $browser
* @requires $window
* @requires $document
*
* @description
* HTTP backend used by the {@link ng.$http service} that delegates to
* XMLHttpRequest object or JSONP and deals with browser incompatibilities.
*
* You should never need to use this service directly, instead use the higher-level abstractions:
* {@link ng.$http $http} or {@link ngResource.$resource $resource}.
*
* During testing this implementation is swapped with {@link ngMock.$httpBackend mock
* $httpBackend} which can be trained with responses.
*/ function $HttpBackendProvider() {
this.$get = [
"$browser",
"$window",
"$document",
function($browser, $window, $document) {
var $browser1, XHR1, $browserDefer, callbacks, rawDocument;
return $browser1 = $browser, XHR1 = XHR, $browserDefer = $browser.defer, callbacks = $window.angular.callbacks, rawDocument = $document[0], function(method, url, post, callback, headers, timeout, withCredentials, responseType) {
var status;
if ($browser1.$$incOutstandingRequestCount(), url = url || $browser1.url(), "jsonp" == lowercase(method)) {
var url1, done, script, doneWrapper, callbackId = "_" + (callbacks.counter++).toString(36);
callbacks[callbackId] = function(data) {
callbacks[callbackId].data = data;
};
var jsonpDone = (url1 = url.replace("JSON_CALLBACK", "angular.callbacks." + callbackId), done = function() {
callbacks[callbackId].data ? completeRequest(callback, 200, callbacks[callbackId].data) : completeRequest(callback, status || -2), delete callbacks[callbackId];
}, script = rawDocument.createElement("script"), doneWrapper = function() {
script.onreadystatechange = script.onload = script.onerror = null, rawDocument.body.removeChild(script), done && done();
}, script.type = "text/javascript", script.src = url1, msie && msie <= 8 ? script.onreadystatechange = function() {
/loaded|complete/.test(script.readyState) && doneWrapper();
} : script.onload = script.onerror = function() {
doneWrapper();
}, rawDocument.body.appendChild(script), doneWrapper);
} else {
var xhr = new XHR1();
xhr.open(method, url, !0), forEach(headers, function(value, key) {
isDefined(value) && xhr.setRequestHeader(key, value);
}), // In IE6 and 7, this might be called synchronously when xhr.send below is called and the
// response is in the cache. the promise api will ensure that to the app code the api is
// always async
xhr.onreadystatechange = function() {
if (4 == xhr.readyState) {
var responseHeaders = null, response = null;
-1 !== status && (responseHeaders = xhr.getAllResponseHeaders(), response = xhr.responseType ? xhr.response : xhr.responseText), // responseText is the old-school way of retrieving response (supported by IE8 & 9)
// response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
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 = -1, jsonpDone && jsonpDone(), xhr && xhr.abort();
}
function completeRequest(callback, status, response, headersString) {
var protocol = urlResolve(url).protocol;
// cancel timeout and subsequent timeout promise resolution
timeoutId && $browserDefer.cancel(timeoutId), jsonpDone = xhr = null, callback(// normalize IE bug (http://bugs.jquery.com/ticket/1450)
status = 1223 == // fix status code for file protocol (it's always 0)
(status = "file" == protocol && 0 === status ? response ? 200 : 404 : status) ? 204 : status, response, headersString), $browser1.$$completeOutstandingRequest(noop);
}
};
}
];
}
var $interpolateMinErr = minErr("$interpolate");
/**
* @ngdoc object
* @name ng.$interpolateProvider
* @function
*
* @description
*
* Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
*
* @example
<doc:example module="customInterpolationApp">
<doc:source>
<script>
var customInterpolationApp = angular.module('customInterpolationApp', []);
customInterpolationApp.config(function($interpolateProvider) {
$interpolateProvider.startSymbol('//');
$interpolateProvider.endSymbol('//');
});
customInterpolationApp.controller('DemoController', function DemoController() {
this.label = "This binding is brought you by // interpolation symbols.";
});
</script>
<div ng-app="App" ng-controller="DemoController as demo">
//demo.label//
</div>
</doc:source>
<doc:scenario>
it('should interpolate binding with custom symbols', function() {
expect(binding('demo.label')).toBe('This binding is brought you by // interpolation symbols.');
});
</doc:scenario>
</doc:example>
*/ function $InterpolateProvider() {
var startSymbol = "{{", endSymbol = "}}";
/**
* @ngdoc method
* @name ng.$interpolateProvider#startSymbol
* @methodOf ng.$interpolateProvider
* @description
* Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
*
* @param {string=} value new value to set the starting symbol to.
* @returns {string|self} Returns the symbol when used as getter and self if used as setter.
*/ this.startSymbol = function(value) {
return value ? (startSymbol = value, this) : startSymbol;
}, /**
* @ngdoc method
* @name ng.$interpolateProvider#endSymbol
* @methodOf ng.$interpolateProvider
* @description
* Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
*
* @param {string=} value new value to set the ending symbol to.
* @returns {string|self} Returns the symbol when used as getter and self if used as setter.
*/ 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;
/**
* @ngdoc function
* @name ng.$interpolate
* @function
*
* @requires $parse
* @requires $sce
*
* @description
*
* Compiles a string with markup into an interpolation function. This service is used by the
* HTML {@link ng.$compile $compile} service for data binding. See
* {@link ng.$interpolateProvider $interpolateProvider} for configuring the
* interpolation markup.
*
*
<pre>
var $interpolate = ...; // injected
var exp = $interpolate('Hello {{name | uppercase}}!');
expect(exp({name:'Angular'}).toEqual('Hello ANGULAR!');
</pre>
*
*
* @param {string} text The text with markup to interpolate.
* @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
* embedded expression in order to return an interpolation function. Strings with no
* embedded expression will return null for the interpolation function.
* @param {string=} trustedContext when provided, the returned function passes the interpolated
* result through {@link ng.$sce#methods_getTrusted $sce.getTrusted(interpolatedResult,
* trustedContext)} before returning it. Refer to the {@link ng.$sce $sce} service that
* provides Strict Contextual Escaping for details.
* @returns {function(context)} an interpolation function which is used to compute the
* interpolated string. The function has these parameters:
*
* * `context`: an object against which any expressions embedded in the strings are evaluated
* against.
*
*/ 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) : (// we did not find anything, so we have to add the remainder to the parts array
index != length && parts.push(text.substring(index)), index = length);
// Concatenating expressions makes it hard to reason about whether some combination of
// concatenated values are unsafe to use and could easily lead to XSS. By requiring that a
// single expression be used for iframe[src], object[src], etc., we ensure that the value
// that's used is assigned or constructed by some JS code somewhere that is more testable or
// make it obvious that you bound the value to some user controlled value. This helps reduce
// the load when auditing for XSS issues.
if ((length = parts.length) || (// we added, nothing, must have been an empty string.
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), part = trustedContext ? $sce.getTrusted(trustedContext, part) : $sce.valueOf(part), null === part || isUndefined(part) ? part = "" : "string" != typeof part && (part = toJson(part))), concat[i] = part;
return concat.join("");
} catch (err) {
$exceptionHandler($interpolateMinErr("interr", "Can't interpolate: {0}\n{1}", text, err.toString()));
}
}).exp = text, fn.parts = parts, fn;
}
return(/**
* @ngdoc method
* @name ng.$interpolate#startSymbol
* @methodOf ng.$interpolate
* @description
* Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
*
* Use {@link ng.$interpolateProvider#startSymbol $interpolateProvider#startSymbol} to change
* the symbol.
*
* @returns {string} start symbol.
*/ $interpolate.startSymbol = function() {
return startSymbol;
}, /**
* @ngdoc method
* @name ng.$interpolate#endSymbol
* @methodOf ng.$interpolate
* @description
* Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
*
* Use {@link ng.$interpolateProvider#endSymbol $interpolateProvider#endSymbol} to change
* the symbol.
*
* @returns {string} start symbol.
*/ $interpolate.endSymbol = function() {
return endSymbol;
}, $interpolate);
}
];
}
function $IntervalProvider() {
this.$get = [
"$rootScope",
"$window",
"$q",
function($rootScope, $window, $q) {
var intervals = {};
/**
* @ngdoc function
* @name ng.$interval
*
* @description
* Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
* milliseconds.
*
* The return value of registering an interval function is a promise. This promise will be
* notified upon each tick of the interval, and will be resolved after `count` iterations, or
* run indefinitely if `count` is not defined. The value of the notification will be the
* number of iterations that have run.
* To cancel an interval, call `$interval.cancel(promise)`.
*
* In tests you can use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to
* move forward by `millis` milliseconds and trigger any functions scheduled to run in that
* time.
*
* @param {function()} fn A function that should be called repeatedly.
* @param {number} delay Number of milliseconds between each function call.
* @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
* indefinitely.
* @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
* will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
* @returns {promise} A promise which will be notified on each iteration.
*/ function interval(fn, delay, count, invokeApply) {
var setInterval = $window.setInterval, clearInterval1 = $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), clearInterval1(promise.$$intervalId), delete intervals[promise.$$intervalId]), skipApply || $rootScope.$apply();
}, delay), intervals[promise.$$intervalId] = deferred, promise;
}
return(/**
* @ngdoc function
* @name ng.$interval#cancel
* @methodOf ng.$interval
*
* @description
* Cancels a task associated with the `promise`.
*
* @param {number} promise Promise returned by the `$interval` function.
* @returns {boolean} Returns `true` if the task was successfully canceled.
*/ interval.cancel = function(promise) {
return !!promise && promise.$$intervalId in intervals && (intervals[promise.$$intervalId].reject("canceled"), clearInterval(promise.$$intervalId), delete intervals[promise.$$intervalId], !0);
}, interval);
}
];
}
/**
* @ngdoc object
* @name ng.$locale
*
* @description
* $locale service provides localization rules for various Angular components. As of right now the
* only public api is:
*
* * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`)
*/ function $LocaleProvider() {
this.$get = function() {
return {
id: "en-us",
NUMBER_FORMATS: {
DECIMAL_SEP: ".",
GROUP_SEP: ",",
PATTERNS: [
{
// Decimal Pattern
minInt: 1,
minFrac: 0,
maxFrac: 3,
posPre: "",
posSuf: "",
negPre: "-",
negSuf: "",
gSize: 3,
lgSize: 3
},
{
//Currency Pattern
minInt: 1,
minFrac: 2,
maxFrac: 2,
posPre: "\u00A4",
posSuf: "",
negPre: "(\u00A4",
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");
/**
* Encode path using encodeUriSegment, ignoring forward slashes
*
* @param {string} path Path to encode
* @returns {string}
*/ 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);
}
/**
*
* @param {string} begin
* @param {string} whole
* @returns {string} returns text from whole after begin or undefined if it does not begin with
* expected string.
*/ 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);
}
/**
* LocationHtml5Url represents an url
* This object is exposed as $location service when HTML5 mode is enabled and supported
*
* @constructor
* @param {string} appBase application base URL
* @param {string} basePrefix url path prefix
*/ function LocationHtml5Url(appBase, basePrefix) {
this.$$html5 = !0, basePrefix = basePrefix || "";
var appBaseNoFile = stripFile(appBase);
parseAbsoluteUrl(appBase, this, appBase), /**
* Parse given html5 (regular) url string into properties
* @param {string} newAbsoluteUrl HTML5 url
* @private
*/ 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();
}, /**
* Compose url and update `absUrl` property
* @private
*/ 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 (appUrl = beginsWith(appBase, url)) !== undefined ? (prevAppUrl = appUrl, (appUrl = beginsWith(basePrefix, appUrl)) !== undefined) ? appBaseNoFile + (beginsWith("/", appUrl) || appUrl) : appBase + prevAppUrl : (appUrl = beginsWith(appBaseNoFile, url)) !== undefined ? appBaseNoFile + appUrl : appBaseNoFile == url + "/" ? appBaseNoFile : void 0;
};
}
/**
* LocationHashbangUrl represents url
* This object is exposed as $location service when developer doesn't opt into html5 mode.
* It also serves as the base class for html5 mode fallback on legacy browsers.
*
* @constructor
* @param {string} appBase application base URL
* @param {string} hashPrefix hashbang prefix
*/ function LocationHashbangUrl(appBase, hashPrefix) {
var appBaseNoFile = stripFile(appBase);
parseAbsoluteUrl(appBase, this, appBase), /**
* Parse given hashbang url into properties
* @param {string} url Hashbang url
* @private
*/ this.$$parse = function(url) {
var path, url1, base, firstPathSegmentMatch, windowsFilePathExp, 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 = (path = this.$$path, url1 = withoutHashUrl, base = appBase, windowsFilePathExp = /^\/?.*?:(\/.*)/, /*
* The input URL intentionally contains a
* first path segment that ends with a colon.
*/ (0 === url1.indexOf(base) && (url1 = url1.replace(base, "")), windowsFilePathExp.exec(url1)) ? path : (firstPathSegmentMatch = windowsFilePathExp.exec(path)) ? firstPathSegmentMatch[1] : path), this.$$compose();
}, /**
* Compose hashbang url and update `absUrl` property
* @private
*/ 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;
};
}
/**
* LocationHashbangUrl represents url
* This object is exposed as $location service when html5 history api is enabled but the browser
* does not support it.
*
* @constructor
* @param {string} appBase application base URL
* @param {string} hashPrefix hashbang prefix
*/ 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);
};
}
/**
* @ngdoc object
* @name ng.$location
*
* @requires $browser
* @requires $sniffer
* @requires $rootElement
*
* @description
* The $location service parses the URL in the browser address bar (based on the
* {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL
* available to your application. Changes to the URL in the address bar are reflected into
* $location service and changes to $location are reflected into the browser address bar.
*
* **The $location service:**
*
* - Exposes the current URL in the browser address bar, so you can
* - Watch and observe the URL.
* - Change the URL.
* - Synchronizes the URL with the browser when the user
* - Changes the address bar.
* - Clicks the back or forward button (or clicks a History link).
* - Clicks on a link.
* - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
*
* For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular
* Services: Using $location}
*/ /**
* @ngdoc object
* @name ng.$locationProvider
* @description
* Use the `$locationProvider` to configure how the application deep linking paths are stored.
*/ function $LocationProvider() {
var hashPrefix = "", html5Mode = !1;
/**
* @ngdoc property
* @name ng.$locationProvider#hashPrefix
* @methodOf ng.$locationProvider
* @description
* @param {string=} prefix Prefix for hash part (containing path and search)
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/ this.hashPrefix = function(prefix) {
return isDefined(prefix) ? (hashPrefix = prefix, this) : hashPrefix;
}, /**
* @ngdoc property
* @name ng.$locationProvider#html5Mode
* @methodOf ng.$locationProvider
* @description
* @param {boolean=} mode Use HTML5 strategy if available.
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/ this.html5Mode = function(mode) {
return isDefined(mode) ? (html5Mode = mode, this) : html5Mode;
}, /**
* @ngdoc event
* @name ng.$location#$locationChangeStart
* @eventOf ng.$location
* @eventType broadcast on root scope
* @description
* Broadcasted before a URL will change. This change can be prevented by calling
* `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
* details about event object. Upon successful change
* {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
*
* @param {Object} angularEvent Synthetic event object.
* @param {string} newUrl New URL
* @param {string=} oldUrl URL that was before it was changed.
*/ /**
* @ngdoc event
* @name ng.$location#$locationChangeSuccess
* @eventOf ng.$location
* @eventType broadcast on root scope
* @description
* Broadcasted after a URL was changed.
*
* @param {Object} angularEvent Synthetic event object.
* @param {string} newUrl New URL
* @param {string=} oldUrl URL that was before it was changed.
*/ this.$get = [
"$rootScope",
"$browser",
"$sniffer",
"$rootElement",
function($rootScope, $browser, $sniffer, $rootElement) {
var $location, LocationMode, appBase, baseHref = $browser.baseHref(), initialUrl = $browser.url();
html5Mode ? (appBase = initialUrl.substring(0, initialUrl.indexOf("/", initialUrl.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) {
// TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
// currently we open nice url link and redirect then
if (!event.ctrlKey && !event.metaKey && 2 != event.which) {
// traverse the DOM up to find first A tag
for(var elm = jqLite(event.target); "a" !== lowercase(elm[0].nodeName);)// ignore rewriting if no A tag (reached root element, or no parent - removed from document)
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() && (// update location manually
$location.$$parse(rewrittenUrl), $rootScope.$apply(), // hack to work around FF6 bug 684208 when scenario runner clicks on links
window1.angular["ff-684208-preventDefault"] = !0));
}
}), $location.absUrl() != initialUrl && $browser.url($location.absUrl(), !0), // update $location when $browser url changes
$browser.onUrlChange(function(newUrl) {
if ($location.absUrl() != newUrl) {
if ($rootScope.$broadcast("$locationChangeStart", newUrl, $location.absUrl()).defaultPrevented) {
$browser.url($location.absUrl());
return;
}
$rootScope.$evalAsync(function() {
var oldUrl = $location.absUrl();
$location.$$parse(newUrl), afterLocationChange(oldUrl);
}), $rootScope.$$phase || $rootScope.$digest();
}
});
// update browser
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);
}
}
];
}
/**
* @ngdoc object
* @name ng.$log
* @requires $window
*
* @description
* Simple service for logging. Default implementation safely writes the message
* into the browser's console (if present).
*
* The main purpose of this service is to simplify debugging and troubleshooting.
*
* The default is to log `debug` messages. You can use
* {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this.
*
* @example
<example>
<file name="script.js">
function LogCtrl($scope, $log) {
$scope.$log = $log;
$scope.message = 'Hello World!';
}
</file>
<file name="index.html">
<div ng-controller="LogCtrl">
<p>Reload this page with open console, enter text and hit the log button...</p>
Message:
<input type="text" ng-model="message"/>
<button ng-click="$log.log(message)">log</button>
<button ng-click="$log.warn(message)">warn</button>
<button ng-click="$log.info(message)">info</button>
<button ng-click="$log.error(message)">error</button>
</div>
</file>
</example>
*/ /**
* @ngdoc object
* @name ng.$logProvider
* @description
* Use the `$logProvider` to configure how the application logs messages
*/ function $LogProvider() {
var debug = !0, self = this;
/**
* @ngdoc property
* @name ng.$logProvider#debugEnabled
* @methodOf ng.$logProvider
* @description
* @param {string=} flag enable or disable debug level messages
* @returns {*} current value if used as getter or itself (chaining) if used as setter
*/ this.debugEnabled = function(flag) {
return isDefined(flag) ? (debug = flag, this) : debug;
}, this.$get = [
"$window",
function($window) {
var fn;
return {
/**
* @ngdoc method
* @name ng.$log#log
* @methodOf ng.$log
*
* @description
* Write a log message
*/ log: consoleLog("log"),
/**
* @ngdoc method
* @name ng.$log#info
* @methodOf ng.$log
*
* @description
* Write an information message
*/ info: consoleLog("info"),
/**
* @ngdoc method
* @name ng.$log#warn
* @methodOf ng.$log
*
* @description
* Write a warning message
*/ warn: consoleLog("warn"),
/**
* @ngdoc method
* @name ng.$log#error
* @methodOf ng.$log
*
* @description
* Write an error message
*/ error: consoleLog("error"),
/**
* @ngdoc method
* @name ng.$log#debug
* @methodOf ng.$log
*
* @description
* Write a debug message
*/ debug: (fn = consoleLog("debug"), function() {
debug && fn.apply(self, arguments);
})
};
function consoleLog(type) {
var console = $window.console || {}, logFn = console[type] || console.log || noop;
return logFn.apply ? function() {
var args = [];
return forEach(arguments, function(arg) {
var arg1;
args.push(((arg1 = arg) instanceof Error && (arg1.stack ? arg1 = arg1.message && -1 === arg1.stack.indexOf(arg1.message) ? "Error: " + arg1.message + "\n" + arg1.stack : arg1.stack : arg1.sourceURL && (arg1 = arg1.message + "\n" + arg1.sourceURL + ":" + arg1.line)), arg1));
}), logFn.apply(console, args);
} : function(arg1, arg2) {
logFn(arg1, null == arg2 ? "" : arg2);
};
}
}
];
}
LocationHashbangInHtml5Url.prototype = LocationHashbangUrl.prototype = LocationHtml5Url.prototype = {
/**
* Are we in html5 mode?
* @private
*/ $$html5: !1,
/**
* Has any change been replacing ?
* @private
*/ $$replace: !1,
/**
* @ngdoc method
* @name ng.$location#absUrl
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return full url representation with all segments encoded according to rules specified in
* {@link http://www.ietf.org/rfc/rfc3986.txt RFC 3986}.
*
* @return {string} full url
*/ absUrl: locationGetter("$$absUrl"),
/**
* @ngdoc method
* @name ng.$location#url
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return url (e.g. `/path?a=b#hash`) when called without any parameter.
*
* Change path, search and hash, when called with parameter and return `$location`.
*
* @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
* @param {string=} replace The path that will be changed
* @return {string} url
*/ 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;
},
/**
* @ngdoc method
* @name ng.$location#protocol
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return protocol of current url.
*
* @return {string} protocol of current url
*/ protocol: locationGetter("$$protocol"),
/**
* @ngdoc method
* @name ng.$location#host
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return host of current url.
*
* @return {string} host of current url.
*/ host: locationGetter("$$host"),
/**
* @ngdoc method
* @name ng.$location#port
* @methodOf ng.$location
*
* @description
* This method is getter only.
*
* Return port of current url.
*
* @return {Number} port
*/ port: locationGetter("$$port"),
/**
* @ngdoc method
* @name ng.$location#path
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return path of current url when called without any parameter.
*
* Change path when called with parameter and return `$location`.
*
* Note: Path should always begin with forward slash (/), this method will add the forward slash
* if it is missing.
*
* @param {string=} path New path
* @return {string} path
*/ path: locationGetterSetter("$$path", function(path) {
return "/" == path.charAt(0) ? path : "/" + path;
}),
/**
* @ngdoc method
* @name ng.$location#search
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return search part (as object) of current url when called without any parameter.
*
* Change search part when called with parameter and return `$location`.
*
* @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
* hash object. Hash object may contain an array of values, which will be decoded as duplicates in
* the url.
*
* @param {(string|Array<string>)=} paramValue If `search` is a string, then `paramValue` will override only a
* single search parameter. If `paramValue` is an array, it will set the parameter as a
* comma-separated value. If `paramValue` is `null`, the parameter will be deleted.
*
* @return {string} search
*/ 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)) this.$$search = search;
else throw $locationMinErr("isrcharg", "The first argument of the `$location#search()` call must be a string or an object.");
break;
default:
isUndefined(paramValue) || null === paramValue ? delete this.$$search[search] : this.$$search[search] = paramValue;
}
return this.$$compose(), this;
},
/**
* @ngdoc method
* @name ng.$location#hash
* @methodOf ng.$location
*
* @description
* This method is getter / setter.
*
* Return hash fragment when called without any parameter.
*
* Change hash fragment when called with parameter and return `$location`.
*
* @param {string=} hash New hash fragment
* @return {string} hash
*/ hash: locationGetterSetter("$$hash", identity),
/**
* @ngdoc method
* @name ng.$location#replace
* @methodOf ng.$location
*
* @description
* If called, all changes to $location during current `$digest` will be replacing current history
* record, instead of adding new one.
*/ replace: function() {
return this.$$replace = !0, this;
}
};
var $parseMinErr = minErr("$parse"), promiseWarningCache = {};
// Sandboxing Angular Expressions
// ------------------------------
// Angular expressions are generally considered safe because these expressions only have direct
// access to $scope and locals. However, one can obtain the ability to execute arbitrary JS code by
// obtaining a reference to native JS functions such as the Function constructor.
//
// As an example, consider the following Angular expression:
//
// {}.toString.constructor(alert("evil JS code"))
//
// We want to prevent this type of access. For the sake of performance, during the lexing phase we
// disallow any "dotted" access to any member named "constructor".
//
// For reflective calls (a[b]) we check that the value of the lookup is not the Function constructor
// while evaluating the expression, which is a stronger but more expensive test. Since reflective
// calls are expensive anyway, this is not such a big deal compared to static dereferencing.
//
// This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits
// against the expression language, but not to prevent exploits that were enabled by exposing
// sensitive JavaScript or browser apis on Scope. Exposing such objects on a Scope is never a good
// practice and therefore we are not even trying to protect against interaction with an object
// explicitly exposed in this way.
//
// A developer could foil the name check by aliasing the Function constructor under a different
// name on the scope.
//
// In general, it is not possible to access a Window object from an angular expression unless a
// window or some DOM object that has a reference to window is published onto a Scope.
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) {
// nifty check if obj is Function that is fast and works across iframes and other contexts
if (obj) {
if (obj.constructor === obj) throw $parseMinErr("isecfn", "Referencing Function in Angular expressions is disallowed! Expression: {0}", fullExpression);
if (// isWindow(obj)
obj.document && obj.location && obj.alert && obj.setInterval) throw $parseMinErr("isecwindow", "Referencing the Window in Angular expressions is disallowed! Expression: {0}", fullExpression);
if (// isElement(obj)
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 = {
/* jshint bitwise : false */ 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 a|b;},
"|": 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) {
this.text = text, this.index = 0, this.ch = undefined, this.lastCh = ":", this.tokens = [];
for(var token, 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;
} else {
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) {
// IE treats non-breaking space as \u00A0
return " " === ch || "\r" === ch || "\t" === ch || "\n" === ch || "\v" === ch || "\u00A0" === 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) {
throw end = end || this.index, $parseMinErr("lexerr", "Lexer Error: {0} at column{1} in expression [{2}].", error, isDefined(start) ? "s " + start + "-" + this.index + " [" + this.text.substring(start, end) + "]" : " " + end, 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;
else 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++;
//check if this is not a method invocation and if it is back out to last dot
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)) peekIndex++;
else break;
}
var token = {
index: start,
text: ident
};
// OPERATORS is our own object so we don't need to use special hasOwnPropertyFn
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, escape1 = !1; this.index < this.text.length;){
var ch = this.text.charAt(this.index);
if (rawString += ch, escape1) {
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];
rep ? string += rep : string += ch;
}
escape1 = !1;
} else if ("\\" === ch) escape1 = !0;
else if (ch === quote) {
this.index++, this.tokens.push({
index: start,
text: rawString,
string: string,
json: !0,
fn: function() {
return string;
}
});
return;
} else string += ch;
this.index++;
}
this.throwError("Unterminated quote", start);
}
};
/**
* @constructor
*/ var Parser = function(lexer, $filter, options) {
this.lexer = lexer, this.$filter = $filter, this.options = options;
};
//////////////////////////////////////////////////
// Parser helper functions
//////////////////////////////////////////////////
function setter(obj, path, setValue, fullExp, options) {
//needed?
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), obj.$$v === undefined && (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, //TODO(i): strip all the obsolte json stuff from this file
this.json = json, this.tokens = this.lexer.lex(text), json && (// The extra level of aliasing is here, just in case the lexer misses something, so that
// we prevent any accidental execution in 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() {
if (this.expect("(")) primary = this.filterChain(), this.consume(")");
else if (this.expect("[")) primary = this.arrayDeclaration();
else if (this.expect("{")) primary = this.object();
else {
var primary, next, context, 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(";")) // optimize for the common case where there is only one statement.
// TODO(size): maybe we should not support multiple statements?
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(":")) argsFn.push(this.expression());
else {
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;
};
}
},
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);
return o ? ((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) : undefined;
}, {
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);
};
},
// This is used with json array declaration
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 = {};
/**
* Implementation of the "Black Hole" variant from:
* - http://jsperf.com/angularjs-parse-getter/4
* - http://jsperf.com/path-evaluation-simplified/7
*/ 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[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;
} : 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;
};
}
function getterFn(path, options, fullExp) {
// Check whether the cache has this getter already.
// We can use hasOwnProperty directly on the cache because we ensure,
// see below, that the cache never stores a path called 'hasOwnProperty'
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' : "");
});
/* jshint -W054 */ var evaledFnGetter = Function("s", "k", "pw", code += "return s;"); // s=scope, k=locals, pw=promiseWarning
/* jshint +W054 */ evaledFnGetter.toString = function() {
return code;
}, fn = function(scope, locals) {
return evaledFnGetter(scope, locals, promiseWarning);
};
}
return "hasOwnProperty" !== path && (getterFnCache[path] = fn), fn;
}
///////////////////////////////////
/**
* @ngdoc function
* @name ng.$parse
* @function
*
* @description
*
* Converts Angular {@link guide/expression expression} into a function.
*
* <pre>
* var getter = $parse('user.name');
* var setter = getter.assign;
* var context = {user:{name:'angular'}};
* var locals = {user:{name:'local'}};
*
* expect(getter(context)).toEqual('angular');
* setter(context, 'newValue');
* expect(context.user.name).toEqual('newValue');
* expect(getter(context, locals)).toEqual('local');
* </pre>
*
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*
* The returned function also has the following properties:
* * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
* literal.
* * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
* constant literals.
* * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
* set to a function to change its value on the given context.
*
*/ /**
* @ngdoc object
* @name ng.$parseProvider
* @function
*
* @description
* `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
* service.
*/ function $ParseProvider() {
var cache = {}, $parseOptions = {
csp: !1,
unwrapPromises: !1,
logPromiseWarnings: !0
};
/**
* @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
*
* @ngdoc method
* @name ng.$parseProvider#unwrapPromises
* @methodOf ng.$parseProvider
* @description
*
* **This feature is deprecated, see deprecation notes below for more info**
*
* If set to true (default is false), $parse will unwrap promises automatically when a promise is
* found at any part of the expression. In other words, if set to true, the expression will always
* result in a non-promise value.
*
* While the promise is unresolved, it's treated as undefined, but once resolved and fulfilled,
* the fulfillment value is used in place of the promise while evaluating the expression.
*
* **Deprecation notice**
*
* This is a feature that didn't prove to be wildly useful or popular, primarily because of the
* dichotomy between data access in templates (accessed as raw values) and controller code
* (accessed as promises).
*
* In most code we ended up resolving promises manually in controllers anyway and thus unifying
* the model access there.
*
* Other downsides of automatic promise unwrapping:
*
* - when building components it's often desirable to receive the raw promises
* - adds complexity and slows down expression evaluation
* - makes expression code pre-generation unattractive due to the amount of code that needs to be
* generated
* - makes IDE auto-completion and tool support hard
*
* **Warning Logs**
*
* If the unwrapping is enabled, Angular will log a warning about each expression that unwraps a
* promise (to reduce the noise, each expression is logged only once). To disable this logging use
* `$parseProvider.logPromiseWarnings(false)` api.
*
*
* @param {boolean=} value New value.
* @returns {boolean|self} Returns the current setting when used as getter and self if used as
* setter.
*/ this.unwrapPromises = function(value) {
return isDefined(value) ? ($parseOptions.unwrapPromises = !!value, this) : $parseOptions.unwrapPromises;
}, /**
* @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
*
* @ngdoc method
* @name ng.$parseProvider#logPromiseWarnings
* @methodOf ng.$parseProvider
* @description
*
* Controls whether Angular should log a warning on any encounter of a promise in an expression.
*
* The default is set to `true`.
*
* This setting applies only if `$parseProvider.unwrapPromises` setting is set to true as well.
*
* @param {boolean=} value New value.
* @returns {boolean|self} Returns the current setting when used as getter and self if used as
* setter.
*/ 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];
return parsedExpression = new Parser(new Lexer($parseOptions), $filter, $parseOptions).parse(exp, !1), "hasOwnProperty" !== exp && // Only cache the value if it's not going to mess up the cache object
// This is more performant that using Object.prototype.hasOwnProperty.call
(cache[exp] = parsedExpression), parsedExpression;
case "function":
return exp;
default:
return noop;
}
};
}
];
}
/**
* @ngdoc service
* @name ng.$q
* @requires $rootScope
*
* @description
* A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
*
* [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an
* interface for interacting with an object that represents the result of an action that is
* performed asynchronously, and may or may not be finished at any given point in time.
*
* From the perspective of dealing with error handling, deferred and promise APIs are to
* asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.
*
* <pre>
* // for the purpose of this example let's assume that variables `$q` and `scope` are
* // available in the current lexical scope (they could have been injected or passed in).
*
* function asyncGreet(name) {
* var deferred = $q.defer();
*
* setTimeout(function() {
* // since this fn executes async in a future turn of the event loop, we need to wrap
* // our code into an $apply call so that the model changes are properly observed.
* scope.$apply(function() {
* deferred.notify('About to greet ' + name + '.');
*
* if (okToGreet(name)) {
* deferred.resolve('Hello, ' + name + '!');
* } else {
* deferred.reject('Greeting ' + name + ' is not allowed.');
* }
* });
* }, 1000);
*
* return deferred.promise;
* }
*
* var promise = asyncGreet('Robin Hood');
* promise.then(function(greeting) {
* alert('Success: ' + greeting);
* }, function(reason) {
* alert('Failed: ' + reason);
* }, function(update) {
* alert('Got notification: ' + update);
* });
* </pre>
*
* At first it might not be obvious why this extra complexity is worth the trouble. The payoff
* comes in the way of guarantees that promise and deferred APIs make, see
* https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md.
*
* Additionally the promise api allows for composition that is very hard to do with the
* traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.
* For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the
* section on serial or parallel joining of promises.
*
*
* # The Deferred API
*
* A new instance of deferred is constructed by calling `$q.defer()`.
*
* The purpose of the deferred object is to expose the associated Promise instance as well as APIs
* that can be used for signaling the successful or unsuccessful completion, as well as the status
* of the task.
*
* **Methods**
*
* - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection
* constructed via `$q.reject`, the promise will be rejected instead.
* - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to
* resolving it with a rejection constructed via `$q.reject`.
* - `notify(value)` - provides updates on the status of the promises execution. This may be called
* multiple times before the promise is either resolved or rejected.
*
* **Properties**
*
* - promise – `{Promise}` – promise object associated with this deferred.
*
*
* # The Promise API
*
* A new promise instance is created when a deferred instance is created and can be retrieved by
* calling `deferred.promise`.
*
* The purpose of the promise object is to allow for interested parties to get access to the result
* of the deferred task when it completes.
*
* **Methods**
*
* - `then(successCallback, errorCallback, notifyCallback)` – regardless of when the promise was or
* will be resolved or rejected, `then` calls one of the success or error callbacks asynchronously
* as soon as the result is available. The callbacks are called with a single argument: the result
* or rejection reason. Additionally, the notify callback may be called zero or more times to
* provide a progress indication, before the promise is resolved or rejected.
*
* This method *returns a new promise* which is resolved or rejected via the return value of the
* `successCallback`, `errorCallback`. It also notifies via the return value of the
* `notifyCallback` method. The promise can not be resolved or rejected from the notifyCallback
* method.
*
* - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)`
*
* - `finally(callback)` – allows you to observe either the fulfillment or rejection of a promise,
* but to do so without modifying the final value. This is useful to release resources or do some
* clean-up that needs to be done whether the promise was rejected or resolved. See the [full
* specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for
* more information.
*
* Because `finally` is a reserved word in JavaScript and reserved keywords are not supported as
* property names by ES3, you'll need to invoke the method like `promise['finally'](callback)` to
* make your code IE8 compatible.
*
* # Chaining promises
*
* Because calling the `then` method of a promise returns a new derived promise, it is easily
* possible to create a chain of promises:
*
* <pre>
* promiseB = promiseA.then(function(result) {
* return result + 1;
* });
*
* // promiseB will be resolved immediately after promiseA is resolved and its value
* // will be the result of promiseA incremented by 1
* </pre>
*
* It is possible to create chains of any length and since a promise can be resolved with another
* promise (which will defer its resolution further), it is possible to pause/defer resolution of
* the promises at any point in the chain. This makes it possible to implement powerful APIs like
* $http's response interceptors.
*
*
* # Differences between Kris Kowal's Q and $q
*
* There are two main differences:
*
* - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation
* mechanism in angular, which means faster propagation of resolution or rejection into your
* models and avoiding unnecessary browser repaints, which would result in flickering UI.
* - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains
* all the important functionality needed for common async tasks.
*
* # Testing
*
* <pre>
* it('should simulate promise', inject(function($q, $rootScope) {
* var deferred = $q.defer();
* var promise = deferred.promise;
* var resolvedValue;
*
* promise.then(function(value) { resolvedValue = value; });
* expect(resolvedValue).toBeUndefined();
*
* // Simulate resolving of promise
* deferred.resolve(123);
* // Note that the 'then' function does not get called synchronously.
* // This is because we want the promise API to always be async, whether or not
* // it got called synchronously or asynchronously.
* expect(resolvedValue).toBeUndefined();
*
* // Propagate promise resolution to 'then' functions using $apply().
* $rootScope.$apply();
* expect(resolvedValue).toEqual(123);
* }));
* </pre>
*/ function $QProvider() {
this.$get = [
"$rootScope",
"$exceptionHandler",
function($rootScope, $exceptionHandler) {
return(/**
* Constructs a promise manager.
*
* @param {function(function)} nextTick Function for executing functions in the next turn.
* @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for
* debugging purposes.
* @returns {object} Promise manager.
*/ function(nextTick, exceptionHandler) {
/**
* @ngdoc
* @name ng.$q#defer
* @methodOf ng.$q
* @description
* Creates a `Deferred` object which represents a task which will finish in the future.
*
* @returns {Deferred} Returns a new instance of deferred.
*/ 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;
}
};
};
function defaultCallback(value) {
return value;
}
function defaultErrback(reason) {
return reject(reason);
}
return {
defer: defer,
reject: reject,
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;
},
all: /**
* @ngdoc
* @name ng.$q#all
* @methodOf ng.$q
* @description
* Combines multiple promises into a single promise that is resolved when all of the input
* promises are resolved.
*
* @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises.
* @returns {Promise} Returns a single promise that will be resolved with an array/hash of values,
* each value corresponding to the promise at the same index/key in the `promises` array/hash.
* If any of the promises is resolved with a rejection, this resulting promise will be rejected
* with the same rejection value.
*/ function(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;
}
};
}(function(callback) {
$rootScope.$evalAsync(callback);
}, $exceptionHandler));
}
];
}
/**
* DESIGN NOTES
*
* The design decisions behind the scope are heavily favored for speed and memory consumption.
*
* The typical use of scope is to watch the expressions, which most of the time return the same
* value as last time so we optimize the operation.
*
* Closures construction is expensive in terms of speed as well as memory:
* - No closures, instead use prototypical inheritance for API
* - Internal state needs to be stored on scope directly, which means that private state is
* exposed as $$____ properties
*
* Loop operations are optimized by using while(count--) { ... }
* - this means that in order to keep the same order of execution as addition we have to add
* items to the array at the beginning (shift) instead of at the end (push)
*
* Child scopes are created and removed often
* - Using an array would be slow since inserts in middle are expensive so we use linked list
*
* There are few watches then a lot of observers. This is why you don't want the observer to be
* implemented in the same way as watch. Watch requires return of initialization function which
* are expensive to construct.
*/ /**
* @ngdoc object
* @name ng.$rootScopeProvider
* @description
*
* Provider for the $rootScope service.
*/ /**
* @ngdoc function
* @name ng.$rootScopeProvider#digestTtl
* @methodOf ng.$rootScopeProvider
* @description
*
* Sets the number of `$digest` iterations the scope should attempt to execute before giving up and
* assuming that the model is unstable.
*
* The current default is 10 iterations.
*
* In complex applications it's possible that the dependencies between `$watch`s will result in
* several digest iterations. However if an application needs more than the default 10 digest
* iterations for its model to stabilize then you should investigate what is causing the model to
* continuously change during the digest.
*
* Increasing the TTL could have performance implications, so you should not change it without
* proper justification.
*
* @param {number} limit The number of digest iterations.
*/ /**
* @ngdoc object
* @name ng.$rootScope
* @description
*
* Every application has a single root {@link ng.$rootScope.Scope scope}.
* All other scopes are descendant scopes of the root scope. Scopes provide separation
* between the model and the view, via a mechanism for watching the model for changes.
* They also provide an event emission/broadcast and subscription facility. See the
* {@link guide/scope developer guide on scopes}.
*/ 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) {
/**
* @ngdoc function
* @name ng.$rootScope.Scope
*
* @description
* A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the
* {@link AUTO.$injector $injector}. Child scopes are created using the
* {@link ng.$rootScope.Scope#methods_$new $new()} method. (Most scopes are created automatically when
* compiled HTML template is executed.)
*
* Here is a simple scope snippet to show how you can interact with the scope.
* <pre>
* <file src="./test/ng/rootScopeSpec.js" tag="docs1" />
* </pre>
*
* # Inheritance
* A scope can inherit from a parent scope, as in this example:
* <pre>
var parent = $rootScope;
var child = parent.$new();
parent.salutation = "Hello";
child.name = "World";
expect(child.salutation).toEqual('Hello');
child.salutation = "Welcome";
expect(child.salutation).toEqual('Welcome');
expect(parent.salutation).toEqual('Hello');
* </pre>
*
*
* @param {Object.<string, function()>=} providers Map of service factory which need to be
* provided for the current scope. Defaults to {@link ng}.
* @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
* append/override services provided by `providers`. This is handy
* when unit-testing and having the need to override a default
* service.
* @returns {Object} Newly created scope.
*
*/ 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 = {};
}
/**
* @ngdoc property
* @name ng.$rootScope.Scope#$id
* @propertyOf ng.$rootScope.Scope
* @returns {number} Unique scope ID (monotonically increasing alphanumeric sequence) useful for
* debugging.
*/ Scope.prototype = {
constructor: Scope,
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$new
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Creates a new child {@link ng.$rootScope.Scope scope}.
*
* The parent scope will propagate the {@link ng.$rootScope.Scope#methods_$digest $digest()} and
* {@link ng.$rootScope.Scope#methods_$digest $digest()} events. The scope can be removed from the
* scope hierarchy using {@link ng.$rootScope.Scope#methods_$destroy $destroy()}.
*
* {@link ng.$rootScope.Scope#methods_$destroy $destroy()} must be called on a scope when it is
* desired for the scope and its child scopes to be permanently detached from the parent and
* thus stop participating in model change detection and listener notification by invoking.
*
* @param {boolean} isolate If true, then the scope does not prototypically inherit from the
* parent scope. The scope is isolated, as it can not see parent scope properties.
* When creating widgets, it is useful for the widget to not accidentally read parent
* state.
*
* @returns {Object} The newly created child scope.
*
*/ $new: function(isolate) {
var ChildScope, child;
return isolate ? ((child = new Scope()).$root = this.$root, // ensure that there is just one async queue per $rootScope and its children
child.$$asyncQueue = this.$$asyncQueue, child.$$postDigestQueue = this.$$postDigestQueue) : (// the name it does not become random set of chars. This will then show up as class
// name in the debugger.
(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;
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$watch
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Registers a `listener` callback to be executed whenever the `watchExpression` changes.
*
* - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#methods_$digest
* $digest()} and should return the value that will be watched. (Since
* {@link ng.$rootScope.Scope#methods_$digest $digest()} reruns when it detects changes the
* `watchExpression` can execute multiple times per
* {@link ng.$rootScope.Scope#methods_$digest $digest()} and should be idempotent.)
* - The `listener` is called only when the value from the current `watchExpression` and the
* previous call to `watchExpression` are not equal (with the exception of the initial run,
* see below). The inequality is determined according to
* {@link angular.equals} function. To save the value of the object for later comparison,
* the {@link angular.copy} function is used. It also means that watching complex options
* will have adverse memory and performance implications.
* - The watch `listener` may change the model, which may trigger other `listener`s to fire.
* This is achieved by rerunning the watchers until no changes are detected. The rerun
* iteration limit is 10 to prevent an infinite loop deadlock.
*
*
* If you want to be notified whenever {@link ng.$rootScope.Scope#methods_$digest $digest} is called,
* you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
* can execute multiple times per {@link ng.$rootScope.Scope#methods_$digest $digest} cycle when a
* change is detected, be prepared for multiple calls to your listener.)
*
* After a watcher is registered with the scope, the `listener` fn is called asynchronously
* (via {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync}) to initialize the
* watcher. In rare cases, this is undesirable because the listener is called when the result
* of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
* can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
* listener was called due to initialization.
*
* The example below contains an illustration of using a function as your $watch listener
*
*
* # Example
* <pre>
// let's assume that scope was dependency injected as the $rootScope
var scope = $rootScope;
scope.name = 'misko';
scope.counter = 0;
expect(scope.counter).toEqual(0);
scope.$watch('name', function(newValue, oldValue) {
scope.counter = scope.counter + 1;
});
expect(scope.counter).toEqual(0);
scope.$digest();
// no variable change
expect(scope.counter).toEqual(0);
scope.name = 'adam';
scope.$digest();
expect(scope.counter).toEqual(1);
// Using a listener function
var food;
scope.foodCounter = 0;
expect(scope.foodCounter).toEqual(0);
scope.$watch(
// This is the listener function
function() { return food; },
// This is the change handler
function(newValue, oldValue) {
if ( newValue !== oldValue ) {
// Only increment the counter if the value changed
scope.foodCounter = scope.foodCounter + 1;
}
}
);
// No digest has been run so the counter will be zero
expect(scope.foodCounter).toEqual(0);
// Run the digest but since food has not changed cout will still be zero
scope.$digest();
expect(scope.foodCounter).toEqual(0);
// Update food and run digest. Now the counter will increment
food = 'cheeseburger';
scope.$digest();
expect(scope.foodCounter).toEqual(1);
* </pre>
*
*
*
* @param {(function()|string)} watchExpression Expression that is evaluated on each
* {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. A change in the return value triggers
* a call to the `listener`.
*
* - `string`: Evaluated as {@link guide/expression expression}
* - `function(scope)`: called with current `scope` as a parameter.
* @param {(function()|string)=} listener Callback called whenever the return value of
* the `watchExpression` changes.
*
* - `string`: Evaluated as {@link guide/expression expression}
* - `function(newValue, oldValue, scope)`: called with current and previous values as
* parameters.
*
* @param {boolean=} objectEquality Compare object for equality rather than for reference.
* @returns {function()} Returns a deregistration function for this listener.
*/ $watch: function(watchExp, listener, objectEquality) {
var get = compileToFn(watchExp, "watch"), array = this.$$watchers, watcher = {
fn: listener,
last: initWatchVal,
get: get,
exp: watchExp,
eq: !!objectEquality
};
// in the case user pass string, we need to compile it, do we really need this ?
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 = []), // we use unshift since we use a while loop in $digest for speed.
// the while loop reads in reverse order.
array.unshift(watcher), function() {
arrayRemove(array, watcher);
};
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$watchCollection
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Shallow watches the properties of an object and fires whenever any of the properties change
* (for arrays, this implies watching the array items; for object maps, this implies watching
* the properties). If a change is detected, the `listener` callback is fired.
*
* - The `obj` collection is observed via standard $watch operation and is examined on every
* call to $digest() to see if any items have been added, removed, or moved.
* - The `listener` is called whenever anything within the `obj` has changed. Examples include
* adding, removing, and moving items belonging to an object or array.
*
*
* # Example
* <pre>
$scope.names = ['igor', 'matias', 'misko', 'james'];
$scope.dataCount = 4;
$scope.$watchCollection('names', function(newNames, oldNames) {
$scope.dataCount = newNames.length;
});
expect($scope.dataCount).toEqual(4);
$scope.$digest();
//still at 4 ... no changes
expect($scope.dataCount).toEqual(4);
$scope.names.pop();
$scope.$digest();
//now there's been a change
expect($scope.dataCount).toEqual(3);
* </pre>
*
*
* @param {string|Function(scope)} obj Evaluated as {@link guide/expression expression}. The
* expression value should evaluate to an object or an array which is observed on each
* {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. Any shallow change within the
* collection will trigger a call to the `listener`.
*
* @param {function(newCollection, oldCollection, scope)} listener a callback function that is
* fired with both the `newCollection` and `oldCollection` as parameters.
* The `newCollection` object is the newly modified data obtained from the `obj` expression
* and the `oldCollection` object is a copy of the former collection data.
* The `scope` refers to the current scope.
*
* @returns {function()} Returns a de-registration function for this listener. When the
* de-registration function is executed, the internal watch operation is terminated.
*/ $watchCollection: function(obj, listener) {
var oldValue, newValue, self = this, changeDetected = 0, objGetter = $parse(obj), internalArray = [], internalObject = {}, oldLength = 0;
return this.$watch(function() {
if (isObject(newValue = objGetter(self))) {
if (isArrayLike(newValue)) {
oldValue !== internalArray && (oldLength = // we are transitioning from something which was not an array into array.
(oldValue = internalArray).length = 0, changeDetected++), newLength = newValue.length, oldLength !== newLength && (// if lengths do not match we need to trigger change notification
changeDetected++, oldValue.length = oldLength = newLength);
// copy the items to oldValue and look for changes.
for(var newLength, key, i = 0; i < newLength; i++)oldValue[i] !== newValue[i] && (changeDetected++, oldValue[i] = newValue[i]);
} else {
for(key in oldValue !== internalObject && (// we are transitioning from something which was not an object into object.
oldValue = internalObject = {}, oldLength = 0, changeDetected++), // copy the items to oldValue and look for changes.
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 // we used to have more keys, need to find them and destroy them.
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);
});
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$digest
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and
* its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change
* the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
* until no more listeners are firing. This means that it is possible to get into an infinite
* loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
* iterations exceeds 10.
*
* Usually, you don't call `$digest()` directly in
* {@link ng.directive:ngController controllers} or in
* {@link ng.$compileProvider#methods_directive directives}.
* Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within
* a {@link ng.$compileProvider#methods_directive directives}), which will force a `$digest()`.
*
* If you want to be notified whenever `$digest()` is called,
* you can register a `watchExpression` function with
* {@link ng.$rootScope.Scope#methods_$watch $watch()} with no `listener`.
*
* In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
*
* # Example
* <pre>
var scope = ...;
scope.name = 'misko';
scope.counter = 0;
expect(scope.counter).toEqual(0);
scope.$watch('name', function(newValue, oldValue) {
scope.counter = scope.counter + 1;
});
expect(scope.counter).toEqual(0);
scope.$digest();
// no variable change
expect(scope.counter).toEqual(0);
scope.name = 'adam';
scope.$digest();
expect(scope.counter).toEqual(1);
* </pre>
*
*/ $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(// "while dirty" loop
dirty = !1, current = this; asyncQueue.length;){
try {
(asyncTask = asyncQueue.shift()).scope.$eval(asyncTask.expression);
} catch (e) {
clearPhase(), $exceptionHandler(e);
}
lastDirtyWatch = null;
}
traverseScopesLoop: do {
// "traverse the scopes" loop
if (watchers = current.$$watchers) for(// process our watches
length = watchers.length; length--;)try {
// Most common watches are on primitives, in which case we can short
// circuit it with === operator, only when === fails do we use .equals
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) {
// If the most recently dirty watcher is now clean, short circuit since the remaining watchers
// have already been tested.
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) + ("; newVal: " + toJson(value) + "; oldVal: ") + toJson(last), watchLog[logIdx].push(logMsg));
}
} catch (e) {
clearPhase(), $exceptionHandler(e);
}
// Insanity Warning: scope depth-first traversal
// yes, this code is a bit crazy, but it works and we have tests to prove it!
// this piece should be kept in sync with the traversal in $broadcast
if (!(next = current.$$childHead || current !== this && current.$$nextSibling)) for(; current !== this && !(next = current.$$nextSibling);)current = current.$parent;
}while (current = next)
// `break traverseScopesLoop;` takes us to here
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);
}
},
/**
* @ngdoc event
* @name ng.$rootScope.Scope#$destroy
* @eventOf ng.$rootScope.Scope
* @eventType broadcast on scope being destroyed
*
* @description
* Broadcasted when a scope and its children are being destroyed.
*
* Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
* clean up DOM bindings before an element is removed from the DOM.
*/ /**
* @ngdoc function
* @name ng.$rootScope.Scope#$destroy
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Removes the current scope (and all of its children) from the parent scope. Removal implies
* that calls to {@link ng.$rootScope.Scope#methods_$digest $digest()} will no longer
* propagate to the current scope and its children. Removal also implies that the current
* scope is eligible for garbage collection.
*
* The `$destroy()` is usually used by directives such as
* {@link ng.directive:ngRepeat ngRepeat} for managing the
* unrolling of the loop.
*
* Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope.
* Application code can register a `$destroy` event handler that will give it a chance to
* perform any necessary cleanup.
*
* Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
* clean up DOM bindings before an element is removed from the DOM.
*/ $destroy: function() {
// we can't destroy the root scope or a scope that has been already destroyed
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 is bogus code that works around Chrome's GC leak
// see: https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead = this.$$childTail = null);
}
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$eval
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Executes the `expression` on the current scope and returns the result. Any exceptions in
* the expression are propagated (uncaught). This is useful when evaluating Angular
* expressions.
*
* # Example
* <pre>
var scope = ng.$rootScope.Scope();
scope.a = 1;
scope.b = 2;
expect(scope.$eval('a+b')).toEqual(3);
expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
* </pre>
*
* @param {(string|function())=} expression An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with the current `scope` parameter.
*
* @param {(object)=} locals Local variables object, useful for overriding values in scope.
* @returns {*} The result of evaluating the expression.
*/ $eval: function(expr, locals) {
return $parse(expr)(this, locals);
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$evalAsync
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Executes the expression on the current scope at a later point in time.
*
* The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only
* that:
*
* - it will execute after the function that scheduled the evaluation (preferably before DOM
* rendering).
* - at least one {@link ng.$rootScope.Scope#methods_$digest $digest cycle} will be performed after
* `expression` execution.
*
* Any exceptions from the execution of the expression are forwarded to the
* {@link ng.$exceptionHandler $exceptionHandler} service.
*
* __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle
* will be scheduled. However, it is encouraged to always call code that changes the model
* from within an `$apply` call. That includes code evaluated via `$evalAsync`.
*
* @param {(string|function())=} expression An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with the current `scope` parameter.
*
*/ $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);
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$apply
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* `$apply()` is used to execute an expression in angular from outside of the angular
* framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
* Because we are calling into the angular framework we need to perform proper scope life
* cycle of {@link ng.$exceptionHandler exception handling},
* {@link ng.$rootScope.Scope#methods_$digest executing watches}.
*
* ## Life cycle
*
* # Pseudo-Code of `$apply()`
* <pre>
function $apply(expr) {
try {
return $eval(expr);
} catch (e) {
$exceptionHandler(e);
} finally {
$root.$digest();
}
}
* </pre>
*
*
* Scope's `$apply()` method transitions through the following stages:
*
* 1. The {@link guide/expression expression} is executed using the
* {@link ng.$rootScope.Scope#methods_$eval $eval()} method.
* 2. Any exceptions from the execution of the expression are forwarded to the
* {@link ng.$exceptionHandler $exceptionHandler} service.
* 3. The {@link ng.$rootScope.Scope#methods_$watch watch} listeners are fired immediately after the
* expression was executed using the {@link ng.$rootScope.Scope#methods_$digest $digest()} method.
*
*
* @param {(string|function())=} exp An angular expression to be executed.
*
* - `string`: execute using the rules as defined in {@link guide/expression expression}.
* - `function(scope)`: execute the function with current `scope` parameter.
*
* @returns {*} The result of evaluating the expression.
*/ $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;
}
}
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$on
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Listens on events of a given type. See {@link ng.$rootScope.Scope#methods_$emit $emit} for
* discussion of event life cycle.
*
* The event listener function format is: `function(event, args...)`. The `event` object
* passed into the listener has the following attributes:
*
* - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or
* `$broadcast`-ed.
* - `currentScope` - `{Scope}`: the current scope which is handling the event.
* - `name` - `{string}`: name of the event.
* - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel
* further event propagation (available only for events that were `$emit`-ed).
* - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag
* to true.
* - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
*
* @param {string} name Event name to listen on.
* @param {function(event, args...)} listener Function to call when the event is emitted.
* @returns {function()} Returns a deregistration function for this listener.
*/ $on: function(name, listener) {
var namedListeners = this.$$listeners[name];
return namedListeners || (this.$$listeners[name] = namedListeners = []), namedListeners.push(listener), function() {
namedListeners[indexOf(namedListeners, listener)] = null;
};
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$emit
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Dispatches an event `name` upwards through the scope hierarchy notifying the
* registered {@link ng.$rootScope.Scope#methods_$on} listeners.
*
* The event life cycle starts at the scope on which `$emit` was called. All
* {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
* notified. Afterwards, the event traverses upwards toward the root scope and calls all
* registered listeners along the way. The event will stop propagating if one of the listeners
* cancels it.
*
* Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
* onto the {@link ng.$exceptionHandler $exceptionHandler} service.
*
* @param {string} name Event name to emit.
* @param {...*} args Optional set of arguments which will be passed onto the event listeners.
* @return {Object} Event object (see {@link ng.$rootScope.Scope#methods_$on}).
*/ $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(i = 0, namedListeners = scope.$$listeners[name] || empty, event.currentScope = scope, length = namedListeners.length; i < length; i++){
// if listeners were deregistered, defragment the array
if (!namedListeners[i]) {
namedListeners.splice(i, 1), i--, length--;
continue;
}
try {
//allow all listeners attached to the current scope to run
namedListeners[i].apply(null, listenerArgs);
} catch (e) {
$exceptionHandler(e);
}
}
//if any listener on the current scope stops propagation, prevent bubbling
if (stopPropagation) break;
//traverse upwards
scope = scope.$parent;
}while (scope)
return event;
},
/**
* @ngdoc function
* @name ng.$rootScope.Scope#$broadcast
* @methodOf ng.$rootScope.Scope
* @function
*
* @description
* Dispatches an event `name` downwards to all child scopes (and their children) notifying the
* registered {@link ng.$rootScope.Scope#methods_$on} listeners.
*
* The event life cycle starts at the scope on which `$broadcast` was called. All
* {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
* notified. Afterwards, the event propagates to all direct and indirect scopes of the current
* scope and calls all registered listeners along the way. The event cannot be canceled.
*
* Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
* onto the {@link ng.$exceptionHandler $exceptionHandler} service.
*
* @param {string} name Event name to broadcast.
* @param {...*} args Optional set of arguments which will be passed onto the event listeners.
* @return {Object} Event object, see {@link ng.$rootScope.Scope#methods_$on}
*/ $broadcast: function(name, args) {
var listeners, i, length, current = this, next = this, event = {
name: name,
targetScope: this,
preventDefault: function() {
event.defaultPrevented = !0;
},
defaultPrevented: !1
}, listenerArgs = concat([
event
], arguments, 1);
//down while you can, then up and next sibling or up and next sibling until back at root
do {
for(i = 0, event.currentScope = current = next, length = (listeners = current.$$listeners[name] || []).length; i < length; i++){
// if listeners were deregistered, defragment the array
if (!listeners[i]) {
listeners.splice(i, 1), i--, length--;
continue;
}
try {
listeners[i].apply(null, listenerArgs);
} catch (e) {
$exceptionHandler(e);
}
}
// Insanity Warning: scope depth-first traversal
// yes, this code is a bit crazy, but it works and we have tests to prove it!
// this piece should be kept in sync with the traversal in $digest
if (!(next = current.$$childHead || current !== this && current.$$nextSibling)) for(; current !== this && !(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 used as an initial value for watchers.
* because it's unique we can easily tell it apart from other values
*/ function initWatchVal() {}
}
];
}
/**
* @description
* Private service to sanitize uris for links and images. Used by $compile and $sanitize.
*/ function $$SanitizeUriProvider() {
var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/, imgSrcSanitizationWhitelist = /^\s*(https?|ftp|file):|data:image\//;
/**
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during a[href] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to a[href] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/ this.aHrefSanitizationWhitelist = function(regexp) {
return isDefined(regexp) ? (aHrefSanitizationWhitelist = regexp, this) : aHrefSanitizationWhitelist;
}, /**
* @description
* Retrieves or overrides the default regular expression that is used for whitelisting of safe
* urls during img[src] sanitization.
*
* The sanitization is a security measure aimed at prevent XSS attacks via html links.
*
* Any url about to be assigned to img[src] via data-binding is first normalized and turned into
* an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
* regular expression. If a match is found, the original url is written into the dom. Otherwise,
* the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
*
* @param {RegExp=} regexp New regexp to whitelist urls with.
* @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
* chaining otherwise.
*/ 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(// NOTE: urlResolve() doesn't support IE < 8 so we don't sanitize for that case.
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 is a subtype of URL used in contexts where a privileged resource is sourced from a
// url. (e.g. ng-include, script src, templateUrl)
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)) {
// Strings match exactly except for 2 wildcards - '*' and '**'.
// '*' matches any character except those from the set ':/.?&'.
// '**' matches any character (like .* in a RegExp).
// More than 2 *'s raises an error as it's ill defined.
if (matcher.indexOf("***") > -1) throw $sceMinErr("iwcard", "Illegal sequence *** in string matcher. String: {0}", matcher);
return RegExp("^" + (matcher = matcher.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08").replace("\\*\\*", ".*").replace("\\*", "[^:/.?&;]*")) + "$");
}
if (isRegExp(matcher)) // The only other type of matcher allowed is a Regexp.
// Match entire URL / disallow partial matches.
// Flags are reset (i.e. no global, ignoreCase or multiline)
return RegExp("^" + matcher.source + "$");
throw $sceMinErr("imatcher", 'Matchers may only be "self", string patterns or RegExp objects');
}(matcher));
}), adjustedMatchers;
}
/**
* @ngdoc service
* @name ng.$sceDelegate
* @function
*
* @description
*
* `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
* Contextual Escaping (SCE)} services to AngularJS.
*
* Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
* the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS. This is
* because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
* override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
* work because `$sce` delegates to `$sceDelegate` for these operations.
*
* Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
*
* The default instance of `$sceDelegate` should work out of the box with little pain. While you
* can override it completely to change the behavior of `$sce`, the common case would
* involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
* your own whitelists and blacklists for trusting URLs used for loading AngularJS resources such as
* templates. Refer {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist
* $sceDelegateProvider.resourceUrlWhitelist} and {@link
* ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
*/ /**
* @ngdoc object
* @name ng.$sceDelegateProvider
* @description
*
* The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
* $sceDelegate} service. This allows one to get/set the whitelists and blacklists used to ensure
* that the URLs used for sourcing Angular templates are safe. Refer {@link
* ng.$sceDelegateProvider#methods_resourceUrlWhitelist $sceDelegateProvider.resourceUrlWhitelist} and
* {@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
*
* For the general details about this service in Angular, read the main page for {@link ng.$sce
* Strict Contextual Escaping (SCE)}.
*
* **Example**: Consider the following case. <a name="example"></a>
*
* - your app is hosted at url `http://myapp.example.com/`
* - but some of your templates are hosted on other domains you control such as
* `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc.
* - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
*
* Here is what a secure configuration for this scenario might look like:
*
* <pre class="prettyprint">
* angular.module('myApp', []).config(function($sceDelegateProvider) {
* $sceDelegateProvider.resourceUrlWhitelist([
* // Allow same origin resource loads.
* 'self',
* // Allow loading from our assets domain. Notice the difference between * and **.
* 'http://srv*.assets.example.com/**']);
*
* // The blacklist overrides the whitelist so the open redirect here is blocked.
* $sceDelegateProvider.resourceUrlBlacklist([
* 'http://myapp.example.com/clickThru**']);
* });
* </pre>
*/ function $SceDelegateProvider() {
this.SCE_CONTEXTS = SCE_CONTEXTS;
// Resource URLs can also be trusted by policy.
var resourceUrlWhitelist = [
"self"
], resourceUrlBlacklist = [];
/**
* @ngdoc function
* @name ng.sceDelegateProvider#resourceUrlWhitelist
* @methodOf ng.$sceDelegateProvider
* @function
*
* @param {Array=} whitelist When provided, replaces the resourceUrlWhitelist with the value
* provided. This must be an array or null. A snapshot of this array is used so further
* changes to the array are ignored.
*
* Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
* allowed in this array.
*
* Note: **an empty whitelist array will block all URLs**!
*
* @return {Array} the currently set whitelist array.
*
* The **default value** when no whitelist has been explicitly set is `['self']` allowing only
* same origin resource requests.
*
* @description
* Sets/Gets the whitelist of trusted resource URLs.
*/ this.resourceUrlWhitelist = function(value) {
return arguments.length && (resourceUrlWhitelist = adjustMatchers(value)), resourceUrlWhitelist;
}, /**
* @ngdoc function
* @name ng.sceDelegateProvider#resourceUrlBlacklist
* @methodOf ng.$sceDelegateProvider
* @function
*
* @param {Array=} blacklist When provided, replaces the resourceUrlBlacklist with the value
* provided. This must be an array or null. A snapshot of this array is used so further
* changes to the array are ignored.
*
* Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
* allowed in this array.
*
* The typical usage for the blacklist is to **block
* [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
* these would otherwise be trusted but actually return content from the redirected domain.
*
* Finally, **the blacklist overrides the whitelist** and has the final say.
*
* @return {Array} the currently set blacklist array.
*
* The **default value** when no whitelist has been explicitly set is the empty array (i.e. there
* is no blacklist.)
*
* @description
* Sets/Gets the blacklist of trusted resource URLs.
*/ 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: /**
* @ngdoc method
* @name ng.$sceDelegate#trustAs
* @methodOf ng.$sceDelegate
*
* @description
* Returns an object that is trusted by angular for use in specified strict
* contextual escaping contexts (such as ng-html-bind-unsafe, ng-include, any src
* attribute interpolation, any dom event binding attribute interpolation
* such as for onclick, etc.) that uses the provided value.
* See {@link ng.$sce $sce} for enabling strict contextual escaping.
*
* @param {string} type The kind of context in which this value is safe for use. e.g. url,
* resourceUrl, html, js and css.
* @param {*} value The value that that should be considered trusted/safe.
* @returns {*} A value that can be used to stand in for the provided `value` in places
* where Angular expects a $sce.trustAs() return value.
*/ 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;
// All the current contexts in SCE_CONTEXTS happen to be strings. In order to avoid trusting
// mutable objects, we ensure here that the value passed in is actually a string.
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: /**
* @ngdoc method
* @name ng.$sceDelegate#getTrusted
* @methodOf ng.$sceDelegate
*
* @description
* Takes the result of a {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`} call and
* returns the originally supplied value if the queried context type is a supertype of the
* created type. If this condition isn't satisfied, throws an exception.
*
* @param {string} type The kind of context in which this value is to be used.
* @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} call.
* @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} if valid in this context. Otherwise, throws an exception.
*/ 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 we get here, then we may only take one of two actions.
// 1. sanitize the value for the requested type, or
// 2. throw an exception.
if (type === SCE_CONTEXTS.RESOURCE_URL) {
if (function(url) {
var i, n, parsedUrl = urlResolve(url.toString()), allowed = !1;
// Ensure that at least one item from the whitelist allows this url.
for(i = 0, n = resourceUrlWhitelist.length; i < n; i++)if (matchUrl(resourceUrlWhitelist[i], parsedUrl)) {
allowed = !0;
break;
}
if (allowed) // Ensure that no item from the blacklist blocked this url.
{
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: /**
* @ngdoc method
* @name ng.$sceDelegate#valueOf
* @methodOf ng.$sceDelegate
*
* @description
* If the passed parameter had been returned by a prior call to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`}, returns the value that had been passed to {@link
* ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}.
*
* If the passed parameter is not a value that had been returned by {@link
* ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}, returns it as-is.
*
* @param {*} value The result of a prior {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}
* call or anything else.
* @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
* `$sceDelegate.trustAs`} if `value` is the result of such a call. Otherwise, returns
* `value` unchanged.
*/ function(maybeTrusted) {
return maybeTrusted instanceof trustedValueHolderBase ? maybeTrusted.$$unwrapTrustedValue() : maybeTrusted;
}
};
}
];
}
/**
* @ngdoc object
* @name ng.$sceProvider
* @description
*
* The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service.
* - enable/disable Strict Contextual Escaping (SCE) in a module
* - override the default implementation with a custom delegate
*
* Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}.
*/ /* jshint maxlen: false*/ /**
* @ngdoc service
* @name ng.$sce
* @function
*
* @description
*
* `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
*
* # Strict Contextual Escaping
*
* Strict Contextual Escaping (SCE) is a mode in which AngularJS requires bindings in certain
* contexts to result in a value that is marked as safe to use for that context. One example of
* such a context is binding arbitrary html controlled by the user via `ng-bind-html`. We refer
* to these contexts as privileged or SCE contexts.
*
* As of version 1.2, Angular ships with SCE enabled by default.
*
* Note: When enabled (the default), IE8 in quirks mode is not supported. In this mode, IE8 allows
* one to execute arbitrary javascript by the use of the expression() syntax. Refer
* <http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx> to learn more about them.
* You can ensure your document is in standards mode and not quirks mode by adding `<!doctype html>`
* to the top of your HTML document.
*
* SCE assists in writing code in way that (a) is secure by default and (b) makes auditing for
* security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
*
* Here's an example of a binding in a privileged context:
*
* <pre class="prettyprint">
* <input ng-model="userHtml">
* <div ng-bind-html="userHtml">
* </pre>
*
* Notice that `ng-bind-html` is bound to `userHtml` controlled by the user. With SCE
* disabled, this application allows the user to render arbitrary HTML into the DIV.
* In a more realistic example, one may be rendering user comments, blog articles, etc. via
* bindings. (HTML is just one example of a context where rendering user controlled input creates
* security vulnerabilities.)
*
* For the case of HTML, you might use a library, either on the client side, or on the server side,
* to sanitize unsafe HTML before binding to the value and rendering it in the document.
*
* How would you ensure that every place that used these types of bindings was bound to a value that
* was sanitized by your library (or returned as safe for rendering by your server?) How can you
* ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
* properties/fields and forgot to update the binding to the sanitized value?
*
* To be secure by default, you want to ensure that any such bindings are disallowed unless you can
* determine that something explicitly says it's safe to use a value for binding in that
* context. You can then audit your code (a simple grep would do) to ensure that this is only done
* for those values that you can easily tell are safe - because they were received from your server,
* sanitized by your library, etc. You can organize your codebase to help with this - perhaps
* allowing only the files in a specific directory to do this. Ensuring that the internal API
* exposed by that code doesn't markup arbitrary values as safe then becomes a more manageable task.
*
* In the case of AngularJS' SCE service, one uses {@link ng.$sce#methods_trustAs $sce.trustAs}
* (and shorthand methods such as {@link ng.$sce#methods_trustAsHtml $sce.trustAsHtml}, etc.) to
* obtain values that will be accepted by SCE / privileged contexts.
*
*
* ## How does it work?
*
* In privileged contexts, directives and code will bind to the result of {@link ng.$sce#methods_getTrusted
* $sce.getTrusted(context, value)} rather than to the value directly. Directives use {@link
* ng.$sce#methods_parse $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the
* {@link ng.$sce#methods_getTrusted $sce.getTrusted} behind the scenes on non-constant literals.
*
* As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
* ng.$sce#methods_parseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly
* simplified):
*
* <pre class="prettyprint">
* var ngBindHtmlDirective = ['$sce', function($sce) {
* return function(scope, element, attr) {
* scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) {
* element.html(value || '');
* });
* };
* }];
* </pre>
*
* ## Impact on loading templates
*
* This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
* `templateUrl`'s specified by {@link guide/directive directives}.
*
* By default, Angular only loads templates from the same domain and protocol as the application
* document. This is done by calling {@link ng.$sce#methods_getTrustedResourceUrl
* $sce.getTrustedResourceUrl} on the template URL. To load templates from other domains and/or
* protocols, you may either either {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist
* them} or {@link ng.$sce#methods_trustAsResourceUrl wrap it} into a trusted value.
*
* *Please note*:
* The browser's
* {@link https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest
* Same Origin Policy} and {@link http://www.w3.org/TR/cors/ Cross-Origin Resource Sharing (CORS)}
* policy apply in addition to this and may further restrict whether the template is successfully
* loaded. This means that without the right CORS policy, loading templates from a different domain
* won't work on all browsers. Also, loading templates from `file://` URL does not work on some
* browsers.
*
* ## This feels like too much overhead for the developer?
*
* It's important to remember that SCE only applies to interpolation expressions.
*
* If your expressions are constant literals, they're automatically trusted and you don't need to
* call `$sce.trustAs` on them. (e.g.
* `<div ng-html-bind-unsafe="'<b>implicitly trusted</b>'"></div>`) just works.
*
* Additionally, `a[href]` and `img[src]` automatically sanitize their URLs and do not pass them
* through {@link ng.$sce#methods_getTrusted $sce.getTrusted}. SCE doesn't play a role here.
*
* The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load
* templates in `ng-include` from your application's domain without having to even know about SCE.
* It blocks loading templates from other domains or loading templates over http from an https
* served document. You can change these by setting your own custom {@link
* ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelists} and {@link
* ng.$sceDelegateProvider#methods_resourceUrlBlacklist blacklists} for matching such URLs.
*
* This significantly reduces the overhead. It is far easier to pay the small overhead and have an
* application that's secure and can be audited to verify that with much more ease than bolting
* security onto an application later.
*
* <a name="contexts"></a>
* ## What trusted context types are supported?
*
* | Context | Notes |
* |---------------------|----------------|
* | `$sce.HTML` | For HTML that's safe to source into the application. The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. |
* | `$sce.CSS` | For CSS that's safe to source into the application. Currently unused. Feel free to use it in your own directives. |
* | `$sce.URL` | For URLs that are safe to follow as links. Currently unused (`<a href=` and `<img src=` sanitize their urls and don't consititute an SCE context. |
* | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contens are also safe to include in your application. Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.) <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` does and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` are required. |
* | `$sce.JS` | For JavaScript that is safe to execute in your application's context. Currently unused. Feel free to use it in your own directives. |
*
* ## Format of items in {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist resourceUrlWhitelist}/{@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist Blacklist} <a name="resourceUrlPatternItem"></a>
*
* Each element in these arrays must be one of the following:
*
* - **'self'**
* - The special **string**, `'self'`, can be used to match against all URLs of the **same
* domain** as the application document using the **same protocol**.
* - **String** (except the special value `'self'`)
* - The string is matched against the full *normalized / absolute URL* of the resource
* being tested (substring matches are not good enough.)
* - There are exactly **two wildcard sequences** - `*` and `**`. All other characters
* match themselves.
* - `*`: matches zero or more occurances of any character other than one of the following 6
* characters: '`:`', '`/`', '`.`', '`?`', '`&`' and ';'. It's a useful wildcard for use
* in a whitelist.
* - `**`: matches zero or more occurances of *any* character. As such, it's not
* not appropriate to use in for a scheme, domain, etc. as it would match too much. (e.g.
* http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might
* not have been the intention.) It's usage at the very end of the path is ok. (e.g.
* http://foo.example.com/templates/**).
* - **RegExp** (*see caveat below*)
* - *Caveat*: While regular expressions are powerful and offer great flexibility, their syntax
* (and all the inevitable escaping) makes them *harder to maintain*. It's easy to
* accidentally introduce a bug when one updates a complex expression (imho, all regexes should
* have good test coverage.). For instance, the use of `.` in the regex is correct only in a
* small number of cases. A `.` character in the regex used when matching the scheme or a
* subdomain could be matched against a `:` or literal `.` that was likely not intended. It
* is highly recommended to use the string patterns and only fall back to regular expressions
* if they as a last resort.
* - The regular expression must be an instance of RegExp (i.e. not a string.) It is
* matched against the **entire** *normalized / absolute URL* of the resource being tested
* (even when the RegExp did not have the `^` and `$` codes.) In addition, any flags
* present on the RegExp (such as multiline, global, ignoreCase) are ignored.
* - If you are generating your Javascript from some other templating engine (not
* recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),
* remember to escape your regular expression (and be aware that you might need more than
* one level of escaping depending on your templating engine and the way you interpolated
* the value.) Do make use of your platform's escaping mechanism as it might be good
* enough before coding your own. e.g. Ruby has
* [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)
* and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).
* Javascript lacks a similar built in function for escaping. Take a look at Google
* Closure library's [goog.string.regExpEscape(s)](
* http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).
*
* Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.
*
* ## Show me an example using SCE.
*
* @example
<example module="mySceApp">
<file name="index.html">
<div ng-controller="myAppController as myCtrl">
<i ng-bind-html="myCtrl.explicitlyTrustedHtml" id="explicitlyTrustedHtml"></i><br><br>
<b>User comments</b><br>
By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when
$sanitize is available. If $sanitize isn't available, this results in an error instead of an
exploit.
<div class="well">
<div ng-repeat="userComment in myCtrl.userComments">
<b>{{userComment.name}}</b>:
<span ng-bind-html="userComment.htmlComment" class="htmlComment"></span>
<br>
</div>
</div>
</div>
</file>
<file name="script.js">
var mySceApp = angular.module('mySceApp', ['ngSanitize']);
mySceApp.controller("myAppController", function myAppController($http, $templateCache, $sce) {
var self = this;
$http.get("test_data.json", {cache: $templateCache}).success(function(userComments) {
self.userComments = userComments;
});
self.explicitlyTrustedHtml = $sce.trustAsHtml(
'<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
'sanitization."">Hover over this text.</span>');
});
</file>
<file name="test_data.json">
[
{ "name": "Alice",
"htmlComment":
"<span onmouseover='this.textContent=\"PWN3D!\"'>Is <i>anyone</i> reading this?</span>"
},
{ "name": "Bob",
"htmlComment": "<i>Yes!</i> Am I the only other one?"
}
]
</file>
<file name="scenario.js">
describe('SCE doc demo', function() {
it('should sanitize untrusted values', function() {
expect(element('.htmlComment').html()).toBe('<span>Is <i>anyone</i> reading this?</span>');
});
it('should NOT sanitize explicitly trusted values', function() {
expect(element('#explicitlyTrustedHtml').html()).toBe(
'<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' +
'sanitization."">Hover over this text.</span>');
});
});
</file>
</example>
*
*
*
* ## Can I disable SCE completely?
*
* Yes, you can. However, this is strongly discouraged. SCE gives you a lot of security benefits
* for little coding overhead. It will be much harder to take an SCE disabled application and
* either secure it on your own or enable SCE at a later stage. It might make sense to disable SCE
* for cases where you have a lot of existing code that was written before SCE was introduced and
* you're migrating them a module at a time.
*
* That said, here's how you can completely disable SCE:
*
* <pre class="prettyprint">
* angular.module('myAppWithSceDisabledmyApp', []).config(function($sceProvider) {
* // Completely disable SCE. For demonstration purposes only!
* // Do not use in new projects.
* $sceProvider.enabled(false);
* });
* </pre>
*
*/ /* jshint maxlen: 100 */ function $SceProvider() {
var enabled = !0;
/**
* @ngdoc function
* @name ng.sceProvider#enabled
* @methodOf ng.$sceProvider
* @function
*
* @param {boolean=} value If provided, then enables/disables SCE.
* @return {boolean} true if SCE is enabled, false otherwise.
*
* @description
* Enables/disables SCE and returns the current value.
*/ this.enabled = function(value) {
return arguments.length && (enabled = !!value), enabled;
}, /* Design notes on the default implementation for SCE.
*
* The API contract for the SCE delegate
* -------------------------------------
* The SCE delegate object must provide the following 3 methods:
*
* - trustAs(contextEnum, value)
* This method is used to tell the SCE service that the provided value is OK to use in the
* contexts specified by contextEnum. It must return an object that will be accepted by
* getTrusted() for a compatible contextEnum and return this value.
*
* - valueOf(value)
* For values that were not produced by trustAs(), return them as is. For values that were
* produced by trustAs(), return the corresponding input value to trustAs. Basically, if
* trustAs is wrapping the given values into some type, this operation unwraps it when given
* such a value.
*
* - getTrusted(contextEnum, value)
* This function should return the a value that is safe to use in the context specified by
* contextEnum or throw and exception otherwise.
*
* NOTE: This contract deliberately does NOT state that values returned by trustAs() must be
* opaque or wrapped in some holder object. That happens to be an implementation detail. For
* instance, an implementation could maintain a registry of all trusted objects by context. In
* such a case, trustAs() would return the same object that was passed in. getTrusted() would
* return the same object passed in if it was found in the registry under a compatible context or
* throw an exception otherwise. An implementation might only wrap values some of the time based
* on some criteria. getTrusted() might return a value and not throw an exception for special
* constants or objects even if not wrapped. All such implementations fulfill this contract.
*
*
* A note on the inheritance model for SCE contexts
* ------------------------------------------------
* I've used inheritance and made RESOURCE_URL wrapped types a subtype of URL wrapped types. This
* is purely an implementation details.
*
* The contract is simply this:
*
* getTrusted($sce.RESOURCE_URL, value) succeeding implies that getTrusted($sce.URL, value)
* will also succeed.
*
* Inheritance happens to capture this in a natural way. In some future, we
* may not use inheritance anymore. That is OK because no code outside of
* sce.js and sceSpecs.js would need to be aware of this detail.
*/ this.$get = [
"$parse",
"$sniffer",
"$sceDelegate",
function($parse, $sniffer, $sceDelegate) {
// Prereq: Ensure that we're not running in IE8 quirks mode. In that mode, IE allows
// the "expression(javascript expression)" syntax which is insecure.
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);
/**
* @ngdoc function
* @name ng.sce#isEnabled
* @methodOf ng.$sce
* @function
*
* @return {Boolean} true if SCE is enabled, false otherwise. If you want to set the value, you
* have to do it at module config time on {@link ng.$sceProvider $sceProvider}.
*
* @description
* Returns a boolean indicating if SCE is enabled.
*/ 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), /**
* @ngdoc method
* @name ng.$sce#parse
* @methodOf ng.$sce
*
* @description
* Converts Angular {@link guide/expression expression} into a function. This is like {@link
* ng.$parse $parse} and is identical when the expression is a literal constant. Otherwise, it
* wraps the expression in a call to {@link ng.$sce#methods_getTrusted $sce.getTrusted(*type*,
* *result*)}
*
* @param {string} type The kind of SCE context in which this result will be used.
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ 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));
};
};
/**
* @ngdoc method
* @name ng.$sce#trustAs
* @methodOf ng.$sce
*
* @description
* Delegates to {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}. As such,
* returns an objectthat is trusted by angular for use in specified strict contextual
* escaping contexts (such as ng-html-bind-unsafe, ng-include, any src attribute
* interpolation, any dom event binding attribute interpolation such as for onclick, etc.)
* that uses the provided value. See * {@link ng.$sce $sce} for enabling strict contextual
* escaping.
*
* @param {string} type The kind of context in which this value is safe for use. e.g. url,
* resource_url, html, js and css.
* @param {*} value The value that that should be considered trusted/safe.
* @returns {*} A value that can be used to stand in for the provided `value` in places
* where Angular expects a $sce.trustAs() return value.
*/ /**
* @ngdoc method
* @name ng.$sce#trustAsHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsHtml(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.HTML, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedHtml
* $sce.getTrustedHtml(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/ /**
* @ngdoc method
* @name ng.$sce#trustAsUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsUrl(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.URL, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedUrl
* $sce.getTrustedUrl(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/ /**
* @ngdoc method
* @name ng.$sce#trustAsResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsResourceUrl(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.RESOURCE_URL, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedResourceUrl
* $sce.getTrustedResourceUrl(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the return
* value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/ /**
* @ngdoc method
* @name ng.$sce#trustAsJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.trustAsJs(value)` →
* {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs($sce.JS, value)`}
*
* @param {*} value The value to trustAs.
* @returns {*} An object that can be passed to {@link ng.$sce#methods_getTrustedJs
* $sce.getTrustedJs(value)} to obtain the original value. (privileged directives
* only accept expressions that are either literal constants or are the
* return value of {@link ng.$sce#methods_trustAs $sce.trustAs}.)
*/ /**
* @ngdoc method
* @name ng.$sce#getTrusted
* @methodOf ng.$sce
*
* @description
* Delegates to {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted`}. As such,
* takes the result of a {@link ng.$sce#methods_trustAs `$sce.trustAs`}() call and returns the
* originally supplied value if the queried context type is a supertype of the created type.
* If this condition isn't satisfied, throws an exception.
*
* @param {string} type The kind of context in which this value is to be used.
* @param {*} maybeTrusted The result of a prior {@link ng.$sce#methods_trustAs `$sce.trustAs`}
* call.
* @returns {*} The value the was originally provided to
* {@link ng.$sce#methods_trustAs `$sce.trustAs`} if valid in this context.
* Otherwise, throws an exception.
*/ /**
* @ngdoc method
* @name ng.$sce#getTrustedHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedHtml(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.HTML, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.HTML, value)`
*/ /**
* @ngdoc method
* @name ng.$sce#getTrustedCss
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedCss(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.CSS, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.CSS, value)`
*/ /**
* @ngdoc method
* @name ng.$sce#getTrustedUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedUrl(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.URL, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.URL, value)`
*/ /**
* @ngdoc method
* @name ng.$sce#getTrustedResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedResourceUrl(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.RESOURCE_URL, value)`}
*
* @param {*} value The value to pass to `$sceDelegate.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.RESOURCE_URL, value)`
*/ /**
* @ngdoc method
* @name ng.$sce#getTrustedJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.getTrustedJs(value)` →
* {@link ng.$sceDelegate#methods_getTrusted `$sceDelegate.getTrusted($sce.JS, value)`}
*
* @param {*} value The value to pass to `$sce.getTrusted`.
* @returns {*} The return value of `$sce.getTrusted($sce.JS, value)`
*/ /**
* @ngdoc method
* @name ng.$sce#parseAsHtml
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsHtml(expression string)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.HTML, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ /**
* @ngdoc method
* @name ng.$sce#parseAsCss
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsCss(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.CSS, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ /**
* @ngdoc method
* @name ng.$sce#parseAsUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsUrl(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.URL, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ /**
* @ngdoc method
* @name ng.$sce#parseAsResourceUrl
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsResourceUrl(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.RESOURCE_URL, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ /**
* @ngdoc method
* @name ng.$sce#parseAsJs
* @methodOf ng.$sce
*
* @description
* Shorthand method. `$sce.parseAsJs(value)` →
* {@link ng.$sce#methods_parse `$sce.parseAs($sce.JS, value)`}
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
* * `context` – `{object}` – an object against which any expressions embedded in the strings
* are evaluated against (typically a scope object).
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
* `context`.
*/ // Shorthand delegations.
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;
}
];
}
/**
* !!! This is an undocumented "private" service !!!
*
* @name ng.$sniffer
* @requires $window
* @requires $document
*
* @property {boolean} history Does the browser support html5 history api ?
* @property {boolean} hashchange Does the browser support hashchange event ?
* @property {boolean} transitions Does the browser support CSS transition events ?
* @property {boolean} animations Does the browser support CSS animation events ?
*
* @description
* This is very simple implementation of testing browser's features.
*/ 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), document1 = $document[0] || {}, documentMode = document1.documentMode, vendorRegex = /^(Moz|webkit|O|ms)(?=[A-Z])/, bodyStyle = document1.body && document1.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(document1.body.style.webkitTransition), animations = isString(document1.body.style.webkitAnimation));
}
return {
// Android has history.pushState, but it does not update location correctly
// so let's not use the history API at all.
// http://code.google.com/p/android/issues/detail?id=17471
// https://github.com/angular/angular.js/issues/904
// older webit browser (533.9) on Boxee box has exactly the same problem as Android has
// so let's not use the history API also
// We are purposefully using `!(android < 4)` to cover the case when `android` is undefined
// jshint -W018
history: !!($window.history && $window.history.pushState && !(android < 4) && !boxee),
// jshint +W018
hashchange: "onhashchange" in $window && // IE8 compatible mode lies
(!documentMode || documentMode > 7),
hasEvent: function(event) {
// IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
// it. In particular the event is not fired when backspace or delete key are pressed or
// when cut operation is performed.
if ("input" == event && 9 == msie) return !1;
if (isUndefined(eventSupport[event])) {
var divElm = document1.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 = {};
/**
* @ngdoc function
* @name ng.$timeout
* @requires $browser
*
* @description
* Angular's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
* block and delegates any exceptions to
* {@link ng.$exceptionHandler $exceptionHandler} service.
*
* The return value of registering a timeout function is a promise, which will be resolved when
* the timeout is reached and the timeout function is executed.
*
* To cancel a timeout request, call `$timeout.cancel(promise)`.
*
* In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
* synchronously flush the queue of deferred functions.
*
* @param {function()} fn A function, whose execution should be delayed.
* @param {number=} [delay=0] Delay in milliseconds.
* @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
* will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
* @returns {Promise} Promise that will be resolved when the timeout is reached. The value this
* promise will be resolved with is the return value of the `fn` function.
*
* @example
<doc:example module="time">
<doc:source>
<script>
function Ctrl2($scope,$timeout) {
$scope.format = 'M/d/yy h:mm:ss a';
$scope.blood_1 = 100;
$scope.blood_2 = 120;
var stop;
$scope.fight = function() {
stop = $timeout(function() {
if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
$scope.blood_1 = $scope.blood_1 - 3;
$scope.blood_2 = $scope.blood_2 - 4;
$scope.fight();
} else {
$timeout.cancel(stop);
}
}, 100);
};
$scope.stopFight = function() {
$timeout.cancel(stop);
};
$scope.resetFight = function() {
$scope.blood_1 = 100;
$scope.blood_2 = 120;
}
}
angular.module('time', [])
// Register the 'myCurrentTime' directive factory method.
// We inject $timeout and dateFilter service since the factory method is DI.
.directive('myCurrentTime', function($timeout, dateFilter) {
// return the directive link function. (compile function not needed)
return function(scope, element, attrs) {
var format, // date format
timeoutId; // timeoutId, so that we can cancel the time updates
// used to update the UI
function updateTime() {
element.text(dateFilter(new Date(), format));
}
// watch the expression, and update the UI on change.
scope.$watch(attrs.myCurrentTime, function(value) {
format = value;
updateTime();
});
// schedule update in one second
function updateLater() {
// save the timeoutId for canceling
timeoutId = $timeout(function() {
updateTime(); // update DOM
updateLater(); // schedule another update
}, 1000);
}
// listen on DOM destroy (removal) event, and cancel the next UI update
// to prevent updating time ofter the DOM element was removed.
element.bind('$destroy', function() {
$timeout.cancel(timeoutId);
});
updateLater(); // kick off the UI update process.
}
});
</script>
<div>
<div ng-controller="Ctrl2">
Date format: <input ng-model="format"> <hr/>
Current time is: <span my-current-time="format"></span>
<hr/>
Blood 1 : <font color='red'>{{blood_1}}</font>
Blood 2 : <font color='red'>{{blood_2}}</font>
<button type="button" data-ng-click="fight()">Fight</button>
<button type="button" data-ng-click="stopFight()">StopFight</button>
<button type="button" data-ng-click="resetFight()">resetFight</button>
</div>
</div>
</doc:source>
</doc:example>
*/ 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(/**
* @ngdoc function
* @name ng.$timeout#cancel
* @methodOf ng.$timeout
*
* @description
* Cancels a task associated with the `promise`. As a result of this, the promise will be
* resolved with a rejection.
*
* @param {Promise=} promise Promise returned by the `$timeout` function.
* @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
* canceled.
*/ 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);
}
];
}
// NOTE: The usage of window and document instead of $window and $document here is
// deliberate. This service depends on the specific behavior of anchor nodes created by the
// browser (resolving and parsing URLs) that is unlikely to be provided by mock objects and
// cause us to break tests. In addition, when the browser resolves a URL for XHR, it
// doesn't know about mocked locations and resolves URLs to the real document - which is
// exactly the behavior needed here. There is little value is mocking these out for this
// service.
var urlParsingNode = document1.createElement("a"), originUrl = urlResolve(window1.location.href, !0);
/**
*
* Implementation Notes for non-IE browsers
* ----------------------------------------
* Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
* results both in the normalizing and parsing of the URL. Normalizing means that a relative
* URL will be resolved into an absolute URL in the context of the application document.
* Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
* properties are all populated to reflect the normalized URL. This approach has wide
* compatibility - Safari 1+, Mozilla 1+, Opera 7+,e etc. See
* http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
*
* Implementation Notes for IE
* ---------------------------
* IE >= 8 and <= 10 normalizes the URL when assigned to the anchor node similar to the other
* browsers. However, the parsed components will not be set if the URL assigned did not specify
* them. (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.) We
* work around that by performing the parsing in a 2nd step by taking a previously normalized
* URL (e.g. by assigning to a.href) and assigning it a.href again. This correctly populates the
* properties such as protocol, hostname, port, etc.
*
* IE7 does not normalize the URL when assigned to an anchor node. (Apparently, it does, if one
* uses the inner HTML approach to assign the URL as part of an HTML snippet -
* http://stackoverflow.com/a/472729) However, setting img[src] does normalize the URL.
* Unfortunately, setting img[src] to something like "javascript:foo" on IE throws an exception.
* Since the primary usage for normalizing URLs is to sanitize such URLs, we can't use that
* method and IE < 8 is unsupported.
*
* References:
* http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
* http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
* http://url.spec.whatwg.org/#urlutils
* https://github.com/angular/angular.js/pull/2902
* http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
*
* @function
* @param {string} url The URL to be parsed.
* @description Normalizes and parses a URL.
* @returns {object} Returns the normalized URL as a dictionary.
*
* | member name | Description |
* |---------------|----------------|
* | href | A normalized version of the provided URL if it was not an absolute URL |
* | protocol | The protocol including the trailing colon |
* | host | The host and port (if the port is non-default) of the normalizedUrl |
* | search | The search params, minus the question mark |
* | hash | The hash string, minus the hash symbol
* | hostname | The hostname
* | port | The port, without ":"
* | pathname | The pathname, beginning with "/"
*
*/ function urlResolve(url, base) {
var href = url;
// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
return msie && (// Normalize before parse. Refer Implementation Notes on why this is
// done in two steps on IE.
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
};
}
/**
* Parse a request URL and determine whether this is a same-origin request as the application document.
*
* @param {string|object} requestUrl The url of the request as a string that will be resolved
* or a parsed URL object.
* @returns {boolean} Whether the request is for the same origin as the application document.
*/ function urlIsSameOrigin(requestUrl) {
var parsed = isString(requestUrl) ? urlResolve(requestUrl) : requestUrl;
return parsed.protocol === originUrl.protocol && parsed.host === originUrl.host;
}
/**
* @ngdoc object
* @name ng.$window
*
* @description
* A reference to the browser's `window` object. While `window`
* is globally available in JavaScript, it causes testability problems, because
* it is a global variable. In angular we always refer to it through the
* `$window` service, so it may be overridden, removed or mocked for testing.
*
* Expressions, like the one defined for the `ngClick` directive in the example
* below, are evaluated with respect to the current scope. Therefore, there is
* no risk of inadvertently coding in a dependency on a global value in such an
* expression.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope, $window) {
$scope.greeting = 'Hello, World!';
$scope.doGreeting = function(greeting) {
$window.alert(greeting);
};
}
</script>
<div ng-controller="Ctrl">
<input type="text" ng-model="greeting" />
<button ng-click="doGreeting(greeting)">ALERT</button>
</div>
</doc:source>
<doc:scenario>
it('should display the greeting in the input box', function() {
input('greeting').enter('Hello, E2E Tests');
// If we click the button it will block the test runner
// element(':button').click();
});
</doc:scenario>
</doc:example>
*/ function $WindowProvider() {
this.$get = valueFn(window1);
}
function $FilterProvider($provide) {
var suffix = "Filter";
/**
* @ngdoc function
* @name ng.$controllerProvider#register
* @methodOf ng.$controllerProvider
* @param {string|Object} name Name of the filter function, or an object map of filters where
* the keys are the filter names and the values are the filter factories.
* @returns {Object} Registered filter instance, or if a map of filters was provided then a map
* of the registered filter instances.
*/ function register(name, factory) {
if (!isObject(name)) return $provide.factory(name + suffix, factory);
var filters = {};
return forEach(name, function(filter, key) {
filters[key] = register(key, filter);
}), filters;
}
this.register = register, this.$get = [
"$injector",
function($injector) {
return function(name) {
return $injector.get(name + suffix);
};
}
], ////////////////////////////////////////
/* global
currencyFilter: false,
dateFilter: false,
filterFilter: false,
jsonFilter: false,
limitToFilter: false,
lowercaseFilter: false,
numberFilter: false,
orderByFilter: false,
uppercaseFilter: false,
*/ 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);
}
/**
* @ngdoc filter
* @name ng.filter:filter
* @function
*
* @description
* Selects a subset of items from `array` and returns it as a new array.
*
* @param {Array} array The source array.
* @param {string|Object|function()} expression The predicate to be used for selecting items from
* `array`.
*
* Can be one of:
*
* - `string`: Predicate that results in a substring match using the value of `expression`
* string. All strings or objects with string properties in `array` that contain this string
* will be returned. The predicate can be negated by prefixing the string with `!`.
*
* - `Object`: A pattern object can be used to filter specific properties on objects contained
* by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
* which have property `name` containing "M" and property `phone` containing "1". A special
* property name `$` can be used (as in `{$:"text"}`) to accept a match against any
* property of the object. That's equivalent to the simple substring match with a `string`
* as described above.
*
* - `function`: A predicate function can be used to write arbitrary filters. The function is
* called for each element of `array`. The final result is an array of those elements that
* the predicate returned true for.
*
* @param {function(expected, actual)|true|undefined} comparator Comparator which is used in
* determining if the expected value (from the filter expression) and actual value (from
* the object in the array) should be considered a match.
*
* Can be one of:
*
* - `function(expected, actual)`:
* The function will be given the object value and the predicate value to compare and
* should return true if the item should be included in filtered result.
*
* - `true`: A shorthand for `function(expected, actual) { return angular.equals(expected, actual)}`.
* this is essentially strict comparison of expected and actual.
*
* - `false|undefined`: A short hand for a function which will look for a substring match in case
* insensitive way.
*
* @example
<doc:example>
<doc:source>
<div ng-init="friends = [{name:'John', phone:'555-1276'},
{name:'Mary', phone:'800-BIG-MARY'},
{name:'Mike', phone:'555-4321'},
{name:'Adam', phone:'555-5678'},
{name:'Julie', phone:'555-8765'},
{name:'Juliette', phone:'555-5678'}]"></div>
Search: <input ng-model="searchText">
<table id="searchTextResults">
<tr><th>Name</th><th>Phone</th></tr>
<tr ng-repeat="friend in friends | filter:searchText">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
</tr>
</table>
<hr>
Any: <input ng-model="search.$"> <br>
Name only <input ng-model="search.name"><br>
Phone only <input ng-model="search.phone"><br>
Equality <input type="checkbox" ng-model="strict"><br>
<table id="searchObjResults">
<tr><th>Name</th><th>Phone</th></tr>
<tr ng-repeat="friend in friends | filter:search:strict">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
</tr>
</table>
</doc:source>
<doc:scenario>
it('should search across all fields when filtering with a string', function() {
input('searchText').enter('m');
expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Mike', 'Adam']);
input('searchText').enter('76');
expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
toEqual(['John', 'Julie']);
});
it('should search in specific fields when filtering with a predicate object', function() {
input('search.$').enter('i');
expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Mike', 'Julie', 'Juliette']);
});
it('should use a equal comparison when comparator is true', function() {
input('search.name').enter('Julie');
input('strict').check();
expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
toEqual(['Julie']);
});
</doc:scenario>
</doc:example>
*/ 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 angular1.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":
if ("object" == typeof text) return comparator(obj, text);
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":
// Set up expression object and fall through
expression = {
$: expression
};
// jshint -W086
case "object":
// jshint +W086
for(var key in expression)"$" == key ? expression[key] && predicates.push(function(value) {
return search(value, expression[key]);
}) : void 0 !== expression[key] && predicates.push(function(value) {
return search(getter(value, key), expression[key]);
});
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);
};
}
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;
// determine fractionSize if it is not specified
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(i = 0, pos = whole.length - lgroup; 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);
// format fraction part.
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];
};
}
/**
* @ngdoc object
* @name ng.$filterProvider
* @description
*
* Filters are just functions which transform input to an output. However filters need to be
* Dependency Injected. To achieve this a filter definition consists of a factory function which is
* annotated with dependencies and is responsible for creating a filter function.
*
* <pre>
* // Filter registration
* function MyModule($provide, $filterProvider) {
* // create a service to demonstrate injection (not always needed)
* $provide.value('greet', function(name){
* return 'Hello ' + name + '!';
* });
*
* // register a filter factory which uses the
* // greet service to demonstrate DI.
* $filterProvider.register('greet', function(greet){
* // return the filter function which uses the greet service
* // to generate salutation
* return function(text) {
* // filters need to be forgiving so check input validity
* return text && greet(text) || text;
* };
* });
* }
* </pre>
*
* The filter function is registered with the `$injector` under the filter name suffix with
* `Filter`.
*
* <pre>
* it('should be the same instance', inject(
* function($filterProvider) {
* $filterProvider.register('reverse', function(){
* return ...;
* });
* },
* function($filter, reverseFilter) {
* expect($filter('reverse')).toBe(reverseFilter);
* });
* </pre>
*
*
* For more information about how angular filters work, and how to create your own filters, see
* {@link guide/filter Filters} in the Angular Developer Guide.
*/ /**
* @ngdoc method
* @name ng.$filterProvider#register
* @methodOf ng.$filterProvider
* @description
* Register filter factory function.
*
* @param {String} name Name of the filter.
* @param {function} fn The filter factory function which is injectable.
*/ /**
* @ngdoc function
* @name ng.$filter
* @function
* @description
* Filters are used for formatting data displayed to the user.
*
* The general syntax in templates is as follows:
*
* {{ expression [| filter_name[:parameter_value] ... ] }}
*
* @param {String} name Name of the filter function to retrieve
* @return {Function} the filter function
*/ $FilterProvider.$inject = [
"$provide"
], /**
* @ngdoc filter
* @name ng.filter:currency
* @function
*
* @description
* Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default
* symbol for current locale is used.
*
* @param {number} amount Input to filter.
* @param {string=} symbol Currency symbol or identifier to be displayed.
* @returns {string} Formatted number.
*
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.amount = 1234.56;
}
</script>
<div ng-controller="Ctrl">
<input type="number" ng-model="amount"> <br>
default currency symbol ($): {{amount | currency}}<br>
custom currency identifier (USD$): {{amount | currency:"USD$"}}
</div>
</doc:source>
<doc:scenario>
it('should init with 1234.56', function() {
expect(binding('amount | currency')).toBe('$1,234.56');
expect(binding('amount | currency:"USD$"')).toBe('USD$1,234.56');
});
it('should update', function() {
input('amount').enter('-1234');
expect(binding('amount | currency')).toBe('($1,234.00)');
expect(binding('amount | currency:"USD$"')).toBe('(USD$1,234.00)');
});
</doc:scenario>
</doc:example>
*/ currencyFilter.$inject = [
"$locale"
], /**
* @ngdoc filter
* @name ng.filter:number
* @function
*
* @description
* Formats a number as text.
*
* If the input is not a number an empty string is returned.
*
* @param {number|string} number Number to format.
* @param {(number|string)=} fractionSize Number of decimal places to round the number to.
* If this is not provided then the fraction size is computed from the current locale's number
* formatting pattern. In the case of the default locale, it will be 3.
* @returns {string} Number rounded to decimalPlaces and places a “,” after each third digit.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.val = 1234.56789;
}
</script>
<div ng-controller="Ctrl">
Enter number: <input ng-model='val'><br>
Default formatting: {{val | number}}<br>
No fractions: {{val | number:0}}<br>
Negative number: {{-val | number:4}}
</div>
</doc:source>
<doc:scenario>
it('should format numbers', function() {
expect(binding('val | number')).toBe('1,234.568');
expect(binding('val | number:0')).toBe('1,235');
expect(binding('-val | number:4')).toBe('-1,234.5679');
});
it('should update', function() {
input('val').enter('3374.333');
expect(binding('val | number')).toBe('3,374.333');
expect(binding('val | number:0')).toBe('3,374');
expect(binding('-val | number:4')).toBe('-3,374.3330');
});
</doc:scenario>
</doc:example>
*/ numberFilter.$inject = [
"$locale"
];
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),
// while ISO 8601 requires fractions to be prefixed with `.` or `,`
// we can be just safely rely on using `sss` since we currently don't support single or two digit fractions
sss: dateGetter("Milliseconds", 3),
EEEE: dateStrGetter("Day"),
EEE: dateStrGetter("Day", !0),
a: function(date, formats) {
return 12 > date.getHours() ? 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) : // 1 2 3 4 5 6 7 8 9 10 11
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(1000 * 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) {
fn = DATE_FORMATS[value], text += fn ? fn(date, $locale.DATETIME_FORMATS) : value.replace(/(^'|'$)/g, "").replace(/''/g, "'");
}), text;
};
}
/**
* @ngdoc filter
* @name ng.filter:json
* @function
*
* @description
* Allows you to convert a JavaScript object into JSON string.
*
* This filter is mostly useful for debugging. When using the double curly {{value}} notation
* the binding is automatically converted to JSON.
*
* @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
* @returns {string} JSON string.
*
*
* @example:
<doc:example>
<doc:source>
<pre>{{ {'name':'value'} | json }}</pre>
</doc:source>
<doc:scenario>
it('should jsonify filtered objects', function() {
expect(binding("{'name':'value'}")).toMatch(/\{\n "name": ?"value"\n}/);
});
</doc:scenario>
</doc:example>
*
*/ function jsonFilter() {
return function(object) {
return toJson(object, !0);
};
}
/**
* @ngdoc filter
* @name ng.filter:date
* @function
*
* @description
* Formats `date` to a string based on the requested `format`.
*
* `format` string can be composed of the following elements:
*
* * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010)
* * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)
* * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199)
* * `'MMMM'`: Month in year (January-December)
* * `'MMM'`: Month in year (Jan-Dec)
* * `'MM'`: Month in year, padded (01-12)
* * `'M'`: Month in year (1-12)
* * `'dd'`: Day in month, padded (01-31)
* * `'d'`: Day in month (1-31)
* * `'EEEE'`: Day in Week,(Sunday-Saturday)
* * `'EEE'`: Day in Week, (Sun-Sat)
* * `'HH'`: Hour in day, padded (00-23)
* * `'H'`: Hour in day (0-23)
* * `'hh'`: Hour in am/pm, padded (01-12)
* * `'h'`: Hour in am/pm, (1-12)
* * `'mm'`: Minute in hour, padded (00-59)
* * `'m'`: Minute in hour (0-59)
* * `'ss'`: Second in minute, padded (00-59)
* * `'s'`: Second in minute (0-59)
* * `'.sss' or ',sss'`: Millisecond in second, padded (000-999)
* * `'a'`: am/pm marker
* * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200)
*
* `format` string can also be one of the following predefined
* {@link guide/i18n localizable formats}:
*
* * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale
* (e.g. Sep 3, 2010 12:05:08 pm)
* * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US locale (e.g. 9/3/10 12:05 pm)
* * `'fullDate'`: equivalent to `'EEEE, MMMM d,y'` for en_US locale
* (e.g. Friday, September 3, 2010)
* * `'longDate'`: equivalent to `'MMMM d, y'` for en_US locale (e.g. September 3, 2010)
* * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US locale (e.g. Sep 3, 2010)
* * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10)
* * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 pm)
* * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 pm)
*
* `format` string can contain literal values. These need to be quoted with single quotes (e.g.
* `"h 'in the morning'"`). In order to output single quote, use two single quotes in a sequence
* (e.g. `"h 'o''clock'"`).
*
* @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or
* number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.SSSZ and its
* shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is
* specified in the string input, the time is considered to be in the local timezone.
* @param {string=} format Formatting rules (see Description). If not specified,
* `mediumDate` is used.
* @returns {string} Formatted string or the input if input is not recognized as date/millis.
*
* @example
<doc:example>
<doc:source>
<span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>:
{{1288323623006 | date:'medium'}}<br>
<span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>:
{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}<br>
<span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>:
{{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}<br>
</doc:source>
<doc:scenario>
it('should format date', function() {
expect(binding("1288323623006 | date:'medium'")).
toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/);
expect(binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).
toMatch(/2010\-10\-2\d \d{2}:\d{2}:\d{2} (\-|\+)?\d{4}/);
expect(binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).
toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/);
});
</doc:scenario>
</doc:example>
*/ dateFilter.$inject = [
"$locale"
];
/**
* @ngdoc filter
* @name ng.filter:lowercase
* @function
* @description
* Converts string to lowercase.
* @see angular.lowercase
*/ var lowercaseFilter = valueFn(lowercase), uppercaseFilter = valueFn(uppercase);
/**
* @ngdoc function
* @name ng.filter:limitTo
* @function
*
* @description
* Creates a new array or string containing only a specified number of elements. The elements
* are taken from either the beginning or the end of the source array or string, as specified by
* the value and sign (positive or negative) of `limit`.
*
* @param {Array|string} input Source array or string to be limited.
* @param {string|number} limit The length of the returned array or string. If the `limit` number
* is positive, `limit` number of items from the beginning of the source array/string are copied.
* If the number is negative, `limit` number of items from the end of the source array/string
* are copied. The `limit` will be trimmed if it exceeds `array.length`
* @returns {Array|string} A new sub-array or substring of length `limit` or less if input array
* had less than `limit` elements.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.numbers = [1,2,3,4,5,6,7,8,9];
$scope.letters = "abcdefghi";
$scope.numLimit = 3;
$scope.letterLimit = 3;
}
</script>
<div ng-controller="Ctrl">
Limit {{numbers}} to: <input type="integer" ng-model="numLimit">
<p>Output numbers: {{ numbers | limitTo:numLimit }}</p>
Limit {{letters}} to: <input type="integer" ng-model="letterLimit">
<p>Output letters: {{ letters | limitTo:letterLimit }}</p>
</div>
</doc:source>
<doc:scenario>
it('should limit the number array to first three items', function() {
expect(element('.doc-example-live input[ng-model=numLimit]').val()).toBe('3');
expect(element('.doc-example-live input[ng-model=letterLimit]').val()).toBe('3');
expect(binding('numbers | limitTo:numLimit')).toEqual('[1,2,3]');
expect(binding('letters | limitTo:letterLimit')).toEqual('abc');
});
it('should update the output when -3 is entered', function() {
input('numLimit').enter(-3);
input('letterLimit').enter(-3);
expect(binding('numbers | limitTo:numLimit')).toEqual('[7,8,9]');
expect(binding('letters | limitTo:letterLimit')).toEqual('ghi');
});
it('should not exceed the maximum size of input array', function() {
input('numLimit').enter(100);
input('letterLimit').enter(100);
expect(binding('numbers | limitTo:numLimit')).toEqual('[1,2,3,4,5,6,7,8,9]');
expect(binding('letters | limitTo:letterLimit')).toEqual('abcdefghi');
});
</doc:scenario>
</doc:example>
*/ function limitToFilter() {
return function(input, limit) {
if (!isArray(input) && !isString(input)) return input;
if (limit = int(limit), isString(input)) return(//NaN check on limit
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) || !sortPredicate) return array;
obj = 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) {
var v1, v2, t1, t2;
return v1 = get(a), v2 = get(b), (t1 = typeof v1) != (t2 = typeof v2) ? t1 < t2 ? -1 : 1 : ("string" == t1 && (v1 = v1.toLowerCase(), v2 = v2.toLowerCase()), v1 === v2) ? 0 : v1 < v2 ? -1 : 1;
}, descending);
}, results = [], forEach(obj, function(value, index, list) {
results.push(iterator.call(void 0, value, index, list));
}), sortPredicate = results;
for(var obj, iterator, results, 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);
}
/**
* @ngdoc function
* @name ng.filter:orderBy
* @function
*
* @description
* Orders a specified `array` by the `expression` predicate.
*
* @param {Array} array The array to sort.
* @param {function(*)|string|Array.<(function(*)|string)>} expression A predicate to be
* used by the comparator to determine the order of elements.
*
* Can be one of:
*
* - `function`: Getter function. The result of this function will be sorted using the
* `<`, `=`, `>` operator.
* - `string`: An Angular expression which evaluates to an object to order by, such as 'name'
* to sort by a property called 'name'. Optionally prefixed with `+` or `-` to control
* ascending or descending sort order (for example, +name or -name).
* - `Array`: An array of function or string predicates. The first predicate in the array
* is used for sorting, but when two items are equivalent, the next predicate is used.
*
* @param {boolean=} reverse Reverse the order the array.
* @returns {Array} Sorted copy of the source array.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.friends =
[{name:'John', phone:'555-1212', age:10},
{name:'Mary', phone:'555-9876', age:19},
{name:'Mike', phone:'555-4321', age:21},
{name:'Adam', phone:'555-5678', age:35},
{name:'Julie', phone:'555-8765', age:29}]
$scope.predicate = '-age';
}
</script>
<div ng-controller="Ctrl">
<pre>Sorting predicate = {{predicate}}; reverse = {{reverse}}</pre>
<hr/>
[ <a href="" ng-click="predicate=''">unsorted</a> ]
<table class="friend">
<tr>
<th><a href="" ng-click="predicate = 'name'; reverse=false">Name</a>
(<a href="" ng-click="predicate = '-name'; reverse=false">^</a>)</th>
<th><a href="" ng-click="predicate = 'phone'; reverse=!reverse">Phone Number</a></th>
<th><a href="" ng-click="predicate = 'age'; reverse=!reverse">Age</a></th>
</tr>
<tr ng-repeat="friend in friends | orderBy:predicate:reverse">
<td>{{friend.name}}</td>
<td>{{friend.phone}}</td>
<td>{{friend.age}}</td>
</tr>
</table>
</div>
</doc:source>
<doc:scenario>
it('should be reverse ordered by aged', function() {
expect(binding('predicate')).toBe('-age');
expect(repeater('table.friend', 'friend in friends').column('friend.age')).
toEqual(['35', '29', '21', '19', '10']);
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Adam', 'Julie', 'Mike', 'Mary', 'John']);
});
it('should reorder the table when user selects different predicate', function() {
element('.doc-example-live a:contains("Name")').click();
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Adam', 'John', 'Julie', 'Mary', 'Mike']);
expect(repeater('table.friend', 'friend in friends').column('friend.age')).
toEqual(['35', '10', '29', '19', '21']);
element('.doc-example-live a:contains("Phone")').click();
expect(repeater('table.friend', 'friend in friends').column('friend.phone')).
toEqual(['555-9876', '555-8765', '555-5678', '555-4321', '555-1212']);
expect(repeater('table.friend', 'friend in friends').column('friend.name')).
toEqual(['Mary', 'Julie', 'Adam', 'Mike', 'John']);
});
</doc:scenario>
</doc:example>
*/ orderByFilter.$inject = [
"$parse"
];
/**
* @ngdoc directive
* @name ng.directive:a
* @restrict E
*
* @description
* Modifies the default behavior of the html A tag so that the default action is prevented when
* the href attribute is empty.
*
* This change permits the easy creation of action links with the `ngClick` directive
* without changing the location or causing page reloads, e.g.:
* `<a href="" ng-click="list.addItem()">Add Item</a>`
*/ var htmlAnchorDirective = valueFn({
restrict: "E",
compile: function(element, attr) {
if (msie <= 8 && (attr.href || attr.name || attr.$set("href", ""), // add a comment node to anchors to workaround IE bug that causes element content to be reset
// to new attribute content if attribute is updated with value containing @ and element also
// contains value with @
// see issue #1949
element.append(document1.createComment("IE fix"))), !attr.href && !attr.name) return function(scope, element) {
element.on("click", function(event) {
// if we have no href url, then don't navigate anywhere.
element.attr("href") || event.preventDefault();
});
};
}
}), ngAttributeAliasDirectives = {};
// boolean attrs are evaluated
forEach(BOOLEAN_ATTR, function(propName, attrName) {
// binding to multiple is not supported
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);
});
};
}
};
};
}
}), // ng-src, ng-srcset, ng-href are interpolated
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]));
});
}
};
};
});
/* global -nullFormCtrl */ 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 = [];
// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
validationErrorKey = validationErrorKey ? "-" + snake_case(validationErrorKey, "-") : "", element.removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
}
// init state
form.$name = attrs.name || attrs.ngForm, form.$dirty = !1, form.$pristine = !0, form.$valid = !0, form.$invalid = !1, parentForm.$addControl(form), // Setup initial state of the control
element.addClass(PRISTINE_CLASS), toggleValidCss(!0), /**
* @ngdoc function
* @name ng.directive:form.FormController#$addControl
* @methodOf ng.directive:form.FormController
*
* @description
* Register a control with the form.
*
* Input elements using ngModelController do this automatically when they are linked.
*/ form.$addControl = function(control) {
// Breaking change - before, inputs whose name was "hasOwnProperty" were quietly ignored
// and not added to the scope. Now we throw an error.
assertNotHasOwnProperty(control.$name, "input"), controls.push(control), control.$name && (form[control.$name] = control);
}, /**
* @ngdoc function
* @name ng.directive:form.FormController#$removeControl
* @methodOf ng.directive:form.FormController
*
* @description
* Deregister a control from the form.
*
* Input elements using ngModelController do this automatically when they are destroyed.
*/ 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);
}, /**
* @ngdoc function
* @name ng.directive:form.FormController#$setValidity
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the validity of a form control.
*
* This method will also propagate to parent forms.
*/ 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;
}
}, /**
* @ngdoc function
* @name ng.directive:form.FormController#$setDirty
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the form to a dirty state.
*
* This method can be called to add the 'ng-dirty' class and set the form to a dirty
* state (ng-dirty class). This method will also propagate to parent forms.
*/ form.$setDirty = function() {
element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS), form.$dirty = !0, form.$pristine = !1, parentForm.$setDirty();
}, /**
* @ngdoc function
* @name ng.directive:form.FormController#$setPristine
* @methodOf ng.directive:form.FormController
*
* @description
* Sets the form to its pristine state.
*
* This method can be called to remove the 'ng-dirty' class and set the form to its pristine
* state (ng-pristine class). This method will also propagate to all the controls contained
* in this form.
*
* Setting a form back to a pristine state is often useful when we want to 'reuse' a form after
* saving or resetting it.
*/ form.$setPristine = function() {
element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS), form.$dirty = !1, form.$pristine = !0, forEach(controls, function(control) {
control.$setPristine();
});
};
}
/**
* @ngdoc object
* @name ng.directive:form.FormController
*
* @property {boolean} $pristine True if user has not interacted with the form yet.
* @property {boolean} $dirty True if user has already interacted with the form.
* @property {boolean} $valid True if all of the containing forms and controls are valid.
* @property {boolean} $invalid True if at least one containing control or form is invalid.
*
* @property {Object} $error Is an object hash, containing references to all invalid controls or
* forms, where:
*
* - keys are validation tokens (error names),
* - values are arrays of controls or forms that are invalid for given error name.
*
*
* Built-in validation tokens:
*
* - `email`
* - `max`
* - `maxlength`
* - `min`
* - `minlength`
* - `number`
* - `pattern`
* - `required`
* - `url`
*
* @description
* `FormController` keeps track of all its controls and nested forms as well as state of them,
* such as being valid/invalid or dirty/pristine.
*
* Each {@link ng.directive:form form} directive creates an instance
* of `FormController`.
*
*/ //asks for $scope to fool the BC controller module
FormController.$inject = [
"$element",
"$attrs",
"$scope"
];
/**
* @ngdoc directive
* @name ng.directive:ngForm
* @restrict EAC
*
* @description
* Nestable alias of {@link ng.directive:form `form`} directive. HTML
* does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a
* sub-group of controls needs to be determined.
*
* @param {string=} ngForm|name Name of the form. If specified, the form controller will be published into
* related scope, under this name.
*
*/ /**
* @ngdoc directive
* @name ng.directive:form
* @restrict E
*
* @description
* Directive that instantiates
* {@link ng.directive:form.FormController FormController}.
*
* If the `name` attribute is specified, the form controller is published onto the current scope under
* this name.
*
* # Alias: {@link ng.directive:ngForm `ngForm`}
*
* In Angular forms can be nested. This means that the outer form is valid when all of the child
* forms are valid as well. However, browsers do not allow nesting of `<form>` elements, so
* Angular provides the {@link ng.directive:ngForm `ngForm`} directive which behaves identically to
* `<form>` but can be nested. This allows you to have nested forms, which is very useful when
* using Angular validation directives in forms that are dynamically generated using the
* {@link ng.directive:ngRepeat `ngRepeat`} directive. Since you cannot dynamically generate the `name`
* attribute of input elements using interpolation, you have to wrap each set of repeated inputs in an
* `ngForm` directive and nest these in an outer `form` element.
*
*
* # CSS classes
* - `ng-valid` Is set if the form is valid.
* - `ng-invalid` Is set if the form is invalid.
* - `ng-pristine` Is set if the form is pristine.
* - `ng-dirty` Is set if the form is dirty.
*
*
* # Submitting a form and preventing the default action
*
* Since the role of forms in client-side Angular applications is different than in classical
* roundtrip apps, it is desirable for the browser not to translate the form submission into a full
* page reload that sends the data to the server. Instead some javascript logic should be triggered
* to handle the form submission in an application-specific way.
*
* For this reason, Angular prevents the default action (form submission to the server) unless the
* `<form>` element has an `action` attribute specified.
*
* You can use one of the following two ways to specify what javascript method should be called when
* a form is submitted:
*
* - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
* - {@link ng.directive:ngClick ngClick} directive on the first
* button or input field of type submit (input[type=submit])
*
* To prevent double execution of the handler, use only one of the {@link ng.directive:ngSubmit ngSubmit}
* or {@link ng.directive:ngClick ngClick} directives.
* This is because of the following form submission rules in the HTML specification:
*
* - If a form has only one input field then hitting enter in this field triggers form submit
* (`ngSubmit`)
* - if a form has 2+ input fields and no buttons or input[type=submit] then hitting enter
* doesn't trigger submit
* - if a form has one or more input fields and one or more buttons or input[type=submit] then
* hitting enter in any of the input fields will trigger the click handler on the *first* button or
* input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`)
*
* @param {string=} name Name of the form. If specified, the form controller will be published into
* related scope, under this name.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.userType = 'guest';
}
</script>
<form name="myForm" ng-controller="Ctrl">
userType: <input name="input" ng-model="userType" required>
<span class="error" ng-show="myForm.input.$error.required">Required!</span><br>
<tt>userType = {{userType}}</tt><br>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('userType')).toEqual('guest');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('userType').enter('');
expect(binding('userType')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/ 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) {
// we can't use jq events because if a form is destroyed during submission the default
// action is not prevented. see #1238
//
// IE 9 is not affected because it doesn't fire a submit event and try to do a full
// page reload if the form was destroyed by submission of the form via a click handler
// on a button in the form. Looks like an IE9 specific bug.
var preventDefaultListener = function(event) {
event.preventDefault ? event.preventDefault() : event.returnValue = !1; // IE
};
addEventListenerFn(formElement[0], "submit", preventDefaultListener), // unregister the preventDefault listener so that we don't not leak memory but in a
// way that will achieve the prevention of the default action.
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 = {
/**
* @ngdoc inputType
* @name ng.directive:input.text
*
* @description
* Standard HTML text input with angular data binding.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Adds `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
* @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'guest';
$scope.word = /^\s*\w*\s*$/;
}
</script>
<form name="myForm" ng-controller="Ctrl">
Single word: <input type="text" name="input" ng-model="text"
ng-pattern="word" required ng-trim="false">
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.pattern">
Single word only!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('guest');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if multi word', function() {
input('text').enter('hello world');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should not be trimmed', function() {
input('text').enter('untrimmed ');
expect(binding('text')).toEqual('untrimmed ');
expect(binding('myForm.input.$valid')).toEqual('true');
});
</doc:scenario>
</doc:example>
*/ text: textInputType,
/**
* @ngdoc inputType
* @name ng.directive:input.number
*
* @description
* Text input with number validation and transformation. Sets the `number` validation
* error if not a valid number.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} min Sets the `min` validation error key if the value entered is less than `min`.
* @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.value = 12;
}
</script>
<form name="myForm" ng-controller="Ctrl">
Number: <input type="number" name="input" ng-model="value"
min="0" max="99" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.number">
Not valid number!</span>
<tt>value = {{value}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('value')).toEqual('12');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('value').enter('');
expect(binding('value')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if over max', function() {
input('value').enter('123');
expect(binding('value')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/ 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)) : (ctrl.$setValidity("number", !1), undefined);
}), 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 ? (ctrl.$setValidity("min", !1), undefined) : (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 ? (ctrl.$setValidity("max", !1), undefined) : (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) : (ctrl.$setValidity("number", !1), undefined);
});
},
/**
* @ngdoc inputType
* @name ng.directive:input.url
*
* @description
* Text input with URL validation. Sets the `url` validation error key if the content is not a
* valid URL.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'http://google.com';
}
</script>
<form name="myForm" ng-controller="Ctrl">
URL: <input type="url" name="input" ng-model="text" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.url">
Not valid url!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
<tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('http://google.com');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if not url', function() {
input('text').enter('xxx');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/ 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) : (ctrl.$setValidity("url", !1), undefined);
};
ctrl.$formatters.push(urlValidator), ctrl.$parsers.push(urlValidator);
},
/**
* @ngdoc inputType
* @name ng.directive:input.email
*
* @description
* Text input with email validation. Sets the `email` validation error key if not a valid email
* address.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.text = 'me@example.com';
}
</script>
<form name="myForm" ng-controller="Ctrl">
Email: <input type="email" name="input" ng-model="text" required>
<span class="error" ng-show="myForm.input.$error.required">
Required!</span>
<span class="error" ng-show="myForm.input.$error.email">
Not valid email!</span>
<tt>text = {{text}}</tt><br/>
<tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
<tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
<tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('text')).toEqual('me@example.com');
expect(binding('myForm.input.$valid')).toEqual('true');
});
it('should be invalid if empty', function() {
input('text').enter('');
expect(binding('text')).toEqual('');
expect(binding('myForm.input.$valid')).toEqual('false');
});
it('should be invalid if not email', function() {
input('text').enter('xxx');
expect(binding('myForm.input.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/ 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) : (ctrl.$setValidity("email", !1), undefined);
};
ctrl.$formatters.push(emailValidator), ctrl.$parsers.push(emailValidator);
},
/**
* @ngdoc inputType
* @name ng.directive:input.radio
*
* @description
* HTML radio button.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string} value The value to which the expression should be set when selected.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.color = 'blue';
}
</script>
<form name="myForm" ng-controller="Ctrl">
<input type="radio" ng-model="color" value="red"> Red <br/>
<input type="radio" ng-model="color" value="green"> Green <br/>
<input type="radio" ng-model="color" value="blue"> Blue <br/>
<tt>color = {{color}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should change state', function() {
expect(binding('color')).toEqual('blue');
input('color').select('red');
expect(binding('color')).toEqual('red');
});
</doc:scenario>
</doc:example>
*/ 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);
},
/**
* @ngdoc inputType
* @name ng.directive:input.checkbox
*
* @description
* HTML checkbox.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} ngTrueValue The value to which the expression should be set when selected.
* @param {string=} ngFalseValue The value to which the expression should be set when not selected.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.value1 = true;
$scope.value2 = 'YES'
}
</script>
<form name="myForm" ng-controller="Ctrl">
Value1: <input type="checkbox" ng-model="value1"> <br/>
Value2: <input type="checkbox" ng-model="value2"
ng-true-value="YES" ng-false-value="NO"> <br/>
<tt>value1 = {{value1}}</tt><br/>
<tt>value2 = {{value2}}</tt><br/>
</form>
</doc:source>
<doc:scenario>
it('should change state', function() {
expect(binding('value1')).toEqual('true');
expect(binding('value2')).toEqual('YES');
input('value1').check();
input('value2').check();
expect(binding('value1')).toEqual('false');
expect(binding('value2')).toEqual('NO');
});
</doc:scenario>
</doc:example>
*/ 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;
}, // Override the standard `$isEmpty` because a value of `false` means empty in a checkbox.
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) {
// In composition mode, users are still inputing intermediate text buffer,
// hold the listener until composition is done.
// More about composition events: https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent
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 the browser does support "input" event, we are fine - except on IE9 which doesn't fire the
// input event on backspace, delete or cut
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;
// ignore
// command modifiers arrows
91 === key || 15 < key && key < 19 || 37 <= key && key <= 40 || deferListener();
}), $sniffer.hasEvent("paste") && element.on("paste cut", deferListener);
}
// if user paste into input using mouse on older browser
// or form autocomplete on newer browser, we need "change" event to catch it
element.on("change", listener), ctrl.$render = function() {
element.val(ctrl.$isEmpty(ctrl.$viewValue) ? "" : ctrl.$viewValue);
};
// pattern validator
var patternValidator, match, pattern = attr.ngPattern, validate = function(regexp, value) {
return ctrl.$isEmpty(value) || regexp.test(value) ? (ctrl.$setValidity("pattern", !0), value) : (ctrl.$setValidity("pattern", !1), undefined);
};
// min length validator
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 ? (ctrl.$setValidity("minlength", !1), undefined) : (ctrl.$setValidity("minlength", !0), value);
};
ctrl.$parsers.push(minLengthValidator), ctrl.$formatters.push(minLengthValidator);
}
// max length validator
if (attr.ngMaxlength) {
var maxlength = int(attr.ngMaxlength), maxLengthValidator = function(value) {
return !ctrl.$isEmpty(value) && value.length > maxlength ? (ctrl.$setValidity("maxlength", !1), undefined) : (ctrl.$setValidity("maxlength", !0), value);
};
ctrl.$parsers.push(maxLengthValidator), ctrl.$formatters.push(maxLengthValidator);
}
}
/**
* @ngdoc directive
* @name ng.directive:textarea
* @restrict E
*
* @description
* HTML textarea element control with angular data-binding. The data-binding and validation
* properties of this element are exactly the same as those of the
* {@link ng.directive:input input element}.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*/ /**
* @ngdoc directive
* @name ng.directive:input
* @restrict E
*
* @description
* HTML input element control with angular data-binding. Input control follows HTML5 input types
* and polyfills the HTML5 validation behavior for older browsers.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {boolean=} ngRequired Sets `required` attribute if set to true
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
* minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
* maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
* RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
* patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
* interaction with the input element.
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.user = {name: 'guest', last: 'visitor'};
}
</script>
<div ng-controller="Ctrl">
<form name="myForm">
User name: <input type="text" name="userName" ng-model="user.name" required>
<span class="error" ng-show="myForm.userName.$error.required">
Required!</span><br>
Last name: <input type="text" name="lastName" ng-model="user.last"
ng-minlength="3" ng-maxlength="10">
<span class="error" ng-show="myForm.lastName.$error.minlength">
Too short!</span>
<span class="error" ng-show="myForm.lastName.$error.maxlength">
Too long!</span><br>
</form>
<hr>
<tt>user = {{user}}</tt><br/>
<tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br>
<tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br>
<tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br>
<tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br>
<tt>myForm.$valid = {{myForm.$valid}}</tt><br>
<tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
<tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br>
<tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br>
</div>
</doc:source>
<doc:scenario>
it('should initialize to model', function() {
expect(binding('user')).toEqual('{"name":"guest","last":"visitor"}');
expect(binding('myForm.userName.$valid')).toEqual('true');
expect(binding('myForm.$valid')).toEqual('true');
});
it('should be invalid if empty when required', function() {
input('user.name').enter('');
expect(binding('user')).toEqual('{"last":"visitor"}');
expect(binding('myForm.userName.$valid')).toEqual('false');
expect(binding('myForm.$valid')).toEqual('false');
});
it('should be valid if empty when min length is set', function() {
input('user.last').enter('');
expect(binding('user')).toEqual('{"name":"guest","last":""}');
expect(binding('myForm.lastName.$valid')).toEqual('true');
expect(binding('myForm.$valid')).toEqual('true');
});
it('should be invalid if less than required min length', function() {
input('user.last').enter('xx');
expect(binding('user')).toEqual('{"name":"guest"}');
expect(binding('myForm.lastName.$valid')).toEqual('false');
expect(binding('myForm.lastName.$error')).toMatch(/minlength/);
expect(binding('myForm.$valid')).toEqual('false');
});
it('should be invalid if longer than max length', function() {
input('user.last').enter('some ridiculously long name');
expect(binding('user'))
.toEqual('{"name":"guest"}');
expect(binding('myForm.lastName.$valid')).toEqual('false');
expect(binding('myForm.lastName.$error')).toMatch(/maxlength/);
expect(binding('myForm.$valid')).toEqual('false');
});
</doc:scenario>
</doc:example>
*/ 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));
/**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$render
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Called when the view needs to be updated. It is expected that the user of the ng-model
* directive will implement this method.
*/ this.$render = noop, /**
* @ngdoc function
* @name { ng.directive:ngModel.NgModelController#$isEmpty
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* This is called when we need to determine if the value of the input is empty.
*
* For instance, the required directive does this to work out if the input has data or not.
* The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`.
*
* You can override this for input directives whose concept of being empty is different to the
* default. The `checkboxInputType` directive does this because in its case a value of `false`
* implies empty.
*/ this.$isEmpty = function(value) {
return isUndefined(value) || "" === value || null === value || value != value;
};
var parentForm = $element.inheritedData("$formController") || nullFormCtrl, invalidCount = 0, $error = this.$error = {}; // keep invalid keys here
// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
validationErrorKey = validationErrorKey ? "-" + snake_case(validationErrorKey, "-") : "", $element.removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
}
// Setup initial state of the control
$element.addClass(PRISTINE_CLASS), toggleValidCss(!0), /**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setValidity
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Change the validity state, and notifies the form when the control changes validity. (i.e. it
* does not notify form if given validator is already marked as invalid).
*
* This method should be called by validators - i.e. the parser or formatter functions.
*
* @param {string} validationErrorKey Name of the validator. the `validationErrorKey` will assign
* to `$error[validationErrorKey]=isValid` so that it is available for data-binding.
* The `validationErrorKey` should be in camelCase and will get converted into dash-case
* for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error`
* class and can be bound to as `{{someForm.someControl.$error.myError}}` .
* @param {boolean} isValid Whether the current state is valid (true) or invalid (false).
*/ this.$setValidity = function(validationErrorKey, isValid) {
// Purposeful use of ! here to cast isValid to boolean in case it is undefined
// jshint -W018
!isValid !== $error[validationErrorKey] && (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));
}, /**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setPristine
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Sets the control to its pristine state.
*
* This method can be called to remove the 'ng-dirty' class and set the control to its pristine
* state (ng-pristine class).
*/ this.$setPristine = function() {
this.$dirty = !1, this.$pristine = !0, $element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS);
}, /**
* @ngdoc function
* @name ng.directive:ngModel.NgModelController#$setViewValue
* @methodOf ng.directive:ngModel.NgModelController
*
* @description
* Update the view value.
*
* This method should be called when the view value changes, typically from within a DOM event handler.
* For example {@link ng.directive:input input} and
* {@link ng.directive:select select} directives call it.
*
* It will update the $viewValue, then pass this value through each of the functions in `$parsers`,
* which includes any validators. The value that comes out of this `$parsers` pipeline, be applied to
* `$modelValue` and the **expression** specified in the `ng-model` attribute.
*
* Lastly, all the registered change listeners, in the `$viewChangeListeners` list, are called.
*
* Note that calling this function does not trigger a `$digest`.
*
* @param {string} value Value from the view.
*/ 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);
}
}));
};
// model -> value
var ctrl = this;
$scope.$watch(function() {
var value = ngModelGet($scope);
// if scope model value and ngModel value are out of sync
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) {
// notify others, especially parent forms
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) {
if (!(attr.required && ctrl.$isEmpty(value))) return ctrl.$setValidity("required", !0), value;
ctrl.$setValidity("required", !1);
};
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 the viewValue is invalid (say required but empty) it will be `undefined`
if (!isUndefined(viewValue)) {
var list = [];
return viewValue && forEach(viewValue.split(separator), function(value) {
value && list.push(trim(value));
}), list;
}
}), ctrl.$formatters.push(function(value) {
return isArray(value) ? value.join(", ") : undefined;
}), // Override the standard $isEmpty because an empty array means the input is empty.
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) {
// We are purposefully using == here rather than === because we want to
// catch when value is "null or undefined"
// jshint -W041
element.text(undefined == value ? "" : value);
});
}), ngBindTemplateDirective = [
"$interpolate",
function($interpolate) {
return function(scope, element, attr) {
// TODO: move this to scenario runner
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) {
// jshint bitwise: false
var mod = 1 & $index;
if (mod !== old$index & 1) {
var classes = flattenClasses(scope.$eval(attr[name]));
mod === selector ? attr.$addClass(classes) : attr.$removeClass(classes);
}
});
}
};
};
}
/**
* @ngdoc directive
* @name ng.directive:ngClass
* @restrict AC
*
* @description
* The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding
* an expression that represents all classes to be added.
*
* The directive won't add duplicate classes if a particular class was already set.
*
* When the expression changes, the previously added classes are removed and only then the
* new classes are added.
*
* @animations
* add - happens just before the class is applied to the element
* remove - happens just before the class is removed from the element
*
* @element ANY
* @param {expression} ngClass {@link guide/expression Expression} to eval. The result
* of the evaluation can be a string representing space delimited class
* names, an array, or a map of class names to boolean values. In the case of a map, the
* names of the properties whose values are truthy will be added as css classes to the
* element.
*
* @example Example that demonstrates basic bindings via ngClass directive.
<example>
<file name="index.html">
<p ng-class="{strike: deleted, bold: important, red: error}">Map Syntax Example</p>
<input type="checkbox" ng-model="deleted"> deleted (apply "strike" class)<br>
<input type="checkbox" ng-model="important"> important (apply "bold" class)<br>
<input type="checkbox" ng-model="error"> error (apply "red" class)
<hr>
<p ng-class="style">Using String Syntax</p>
<input type="text" ng-model="style" placeholder="Type: bold strike red">
<hr>
<p ng-class="[style1, style2, style3]">Using Array Syntax</p>
<input ng-model="style1" placeholder="Type: bold, strike or red"><br>
<input ng-model="style2" placeholder="Type: bold, strike or red"><br>
<input ng-model="style3" placeholder="Type: bold, strike or red"><br>
</file>
<file name="style.css">
.strike {
text-decoration: line-through;
}
.bold {
font-weight: bold;
}
.red {
color: red;
}
</file>
<file name="scenario.js">
it('should let you toggle the class', function() {
expect(element('.doc-example-live p:first').prop('className')).not().toMatch(/bold/);
expect(element('.doc-example-live p:first').prop('className')).not().toMatch(/red/);
input('important').check();
expect(element('.doc-example-live p:first').prop('className')).toMatch(/bold/);
input('error').check();
expect(element('.doc-example-live p:first').prop('className')).toMatch(/red/);
});
it('should let you toggle string example', function() {
expect(element('.doc-example-live p:nth-of-type(2)').prop('className')).toBe('');
input('style').enter('red');
expect(element('.doc-example-live p:nth-of-type(2)').prop('className')).toBe('red');
});
it('array example should have 3 classes', function() {
expect(element('.doc-example-live p:last').prop('className')).toBe('');
input('style1').enter('bold');
input('style2').enter('strike');
input('style3').enter('red');
expect(element('.doc-example-live p:last').prop('className')).toBe('bold strike red');
});
</file>
</example>
## Animations
The example below demonstrates how to perform animations using ngClass.
<example animations="true">
<file name="index.html">
<input type="button" value="set" ng-click="myVar='my-class'">
<input type="button" value="clear" ng-click="myVar=''">
<br>
<span class="base-class" ng-class="myVar">Sample Text</span>
</file>
<file name="style.css">
.base-class {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
}
.base-class.my-class {
color: red;
font-size:3em;
}
</file>
<file name="scenario.js">
it('should check ng-class', function() {
expect(element('.doc-example-live span').prop('className')).not().
toMatch(/my-class/);
using('.doc-example-live').element(':button:first').click();
expect(element('.doc-example-live span').prop('className')).
toMatch(/my-class/);
using('.doc-example-live').element(':button:last').click();
expect(element('.doc-example-live span').prop('className')).not().
toMatch(/my-class/);
});
</file>
</example>
## ngClass and pre-existing CSS3 Transitions/Animations
The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
to view the step by step details of {@link ngAnimate.$animate#methods_addclass $animate.addClass} and
{@link ngAnimate.$animate#methods_removeclass $animate.removeClass}.
*/ 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
});
});
});
};
}
};
}
];
});
/**
* @ngdoc directive
* @name ng.directive:ngDblclick
*
* @description
* The `ngDblclick` directive allows you to specify custom behavior on a dblclick event.
*
* @element ANY
* @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon
* a dblclick. (The Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMousedown
*
* @description
* The ngMousedown directive allows you to specify custom behavior on mousedown event.
*
* @element ANY
* @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon
* mousedown. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMouseup
*
* @description
* Specify custom behavior on mouseup event.
*
* @element ANY
* @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon
* mouseup. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMouseover
*
* @description
* Specify custom behavior on mouseover event.
*
* @element ANY
* @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon
* mouseover. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMouseenter
*
* @description
* Specify custom behavior on mouseenter event.
*
* @element ANY
* @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon
* mouseenter. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMouseleave
*
* @description
* Specify custom behavior on mouseleave event.
*
* @element ANY
* @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon
* mouseleave. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngMousemove
*
* @description
* Specify custom behavior on mousemove event.
*
* @element ANY
* @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon
* mousemove. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngKeydown
*
* @description
* Specify custom behavior on keydown event.
*
* @element ANY
* @param {expression} ngKeydown {@link guide/expression Expression} to evaluate upon
* keydown. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngKeyup
*
* @description
* Specify custom behavior on keyup event.
*
* @element ANY
* @param {expression} ngKeyup {@link guide/expression Expression} to evaluate upon
* keyup. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngKeypress
*
* @description
* Specify custom behavior on keypress event.
*
* @element ANY
* @param {expression} ngKeypress {@link guide/expression Expression} to evaluate upon
* keypress. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngSubmit
*
* @description
* Enables binding angular expressions to onsubmit events.
*
* Additionally it prevents the default action (which for form means sending the request to the
* server and reloading the current page) **but only if the form does not contain an `action`
* attribute**.
*
* @element form
* @param {expression} ngSubmit {@link guide/expression Expression} to eval. (Event object is available as `$event`)
*
* @example
<doc:example>
<doc:source>
<script>
function Ctrl($scope) {
$scope.list = [];
$scope.text = 'hello';
$scope.submit = function() {
if (this.text) {
this.list.push(this.text);
this.text = '';
}
};
}
</script>
<form ng-submit="submit()" ng-controller="Ctrl">
Enter text and hit enter:
<input type="text" ng-model="text" name="text" />
<input type="submit" id="submit" value="Submit" />
<pre>list={{list}}</pre>
</form>
</doc:source>
<doc:scenario>
it('should check ng-submit', function() {
expect(binding('list')).toBe('[]');
element('.doc-example-live #submit').click();
expect(binding('list')).toBe('["hello"]');
expect(input('text').val()).toBe('');
});
it('should ignore empty strings', function() {
expect(binding('list')).toBe('[]');
element('.doc-example-live #submit').click();
element('.doc-example-live #submit').click();
expect(binding('list')).toBe('["hello"]');
});
</doc:scenario>
</doc:example>
*/ /**
* @ngdoc directive
* @name ng.directive:ngFocus
*
* @description
* Specify custom behavior on focus event.
*
* @element window, input, select, textarea, a
* @param {expression} ngFocus {@link guide/expression Expression} to evaluate upon
* focus. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngBlur
*
* @description
* Specify custom behavior on blur event.
*
* @element window, input, select, textarea, a
* @param {expression} ngBlur {@link guide/expression Expression} to evaluate upon
* blur. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngCopy
*
* @description
* Specify custom behavior on copy event.
*
* @element window, input, select, textarea, a
* @param {expression} ngCopy {@link guide/expression Expression} to evaluate upon
* copy. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngCut
*
* @description
* Specify custom behavior on cut event.
*
* @element window, input, select, textarea, a
* @param {expression} ngCut {@link guide/expression Expression} to evaluate upon
* cut. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngPaste
*
* @description
* Specify custom behavior on paste event.
*
* @element window, input, select, textarea, a
* @param {expression} ngPaste {@link guide/expression Expression} to evaluate upon
* paste. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/ /**
* @ngdoc directive
* @name ng.directive:ngIf
* @restrict A
*
* @description
* The `ngIf` directive removes or recreates a portion of the DOM tree based on an
* {expression}. If the expression assigned to `ngIf` evaluates to a false
* value then the element is removed from the DOM, otherwise a clone of the
* element is reinserted into the DOM.
*
* `ngIf` differs from `ngShow` and `ngHide` in that `ngIf` completely removes and recreates the
* element in the DOM rather than changing its visibility via the `display` css property. A common
* case when this difference is significant is when using css selectors that rely on an element's
* position within the DOM, such as the `:first-child` or `:last-child` pseudo-classes.
*
* Note that when an element is removed using `ngIf` its scope is destroyed and a new scope
* is created when the element is restored. The scope created within `ngIf` inherits from
* its parent scope using
* {@link https://github.com/angular/angular.js/wiki/The-Nuances-of-Scope-Prototypal-Inheritance prototypal inheritance}.
* An important implication of this is if `ngModel` is used within `ngIf` to bind to
* a javascript primitive defined in the parent scope. In this case any modifications made to the
* variable within the child scope will override (hide) the value in the parent scope.
*
* Also, `ngIf` recreates elements using their compiled state. An example of this behavior
* is if an element's class attribute is directly modified after it's compiled, using something like
* jQuery's `.addClass()` method, and the element is later removed. When `ngIf` recreates the element
* the added class will be lost because the original compiled state is used to regenerate the element.
*
* Additionally, you can provide animations via the `ngAnimate` module to animate the `enter`
* and `leave` effects.
*
* @animations
* enter - happens just after the ngIf contents change and a new DOM element is created and injected into the ngIf container
* leave - happens just before the ngIf contents are removed from the DOM
*
* @element ANY
* @scope
* @priority 600
* @param {expression} ngIf If the {@link guide/expression expression} is falsy then
* the element is removed from the DOM tree. If it is truthy a copy of the compiled
* element is added to the DOM tree.
*
* @example
<example animations="true">
<file name="index.html">
Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /><br/>
Show when checked:
<span ng-if="checked" class="animate-if">
I'm removed when the checkbox is unchecked.
</span>
</file>
<file name="animations.css">
.animate-if {
background:white;
border:1px solid black;
padding:10px;
}
/*
The transition styles can also be placed on the CSS base class above
*/
.animate-if.ng-enter, .animate-if.ng-leave {
-webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
}
.animate-if.ng-enter,
.animate-if.ng-leave.ng-leave-active {
opacity:0;
}
.animate-if.ng-leave,
.animate-if.ng-enter.ng-enter-active {
opacity:1;
}
</file>
</example>
*/ 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 || $transclude(childScope = $scope.$new(), function(clone) {
clone[clone.length++] = document1.createComment(" end ngIf: " + $attr.ngIf + " "), // Note: We only need the first/last node of the cloned nodes.
// However, we need to keep the reference to the jqlite wrapper as it might be changed later
// by a directive with templateUrl when it's template arrives.
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: angular1.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;
// Note: This will also link all children of ng-include that were contained in the original
// html. If that content contains controllers, ... they could pollute/change the scope.
// However, using ng-include on an element with additional content does not make sense...
// Note: We can't remove them in the cloneAttchFn of $transclude as that
// function is called before linking the content, which would apply child
// directives to non existing elements.
var clone = $transclude(newScope, function(clone) {
cleanupLastIncludeContent(), $animate.enter(clone, null, $element, afterAnimation);
});
currentScope = newScope, currentElement = clone, currentScope.$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: 1000
}), 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 NG_REMOVED = "$$NG_REMOVED", ngRepeatMinErr = minErr("ngRepeat");
return {
transclude: "element",
priority: 1000,
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];
// Store a list of elements from previous run. This is a hash where key is the item from the
// iterator, and the value is objects with following properties.
// - scope: bound scope
// - element: previous element.
// - index: position
var lastBlockMap = {};
//watch props
$scope.$watchCollection(rhs, function(collection) {
var index, length, nextNode, arrayLength, childScope, key, value, trackById, trackByIdFn, collectionKeys, block, elementsToRemove, previousNode = $element[0], // Same as lastBlockMap but it has the current state. It will become the
// lastBlockMap on the next iteration.
nextBlockMap = {}, nextBlockOrder = [];
if (isArrayLike(collection)) collectionKeys = collection, trackByIdFn = trackByIdExpFn || trackByIdArrayFn;
else {
for(key in trackByIdFn = trackByIdExpFn || trackByIdObjFn, // if object, extract keys, sort them and use to determine order of iteration over obj props
collectionKeys = [], collection)collection.hasOwnProperty(key) && "$" != key.charAt(0) && collectionKeys.push(key);
collectionKeys.sort();
}
for(index = 0, arrayLength = collectionKeys.length, // locate existing items
length = nextBlockOrder.length = collectionKeys.length; index < length; index++)if (key = collection === collectionKeys ? index : collectionKeys[index], value = collection[key], assertNotHasOwnProperty(trackById = trackByIdFn(key, value, index), "`track by` id"), lastBlockMap.hasOwnProperty(trackById)) block = lastBlockMap[trackById], delete lastBlockMap[trackById], nextBlockMap[trackById] = block, nextBlockOrder[index] = block;
else if (nextBlockMap.hasOwnProperty(trackById)) // This is a duplicate and we need to throw an error
throw(// restore lastBlockMap
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));
else // new never before seen block
nextBlockOrder[index] = {
id: trackById
}, nextBlockMap[trackById] = !1;
// remove existing items
for(key in lastBlockMap)// lastBlockMap is our own object so we don't need to use special hasOwnPropertyFn
lastBlockMap.hasOwnProperty(key) && (elementsToRemove = getBlockElements((block = lastBlockMap[key]).clone), $animate.leave(elementsToRemove), forEach(elementsToRemove, function(element) {
element[NG_REMOVED] = !0;
}), block.scope.$destroy());
// we are not using forEach for perf reasons (trying to avoid #call)
for(index = 0, length = collectionKeys.length; index < length; index++){
if (key = collection === collectionKeys ? index : collectionKeys[index], value = collection[key], block = nextBlockOrder[index], nextBlockOrder[index - 1] && (previousNode = getBlockEnd(nextBlockOrder[index - 1])), block.scope) {
// if we have already seen this object, then we need to reuse the
// associated scope/element
childScope = block.scope, nextNode = previousNode;
do nextNode = nextNode.nextSibling;
while (nextNode && nextNode[NG_REMOVED])
block.clone[0] != nextNode && // existing item which got moved
$animate.move(getBlockElements(block.clone), null, jqLite(previousNode)), previousNode = getBlockEnd(block);
} else // new item which we don't know about
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), // jshint bitwise: false
childScope.$odd = !(childScope.$even = (1 & index) == 0), block.scope || $transclude(childScope, function(clone) {
clone[clone.length++] = document1.createComment(" end ngRepeat: " + expression + " "), $animate.enter(clone, null, jqLite(previousNode)), previousNode = clone, block.scope = childScope, // Note: We only need the first/last node of the cloned nodes.
// However, we need to keep the reference to the jqlite wrapper as it might be changed later
// by a directive with templateUrl when it's template arrives.
block.clone = clone, nextBlockMap[block.id] = block;
});
}
lastBlockMap = nextBlockMap;
});
}
};
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",
// asks for $scope to fool the BC controller module
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));
// remember the transclusion fn but call it during linking so that we don't process transclusion before directives on
// the parent element even when the transclusion replaces the current element. (we can't use priority here because
// that applies only to compile fns and not controllers
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, // IE is not consistent, in scripts we have to read .text but in other nodes we have to read .textContent
text = element[0].text;
$templateCache.put(templateUrl, text);
}
}
};
}
], ngOptionsMinErr = minErr("ngOptions"), ngOptionsDirective = valueFn({
terminal: !0
}), selectDirective = [
"$compile",
"$parse",
function($compile, $parse) {
//0000111110000000000022220000000000000000000000333300000000000000444444444444444000000000555555555555555000000066666666666666600000000000000007777000000000000000000088888
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
};
// jshint maxlen: 100
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_, 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() {
// disable unknown option so that we don't do work when the whole select is being destroyed
self.renderUnknownOption = noop;
});
}
],
link: function(scope, element, attr, ctrls) {
// if ngModel is not defined, we don't need to do anything
if (ctrls[1]) {
// find "null" option
for(var scope1, selectElement, ctrl, lastView, scope2, selectElement1, ngModelCtrl, selectCtrl, emptyOption, selectCtrl1 = ctrls[0], ngModelCtrl1 = ctrls[1], multiple = attr.multiple, optionsExp = attr.ngOptions, nullOption = !1, // we can't just jqLite('<option>') since jqLite is not smart enough
// to create it in <select> and IE barfs otherwise.
optionTemplate = jqLite(document1.createElement("option")), optGroupTemplate = jqLite(document1.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;
}
// required validator
if (selectCtrl1.init(ngModelCtrl1, nullOption, unknownOption), multiple && (attr.required || attr.ngRequired)) {
var requiredValidator = function(value) {
return ngModelCtrl1.$setValidity("required", !attr.required || value && value.length), value;
};
ngModelCtrl1.$parsers.push(requiredValidator), ngModelCtrl1.$formatters.unshift(requiredValidator), attr.$observe("required", function() {
requiredValidator(ngModelCtrl1.$viewValue);
});
}
optionsExp ? function(scope, selectElement, ctrl) {
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 match, 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, // This is an array of array of existing option groups in DOM.
// We try to reuse these if possible
// - optionGroupsCache[0] is the options with no option group
// - optionGroupsCache[?][0] is the parent: either the SELECT or OPTGROUP element
optionGroupsCache = [
[
{
element: selectElement,
label: ""
}
]
];
function render() {
// Temporary location for the option groups before we render them
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);
}
// We now build up the list of options we need (we merge later)
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; // see if at least one item is selected
}
// doing displayFn(scope, locals) || '' overwrites zero values
label = isDefined(label = displayFn(scope, locals)) ? label : "", optionGroup.push({
// either the index into array or key from object
id: trackFn ? trackFn(scope, locals) : keyName ? keys[index] : index,
label: label,
selected: selected
});
}
// Now we need to update the list of DOM nodes to match the optionGroups we computed above
for(multiple || (nullOption || null === modelValue ? // insert null option if we have a placeholder, or the model is null
optionGroups[""].unshift({
id: "",
label: "",
selected: !selectedSet
}) : selectedSet || // option could not be found, we have to insert the undefined item
optionGroups[""].unshift({
id: "?",
label: "",
selected: !0
})), groupIndex = 0, groupLength = optionGroupNames.length; groupIndex < groupLength; groupIndex++){
for(// list of options for that group. (first item has the parent)
optionGroup = optionGroups[// current option group name or '' if no group
optionGroupName = optionGroupNames[groupIndex]], optionGroupsCache.length <= groupIndex ? (existingOptions = [
// we need to grow the optionGroups
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]) ? (// reuse elements
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 ? // put back the pre-compiled element
element = nullOption : // jQuery(v1.4.2) Bug: We should be able to chain the method calls, but
// in this version of jQuery on some browser the .text() returns a string
// rather then the element.
(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(// remove any excessive OPTIONs in a group
index++; existingOptions.length > index;)existingOptions.pop().element.remove();
}
// remove any excessive OPTGROUPs from select
for(; optionGroupsCache.length > groupIndex;)optionGroupsCache.pop()[0].element.remove();
}
nullOption && (// compile the element since there might be bindings in it
$compile(nullOption)(scope), // remove the class, which is added automatically because we recompile the element and it
// becomes the compilation root
nullOption.removeClass("ng-scope"), // we need to remove it before calling selectElement.empty() because otherwise IE will
// remove the label from the element. wtf?
nullOption.remove()), // clear contents, we'll add what's needed based on the model
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(groupIndex = 0, value = [], groupLength = optionGroupsCache.length; groupIndex < groupLength; groupIndex++)for(index = 1, length = // list of options for that group. (first item has the parent)
(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, // TODO(vojta): can't we optimize this ?
scope.$watch(render);
}(scope, element, ngModelCtrl1) : multiple ? (scope1 = scope, selectElement = element, (ctrl = ngModelCtrl1).$render = function() {
var items = new HashMap(ctrl.$viewValue);
forEach(selectElement.find("option"), function(option) {
option.selected = isDefined(items.get(option.value));
});
}, // we have to do it on each watch since ngModel watches reference, but
// we need to work of an array, so we need to see if anything was inserted/removed
scope1.$watch(function() {
equals(lastView, ctrl.$viewValue) || (lastView = copy(ctrl.$viewValue), ctrl.$render());
}), selectElement.on("change", function() {
scope1.$apply(function() {
var array = [];
forEach(selectElement.find("option"), function(option) {
option.selected && array.push(option.value);
}), ctrl.$setViewValue(array);
});
})) : (scope2 = scope, selectElement1 = element, ngModelCtrl = ngModelCtrl1, selectCtrl = selectCtrl1, ngModelCtrl.$render = function() {
var viewValue = ngModelCtrl.$viewValue;
selectCtrl.hasOption(viewValue) ? (unknownOption.parent() && unknownOption.remove(), selectElement1.val(viewValue), "" === viewValue && emptyOption.prop("selected", !0)) : isUndefined(viewValue) && emptyOption ? selectElement1.val("") : selectCtrl.renderUnknownOption(viewValue);
}, selectElement1.on("change", function() {
scope2.$apply(function() {
unknownOption.parent() && unknownOption.remove(), ngModelCtrl.$setViewValue(selectElement1.val());
});
}));
}
}
};
}
], 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 selectCtrlName = "$selectController", parent = element.parent(), selectCtrl = parent.data(selectCtrlName) || parent.parent().data(selectCtrlName); // in case we are in optgroup
selectCtrl && selectCtrl.databound ? // For some reason Opera defaults to true and if not overridden this messes up the repeater.
// We don't want the view to drive the initialization of the model anyway.
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
});
// bind to jQuery if present;
(jQuery = window1.jQuery) ? (jqLite = jQuery, extend(jQuery.fn, {
scope: JQLitePrototype.scope,
isolateScope: JQLitePrototype.isolateScope,
controller: JQLitePrototype.controller,
injector: JQLitePrototype.injector,
inheritedData: JQLitePrototype.inheritedData
}), // Method signature:
// jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments)
jqLitePatchJQueryRemove("remove", !0, !0, !1), jqLitePatchJQueryRemove("empty", !1, !1, !1), jqLitePatchJQueryRemove("html", !1, !1, !0)) : jqLite = JQLite, angular1.element = jqLite, function(angular1) {
extend(angular1, {
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 = /**
* @ngdoc interface
* @name angular.Module
* @description
*
* Interface for configuring angular {@link angular.module modules}.
*/ function(window1) {
var $injectorMinErr = minErr("$injector"), ngMinErr = minErr("ng");
function ensure(obj, name, factory) {
return obj[name] || (obj[name] = factory());
}
var angular1 = ensure(window1, "angular", Object);
return(// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
angular1.$$minErr = angular1.$$minErr || minErr, ensure(angular1, "module", function() {
/** @type {Object.<string, angular.Module>} */ var modules = {};
/**
* @ngdoc function
* @name angular.module
* @description
*
* The `angular.module` is a global place for creating, registering and retrieving Angular
* modules.
* All modules (angular core or 3rd party) that should be available to an application must be
* registered using this mechanism.
*
* When passed two or more arguments, a new module is created. If passed only one argument, an
* existing module (the name passed as the first argument to `module`) is retrieved.
*
*
* # Module
*
* A module is a collection of services, directives, filters, and configuration information.
* `angular.module` is used to configure the {@link AUTO.$injector $injector}.
*
* <pre>
* // Create a new module
* var myModule = angular.module('myModule', []);
*
* // register a new service
* myModule.value('appName', 'MyCoolApp');
*
* // configure existing services inside initialization blocks.
* myModule.config(function($locationProvider) {
* // Configure existing providers
* $locationProvider.hashPrefix('!');
* });
* </pre>
*
* Then you can create an injector and load your modules like this:
*
* <pre>
* var injector = angular.injector(['ng', 'MyModule'])
* </pre>
*
* However it's more likely that you'll just use
* {@link ng.directive:ngApp ngApp} or
* {@link angular.bootstrap} to simplify this process for you.
*
* @param {!string} name The name of the module to create or retrieve.
* @param {Array.<string>=} requires If specified then new module is being created. If
* unspecified then the the module is being retrieved for further configuration.
* @param {Function} configFn Optional configuration function for the module. Same as
* {@link angular.Module#methods_config Module#config()}.
* @returns {module} new module with the {@link angular.Module} api.
*/ return function(name, requires, configFn) {
return function(name, context) {
if ("hasOwnProperty" === name) throw ngMinErr("badname", "hasOwnProperty is not a valid {0} name", context);
}(name, "module"), 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);
/** @type {!Array.<Array.<*>>} */ var invokeQueue = [], runBlocks = [], config = invokeLater("$injector", "invoke"), moduleInstance = {
// Private state
_invokeQueue: invokeQueue,
_runBlocks: runBlocks,
/**
* @ngdoc property
* @name angular.Module#requires
* @propertyOf angular.Module
* @returns {Array.<string>} List of module names which must be loaded before this module.
* @description
* Holds the list of modules which the injector will load before the current module is
* loaded.
*/ requires: requires,
/**
* @ngdoc property
* @name angular.Module#name
* @propertyOf angular.Module
* @returns {string} Name of the module.
* @description
*/ name: name,
/**
* @ngdoc method
* @name angular.Module#provider
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} providerType Construction function for creating new instance of the
* service.
* @description
* See {@link AUTO.$provide#provider $provide.provider()}.
*/ provider: invokeLater("$provide", "provider"),
/**
* @ngdoc method
* @name angular.Module#factory
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} providerFunction Function for creating new instance of the service.
* @description
* See {@link AUTO.$provide#factory $provide.factory()}.
*/ factory: invokeLater("$provide", "factory"),
/**
* @ngdoc method
* @name angular.Module#service
* @methodOf angular.Module
* @param {string} name service name
* @param {Function} constructor A constructor function that will be instantiated.
* @description
* See {@link AUTO.$provide#service $provide.service()}.
*/ service: invokeLater("$provide", "service"),
/**
* @ngdoc method
* @name angular.Module#value
* @methodOf angular.Module
* @param {string} name service name
* @param {*} object Service instance object.
* @description
* See {@link AUTO.$provide#value $provide.value()}.
*/ value: invokeLater("$provide", "value"),
/**
* @ngdoc method
* @name angular.Module#constant
* @methodOf angular.Module
* @param {string} name constant name
* @param {*} object Constant value.
* @description
* Because the constant are fixed, they get applied before other provide methods.
* See {@link AUTO.$provide#constant $provide.constant()}.
*/ constant: invokeLater("$provide", "constant", "unshift"),
/**
* @ngdoc method
* @name angular.Module#animation
* @methodOf angular.Module
* @param {string} name animation name
* @param {Function} animationFactory Factory function for creating new instance of an
* animation.
* @description
*
* **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
*
*
* Defines an animation hook that can be later used with
* {@link ngAnimate.$animate $animate} service and directives that use this service.
*
* <pre>
* module.animation('.animation-name', function($inject1, $inject2) {
* return {
* eventName : function(element, done) {
* //code to run the animation
* //once complete, then run done()
* return function cancellationFunction(element) {
* //code to cancel the animation
* }
* }
* }
* })
* </pre>
*
* See {@link ngAnimate.$animateProvider#register $animateProvider.register()} and
* {@link ngAnimate ngAnimate module} for more information.
*/ animation: invokeLater("$animateProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#filter
* @methodOf angular.Module
* @param {string} name Filter name.
* @param {Function} filterFactory Factory function for creating new instance of filter.
* @description
* See {@link ng.$filterProvider#register $filterProvider.register()}.
*/ filter: invokeLater("$filterProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#controller
* @methodOf angular.Module
* @param {string|Object} name Controller name, or an object map of controllers where the
* keys are the names and the values are the constructors.
* @param {Function} constructor Controller constructor function.
* @description
* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
*/ controller: invokeLater("$controllerProvider", "register"),
/**
* @ngdoc method
* @name angular.Module#directive
* @methodOf angular.Module
* @param {string|Object} name Directive name, or an object map of directives where the
* keys are the names and the values are the factories.
* @param {Function} directiveFactory Factory function for creating new instance of
* directives.
* @description
* See {@link ng.$compileProvider#methods_directive $compileProvider.directive()}.
*/ directive: invokeLater("$compileProvider", "directive"),
/**
* @ngdoc method
* @name angular.Module#config
* @methodOf angular.Module
* @param {Function} configFn Execute this function on module load. Useful for service
* configuration.
* @description
* Use this method to register work which needs to be performed on module loading.
*/ config: config,
/**
* @ngdoc method
* @name angular.Module#run
* @methodOf angular.Module
* @param {Function} initializationFn Execute this function after injector creation.
* Useful for application initialization.
* @description
* Use this method to register work which should be performed when the injector is done
* loading all modules.
*/ run: function(block) {
return runBlocks.push(block), this;
}
};
return configFn && config(configFn), moduleInstance;
/**
* @param {string} provider
* @param {string} method
* @param {String=} insertMethod
* @returns {angular.Module}
*/ function invokeLater(provider, method, insertMethod) {
return function() {
return invokeQueue[insertMethod || "push"]([
provider,
method,
arguments
]), moduleInstance;
};
}
});
};
}));
}(window1);
try {
angularModule("ngLocale");
} catch (e) {
angularModule("ngLocale", []).provider("$locale", $LocaleProvider);
}
angularModule("ng", [
"ngLocale"
], [
"$provide",
function($provide) {
// $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
$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
});
}
]);
}(angular1), jqLite(document1).ready(function() {
!/**
* @ngdoc directive
* @name ng.directive:ngApp
*
* @element ANY
* @param {angular.Module} ngApp an optional application
* {@link angular.module module} name to load.
*
* @description
*
* Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
* designates the **root element** of the application and is typically placed near the root element
* of the page - e.g. on the `<body>` or `<html>` tags.
*
* Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
* found in the document will be used to define the root element to auto-bootstrap as an
* application. To run multiple applications in an HTML document you must manually bootstrap them using
* {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
*
* You can specify an **AngularJS module** to be used as the root module for the application. This
* module will be loaded into the {@link AUTO.$injector} when the application is bootstrapped and
* should contain the application code needed or have dependencies on other modules that will
* contain the code. See {@link angular.module} for more information.
*
* In the example below if the `ngApp` directive were not placed on the `html` element then the
* document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
* would not be resolved to `3`.
*
* `ngApp` is the easiest, and most common, way to bootstrap an application.
*
<example module="ngAppDemo">
<file name="index.html">
<div ng-controller="ngAppDemoController">
I can add: {{a}} + {{b}} = {{ a+b }}
</file>
<file name="script.js">
angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
$scope.a = 1;
$scope.b = 2;
});
</file>
</example>
*
*/ 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(document1.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
] : []);
}(document1, 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>');
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/backbone-1.1.0.js | JavaScript | // Backbone.js 1.1.0
// (c) 2010-2011 Jeremy Ashkenas, DocumentCloud Inc.
// (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Backbone may be freely distributed under the MIT license.
// For all details and documentation:
// http://backbonejs.org
(function() {
// Initial Setup
// -------------
// Save a reference to the global object (`window` in the browser, `exports`
// on the server).
var Backbone, root = this, previousBackbone = root.Backbone, slice = [].slice;
// Current version of the library. Keep in sync with `package.json`.
(Backbone = "undefined" != typeof exports ? exports : root.Backbone = {}).VERSION = "1.1.0";
// Require Underscore, if we're on the server, and it's not already present.
var _ = root._;
_ || "undefined" == typeof require || (_ = require("underscore")), // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
// the `$` variable.
Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$, // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
// to its previous owner. Returns a reference to this Backbone object.
Backbone.noConflict = function() {
return root.Backbone = previousBackbone, this;
}, // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
// will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and
// set a `X-Http-Method-Override` header.
Backbone.emulateHTTP = !1, // Turn on `emulateJSON` to support legacy servers that can't deal with direct
// `application/json` requests ... will encode the body as
// `application/x-www-form-urlencoded` instead and will send the model in a
// form param named `model`.
Backbone.emulateJSON = !1;
// Backbone.Events
// ---------------
// A module that can be mixed in to *any object* in order to provide it with
// custom events. You may bind with `on` or remove with `off` callback
// functions to an event; `trigger`-ing an event fires all callbacks in
// succession.
//
// var object = {};
// _.extend(object, Backbone.Events);
// object.on('expand', function(){ alert('expanded'); });
// object.trigger('expand');
//
var Events = Backbone.Events = {
// Bind an event to a `callback` function. Passing `"all"` will bind
// the callback to all events fired.
on: function(name, callback, context) {
return eventsApi(this, "on", name, [
callback,
context
]) && callback && (this._events || (this._events = {}), (this._events[name] || (this._events[name] = [])).push({
callback: callback,
context: context,
ctx: context || this
})), this;
},
// Bind an event to only be triggered a single time. After the first time
// the callback is invoked, it will be removed.
once: function(name, callback, context) {
if (!eventsApi(this, "once", name, [
callback,
context
]) || !callback) return this;
var self = this, once = _.once(function() {
self.off(name, once), callback.apply(this, arguments);
});
return once._callback = callback, this.on(name, once, context);
},
// Remove one or many callbacks. If `context` is null, removes all
// callbacks with that function. If `callback` is null, removes all
// callbacks for the event. If `name` is null, removes all bound
// callbacks for all events.
off: function(name, callback, context) {
var retain, ev, events, names, i, l, j, k;
if (!this._events || !eventsApi(this, "off", name, [
callback,
context
])) return this;
if (!name && !callback && !context) return this._events = {}, this;
for(i = 0, l = (names = name ? [
name
] : _.keys(this._events)).length; i < l; i++)if (name = names[i], events = this._events[name]) {
if (this._events[name] = retain = [], callback || context) for(j = 0, k = events.length; j < k; j++)ev = events[j], (callback && callback !== ev.callback && callback !== ev.callback._callback || context && context !== ev.context) && retain.push(ev);
retain.length || delete this._events[name];
}
return this;
},
// Trigger one or many events, firing all bound callbacks. Callbacks are
// passed the same arguments as `trigger` is, apart from the event name
// (unless you're listening on `"all"`, which will cause your callback to
// receive the true name of the event as the first argument).
trigger: function(name) {
if (!this._events) return this;
var args = slice.call(arguments, 1);
if (!eventsApi(this, "trigger", name, args)) return this;
var events = this._events[name], allEvents = this._events.all;
return events && triggerEvents(events, args), allEvents && triggerEvents(allEvents, arguments), this;
},
// Tell this object to stop listening to either specific events ... or
// to every object it's currently listening to.
stopListening: function(obj, name, callback) {
var listeningTo = this._listeningTo;
if (!listeningTo) return this;
var remove = !name && !callback;
for(var id in callback || "object" != typeof name || (callback = this), obj && ((listeningTo = {})[obj._listenId] = obj), listeningTo)(obj = listeningTo[id]).off(name, callback, this), (remove || _.isEmpty(obj._events)) && delete this._listeningTo[id];
return this;
}
}, eventSplitter = /\s+/, eventsApi = function(obj, action, name, rest) {
if (!name) return !0;
// Handle event maps.
if ("object" == typeof name) {
for(var key in name)obj[action].apply(obj, [
key,
name[key]
].concat(rest));
return !1;
}
// Handle space separated event names.
if (eventSplitter.test(name)) {
for(var names = name.split(eventSplitter), i = 0, l = names.length; i < l; i++)obj[action].apply(obj, [
names[i]
].concat(rest));
return !1;
}
return !0;
}, triggerEvents = function(events, args) {
var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
switch(args.length){
case 0:
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx);
return;
case 1:
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1);
return;
case 2:
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1, a2);
return;
case 3:
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
return;
default:
for(; ++i < l;)(ev = events[i]).callback.apply(ev.ctx, args);
}
};
// Inversion-of-control versions of `on` and `once`. Tell *this* object to
// listen to an event in another object ... keeping track of what it's
// listening to.
_.each({
listenTo: "on",
listenToOnce: "once"
}, function(implementation, method) {
Events[method] = function(obj, name, callback) {
return (this._listeningTo || (this._listeningTo = {}))[obj._listenId || (obj._listenId = _.uniqueId("l"))] = obj, callback || "object" != typeof name || (callback = this), obj[implementation](name, callback, this), this;
};
}), // Aliases for backwards compatibility.
Events.bind = Events.on, Events.unbind = Events.off, // Allow the `Backbone` object to serve as a global event bus, for folks who
// want global "pubsub" in a convenient place.
_.extend(Backbone, Events);
// Backbone.Model
// --------------
// Backbone **Models** are the basic data object in the framework --
// frequently representing a row in a table in a database on your server.
// A discrete chunk of data and a bunch of useful, related methods for
// performing computations and transformations on that data.
// Create a new model with the specified attributes. A client id (`cid`)
// is automatically generated and assigned for you.
var Model = Backbone.Model = function(attributes, options) {
var attrs = attributes || {};
options || (options = {}), this.cid = _.uniqueId("c"), this.attributes = {}, options.collection && (this.collection = options.collection), options.parse && (attrs = this.parse(attrs, options) || {}), attrs = _.defaults({}, attrs, _.result(this, "defaults")), this.set(attrs, options), this.changed = {}, this.initialize.apply(this, arguments);
};
// Attach all inheritable methods to the Model prototype.
_.extend(Model.prototype, Events, {
// A hash of attributes whose current and previous value differ.
changed: null,
// The value returned during the last failed validation.
validationError: null,
// The default name for the JSON `id` attribute is `"id"`. MongoDB and
// CouchDB users may want to set this to `"_id"`.
idAttribute: "id",
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function() {},
// Return a copy of the model's `attributes` object.
toJSON: function(options) {
return _.clone(this.attributes);
},
// Proxy `Backbone.sync` by default -- but override this if you need
// custom syncing semantics for *this* particular model.
sync: function() {
return Backbone.sync.apply(this, arguments);
},
// Get the value of an attribute.
get: function(attr) {
return this.attributes[attr];
},
// Get the HTML-escaped value of an attribute.
escape: function(attr) {
return _.escape(this.get(attr));
},
// Returns `true` if the attribute contains a value that is not null
// or undefined.
has: function(attr) {
return null != this.get(attr);
},
// Set a hash of model attributes on the object, firing `"change"`. This is
// the core primitive operation of a model, updating the data and notifying
// anyone who needs to know about the change in state. The heart of the beast.
set: function(key, val, options) {
var attr, attrs, unset, changes, silent, changing, prev, current;
if (null == key) return this;
// Run validation.
if ("object" == typeof key ? (attrs = key, options = val) : (attrs = {})[key] = val, options || (options = {}), !this._validate(attrs, options)) return !1;
// For each `set` attribute, update or delete the current value.
for(attr in // Extract attributes and options.
unset = options.unset, silent = options.silent, changes = [], changing = this._changing, this._changing = !0, changing || (this._previousAttributes = _.clone(this.attributes), this.changed = {}), current = this.attributes, prev = this._previousAttributes, this.idAttribute in attrs && (this.id = attrs[this.idAttribute]), attrs)val = attrs[attr], _.isEqual(current[attr], val) || changes.push(attr), _.isEqual(prev[attr], val) ? delete this.changed[attr] : this.changed[attr] = val, unset ? delete current[attr] : current[attr] = val;
// Trigger all relevant attribute changes.
if (!silent) {
changes.length && (this._pending = !0);
for(var i = 0, l = changes.length; i < l; i++)this.trigger("change:" + changes[i], this, current[changes[i]], options);
}
// You might be wondering why there's a `while` loop here. Changes can
// be recursively nested within `"change"` events.
if (changing) return this;
if (!silent) for(; this._pending;)this._pending = !1, this.trigger("change", this, options);
return this._pending = !1, this._changing = !1, this;
},
// Remove an attribute from the model, firing `"change"`. `unset` is a noop
// if the attribute doesn't exist.
unset: function(attr, options) {
return this.set(attr, void 0, _.extend({}, options, {
unset: !0
}));
},
// Clear all attributes on the model, firing `"change"`.
clear: function(options) {
var attrs = {};
for(var key in this.attributes)attrs[key] = void 0;
return this.set(attrs, _.extend({}, options, {
unset: !0
}));
},
// Determine if the model has changed since the last `"change"` event.
// If you specify an attribute name, determine if that attribute has changed.
hasChanged: function(attr) {
return null == attr ? !_.isEmpty(this.changed) : _.has(this.changed, attr);
},
// Return an object containing all the attributes that have changed, or
// false if there are no changed attributes. Useful for determining what
// parts of a view need to be updated and/or what attributes need to be
// persisted to the server. Unset attributes will be set to undefined.
// You can also pass an attributes object to diff against the model,
// determining if there *would be* a change.
changedAttributes: function(diff) {
if (!diff) return !!this.hasChanged() && _.clone(this.changed);
var val, changed = !1, old = this._changing ? this._previousAttributes : this.attributes;
for(var attr in diff)_.isEqual(old[attr], val = diff[attr]) || ((changed || (changed = {}))[attr] = val);
return changed;
},
// Get the previous value of an attribute, recorded at the time the last
// `"change"` event was fired.
previous: function(attr) {
return null != attr && this._previousAttributes ? this._previousAttributes[attr] : null;
},
// Get all of the attributes of the model at the time of the previous
// `"change"` event.
previousAttributes: function() {
return _.clone(this._previousAttributes);
},
// Fetch the model from the server. If the server's representation of the
// model differs from its current attributes, they will be overridden,
// triggering a `"change"` event.
fetch: function(options) {
void 0 === (options = options ? _.clone(options) : {}).parse && (options.parse = !0);
var model = this, success = options.success;
return options.success = function(resp) {
if (!model.set(model.parse(resp, options), options)) return !1;
success && success(model, resp, options), model.trigger("sync", model, resp, options);
}, wrapError(this, options), this.sync("read", this, options);
},
// Set a hash of model attributes, and sync the model to the server.
// If the server returns an attributes hash that differs, the model's
// state will be `set` again.
save: function(key, val, options) {
var attrs, method, xhr, attributes = this.attributes;
// If we're not waiting and attributes exist, save acts as
// `set(attr).save(null, opts)` with validation. Otherwise, check if
// the model will be valid when the attributes, if any, are set.
if (null == key || "object" == typeof key ? (attrs = key, options = val) : (attrs = {})[key] = val, options = _.extend({
validate: !0
}, options), attrs && !options.wait) {
if (!this.set(attrs, options)) return !1;
} else if (!this._validate(attrs, options)) return !1;
attrs && options.wait && (this.attributes = _.extend({}, attributes, attrs)), void 0 === options.parse && (options.parse = !0);
var model = this, success = options.success;
return options.success = function(resp) {
// Ensure attributes are restored during synchronous saves.
model.attributes = attributes;
var serverAttrs = model.parse(resp, options);
if (options.wait && (serverAttrs = _.extend(attrs || {}, serverAttrs)), _.isObject(serverAttrs) && !model.set(serverAttrs, options)) return !1;
success && success(model, resp, options), model.trigger("sync", model, resp, options);
}, wrapError(this, options), "patch" == (method = this.isNew() ? "create" : options.patch ? "patch" : "update") && (options.attrs = attrs), xhr = this.sync(method, this, options), attrs && options.wait && (this.attributes = attributes), xhr;
},
// Destroy this model on the server if it was already persisted.
// Optimistically removes the model from its collection, if it has one.
// If `wait: true` is passed, waits for the server to respond before removal.
destroy: function(options) {
options = options ? _.clone(options) : {};
var model = this, success = options.success, destroy = function() {
model.trigger("destroy", model, model.collection, options);
};
if (options.success = function(resp) {
(options.wait || model.isNew()) && destroy(), success && success(model, resp, options), model.isNew() || model.trigger("sync", model, resp, options);
}, this.isNew()) return options.success(), !1;
wrapError(this, options);
var xhr = this.sync("delete", this, options);
return options.wait || destroy(), xhr;
},
// Default URL for the model's representation on the server -- if you're
// using Backbone's restful methods, override this to change the endpoint
// that will be called.
url: function() {
var base = _.result(this, "urlRoot") || _.result(this.collection, "url") || urlError();
return this.isNew() ? base : base + ("/" === base.charAt(base.length - 1) ? "" : "/") + encodeURIComponent(this.id);
},
// **parse** converts a response into the hash of attributes to be `set` on
// the model. The default implementation is just to pass the response along.
parse: function(resp, options) {
return resp;
},
// Create a new model with identical attributes to this one.
clone: function() {
return new this.constructor(this.attributes);
},
// A model is new if it has never been saved to the server, and lacks an id.
isNew: function() {
return null == this.id;
},
// Check if the model is currently in a valid state.
isValid: function(options) {
return this._validate({}, _.extend(options || {}, {
validate: !0
}));
},
// Run validation against the next complete set of model attributes,
// returning `true` if all is well. Otherwise, fire an `"invalid"` event.
_validate: function(attrs, options) {
if (!options.validate || !this.validate) return !0;
attrs = _.extend({}, this.attributes, attrs);
var error = this.validationError = this.validate(attrs, options) || null;
return !error || (this.trigger("invalid", this, error, _.extend(options, {
validationError: error
})), !1);
}
}), // Mix in each Underscore method as a proxy to `Model#attributes`.
_.each([
"keys",
"values",
"pairs",
"invert",
"pick",
"omit"
], function(method) {
Model.prototype[method] = function() {
var args = slice.call(arguments);
return args.unshift(this.attributes), _[method].apply(_, args);
};
});
// Backbone.Collection
// -------------------
// If models tend to represent a single row of data, a Backbone Collection is
// more analagous to a table full of data ... or a small slice or page of that
// table, or a collection of rows that belong together for a particular reason
// -- all of the messages in this particular folder, all of the documents
// belonging to this particular author, and so on. Collections maintain
// indexes of their models, both in order, and for lookup by `id`.
// Create a new **Collection**, perhaps to contain a specific type of `model`.
// If a `comparator` is specified, the Collection will maintain
// its models in sort order, as they're added and removed.
var Collection = Backbone.Collection = function(models, options) {
options || (options = {}), options.model && (this.model = options.model), void 0 !== options.comparator && (this.comparator = options.comparator), this._reset(), this.initialize.apply(this, arguments), models && this.reset(models, _.extend({
silent: !0
}, options));
}, setOptions = {
add: !0,
remove: !0,
merge: !0
}, addOptions = {
add: !0,
remove: !1
};
// Define the Collection's inheritable methods.
_.extend(Collection.prototype, Events, {
// The default model for a collection is just a **Backbone.Model**.
// This should be overridden in most cases.
model: Model,
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function() {},
// The JSON representation of a Collection is an array of the
// models' attributes.
toJSON: function(options) {
return this.map(function(model) {
return model.toJSON(options);
});
},
// Proxy `Backbone.sync` by default.
sync: function() {
return Backbone.sync.apply(this, arguments);
},
// Add a model, or list of models to the set.
add: function(models, options) {
return this.set(models, _.extend({
merge: !1
}, options, addOptions));
},
// Remove a model, or a list of models from the set.
remove: function(models, options) {
var i, l, index, model, singular = !_.isArray(models);
for(models = singular ? [
models
] : _.clone(models), options || (options = {}), i = 0, l = models.length; i < l; i++)(model = models[i] = this.get(models[i])) && (delete this._byId[model.id], delete this._byId[model.cid], index = this.indexOf(model), this.models.splice(index, 1), this.length--, options.silent || (options.index = index, model.trigger("remove", model, this, options)), this._removeReference(model));
return singular ? models[0] : models;
},
// Update a collection by `set`-ing a new list of models, adding new ones,
// removing models that are no longer present, and merging models that
// already exist in the collection, as necessary. Similar to **Model#set**,
// the core operation for updating the data contained by the collection.
set: function(models, options) {
(options = _.defaults({}, options, setOptions)).parse && (models = this.parse(models, options));
var i, l, id, model, attrs, existing, sort, singular = !_.isArray(models);
models = singular ? models ? [
models
] : [] : _.clone(models);
var at = options.at, targetModel = this.model, sortable = this.comparator && null == at && !1 !== options.sort, sortAttr = _.isString(this.comparator) ? this.comparator : null, toAdd = [], toRemove = [], modelMap = {}, add = options.add, merge = options.merge, remove = options.remove, order = !sortable && !!add && !!remove && [];
// Turn bare objects into model references, and prevent invalid models
// from being added.
for(i = 0, l = models.length; i < l; i++){
// If a duplicate is found, prevent it from being added and
// optionally merge it into the existing model.
if (id = (attrs = models[i]) instanceof Model ? model = attrs : attrs[targetModel.prototype.idAttribute], existing = this.get(id)) remove && (modelMap[existing.cid] = !0), merge && (attrs = attrs === model ? model.attributes : attrs, options.parse && (attrs = existing.parse(attrs, options)), existing.set(attrs, options), sortable && !sort && existing.hasChanged(sortAttr) && (sort = !0)), models[i] = existing;
else if (add) {
if (!(model = models[i] = this._prepareModel(attrs, options))) continue;
toAdd.push(model), // Listen to added models' events, and index models for lookup by
// `id` and by `cid`.
model.on("all", this._onModelEvent, this), this._byId[model.cid] = model, null != model.id && (this._byId[model.id] = model);
}
order && order.push(existing || model);
}
// Remove nonexistent models if appropriate.
if (remove) {
for(i = 0, l = this.length; i < l; ++i)modelMap[(model = this.models[i]).cid] || toRemove.push(model);
toRemove.length && this.remove(toRemove, options);
}
// See if sorting is needed, update `length` and splice in new models.
if (toAdd.length || order && order.length) {
if (sortable && (sort = !0), this.length += toAdd.length, null != at) for(i = 0, l = toAdd.length; i < l; i++)this.models.splice(at + i, 0, toAdd[i]);
else {
order && (this.models.length = 0);
var orderedModels = order || toAdd;
for(i = 0, l = orderedModels.length; i < l; i++)this.models.push(orderedModels[i]);
}
}
// Unless silenced, it's time to fire all appropriate add/sort events.
if (sort && this.sort({
silent: !0
}), !options.silent) {
for(i = 0, l = toAdd.length; i < l; i++)(model = toAdd[i]).trigger("add", model, this, options);
(sort || order && order.length) && this.trigger("sort", this, options);
}
// Return the added (or merged) model (or models).
return singular ? models[0] : models;
},
// When you have more items than you want to add or remove individually,
// you can reset the entire set with a new list of models, without firing
// any granular `add` or `remove` events. Fires `reset` when finished.
// Useful for bulk operations and optimizations.
reset: function(models, options) {
options || (options = {});
for(var i = 0, l = this.models.length; i < l; i++)this._removeReference(this.models[i]);
return options.previousModels = this.models, this._reset(), models = this.add(models, _.extend({
silent: !0
}, options)), options.silent || this.trigger("reset", this, options), models;
},
// Add a model to the end of the collection.
push: function(model, options) {
return this.add(model, _.extend({
at: this.length
}, options));
},
// Remove a model from the end of the collection.
pop: function(options) {
var model = this.at(this.length - 1);
return this.remove(model, options), model;
},
// Add a model to the beginning of the collection.
unshift: function(model, options) {
return this.add(model, _.extend({
at: 0
}, options));
},
// Remove a model from the beginning of the collection.
shift: function(options) {
var model = this.at(0);
return this.remove(model, options), model;
},
// Slice out a sub-array of models from the collection.
slice: function() {
return slice.apply(this.models, arguments);
},
// Get a model from the set by id.
get: function(obj) {
if (null != obj) return this._byId[obj.id] || this._byId[obj.cid] || this._byId[obj];
},
// Get the model at the given index.
at: function(index) {
return this.models[index];
},
// Return models with matching attributes. Useful for simple cases of
// `filter`.
where: function(attrs, first) {
return _.isEmpty(attrs) ? first ? void 0 : [] : this[first ? "find" : "filter"](function(model) {
for(var key in attrs)if (attrs[key] !== model.get(key)) return !1;
return !0;
});
},
// Return the first model with matching attributes. Useful for simple cases
// of `find`.
findWhere: function(attrs) {
return this.where(attrs, !0);
},
// Force the collection to re-sort itself. You don't need to call this under
// normal circumstances, as the set will maintain sort order as each item
// is added.
sort: function(options) {
if (!this.comparator) throw Error("Cannot sort a set without a comparator");
return options || (options = {}), _.isString(this.comparator) || 1 === this.comparator.length ? this.models = this.sortBy(this.comparator, this) : this.models.sort(_.bind(this.comparator, this)), options.silent || this.trigger("sort", this, options), this;
},
// Pluck an attribute from each model in the collection.
pluck: function(attr) {
return _.invoke(this.models, "get", attr);
},
// Fetch the default set of models for this collection, resetting the
// collection when they arrive. If `reset: true` is passed, the response
// data will be passed through the `reset` method instead of `set`.
fetch: function(options) {
void 0 === (options = options ? _.clone(options) : {}).parse && (options.parse = !0);
var success = options.success, collection = this;
return options.success = function(resp) {
collection[options.reset ? "reset" : "set"](resp, options), success && success(collection, resp, options), collection.trigger("sync", collection, resp, options);
}, wrapError(this, options), this.sync("read", this, options);
},
// Create a new instance of a model in this collection. Add the model to the
// collection immediately, unless `wait: true` is passed, in which case we
// wait for the server to agree.
create: function(model, options) {
if (options = options ? _.clone(options) : {}, !(model = this._prepareModel(model, options))) return !1;
options.wait || this.add(model, options);
var collection = this, success = options.success;
return options.success = function(model, resp, options) {
options.wait && collection.add(model, options), success && success(model, resp, options);
}, model.save(null, options), model;
},
// **parse** converts a response into a list of models to be added to the
// collection. The default implementation is just to pass it through.
parse: function(resp, options) {
return resp;
},
// Create a new collection with an identical list of models as this one.
clone: function() {
return new this.constructor(this.models);
},
// Private method to reset all internal state. Called when the collection
// is first initialized or reset.
_reset: function() {
this.length = 0, this.models = [], this._byId = {};
},
// Prepare a hash of attributes (or other model) to be added to this
// collection.
_prepareModel: function(attrs, options) {
if (attrs instanceof Model) return attrs.collection || (attrs.collection = this), attrs;
(options = options ? _.clone(options) : {}).collection = this;
var model = new this.model(attrs, options);
return model.validationError ? (this.trigger("invalid", this, model.validationError, options), !1) : model;
},
// Internal method to sever a model's ties to a collection.
_removeReference: function(model) {
this === model.collection && delete model.collection, model.off("all", this._onModelEvent, this);
},
// Internal method called every time a model in the set fires an event.
// Sets need to update their indexes when models change ids. All other
// events simply proxy through. "add" and "remove" events that originate
// in other collections are ignored.
_onModelEvent: function(event, model, collection, options) {
("add" !== event && "remove" !== event || collection === this) && ("destroy" === event && this.remove(model, options), model && event === "change:" + model.idAttribute && (delete this._byId[model.previous(model.idAttribute)], null != model.id && (this._byId[model.id] = model)), this.trigger.apply(this, arguments));
}
}), // Mix in each Underscore method as a proxy to `Collection#models`.
_.each([
"forEach",
"each",
"map",
"collect",
"reduce",
"foldl",
"inject",
"reduceRight",
"foldr",
"find",
"detect",
"filter",
"select",
"reject",
"every",
"all",
"some",
"any",
"include",
"contains",
"invoke",
"max",
"min",
"toArray",
"size",
"first",
"head",
"take",
"initial",
"rest",
"tail",
"drop",
"last",
"without",
"difference",
"indexOf",
"shuffle",
"lastIndexOf",
"isEmpty",
"chain"
], function(method) {
Collection.prototype[method] = function() {
var args = slice.call(arguments);
return args.unshift(this.models), _[method].apply(_, args);
};
}), // Use attributes instead of properties.
_.each([
"groupBy",
"countBy",
"sortBy"
], function(method) {
Collection.prototype[method] = function(value, context) {
var iterator = _.isFunction(value) ? value : function(model) {
return model.get(value);
};
return _[method](this.models, iterator, context);
};
});
// Backbone.View
// -------------
// Backbone Views are almost more convention than they are actual code. A View
// is simply a JavaScript object that represents a logical chunk of UI in the
// DOM. This might be a single item, an entire list, a sidebar or panel, or
// even the surrounding frame which wraps your whole app. Defining a chunk of
// UI as a **View** allows you to define your DOM events declaratively, without
// having to worry about render order ... and makes it easy for the view to
// react to specific changes in the state of your models.
// Creating a Backbone.View creates its initial element outside of the DOM,
// if an existing element is not provided...
var View = Backbone.View = function(options) {
this.cid = _.uniqueId("view"), options || (options = {}), _.extend(this, _.pick(options, viewOptions)), this._ensureElement(), this.initialize.apply(this, arguments), this.delegateEvents();
}, delegateEventSplitter = /^(\S+)\s*(.*)$/, viewOptions = [
"model",
"collection",
"el",
"id",
"attributes",
"className",
"tagName",
"events"
];
// Set up all inheritable **Backbone.View** properties and methods.
_.extend(View.prototype, Events, {
// The default `tagName` of a View's element is `"div"`.
tagName: "div",
// jQuery delegate for element lookup, scoped to DOM elements within the
// current view. This should be preferred to global lookups where possible.
$: function(selector) {
return this.$el.find(selector);
},
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function() {},
// **render** is the core function that your view should override, in order
// to populate its element (`this.el`), with the appropriate HTML. The
// convention is for **render** to always return `this`.
render: function() {
return this;
},
// Remove this view by taking the element out of the DOM, and removing any
// applicable Backbone.Events listeners.
remove: function() {
return this.$el.remove(), this.stopListening(), this;
},
// Change the view's element (`this.el` property), including event
// re-delegation.
setElement: function(element, delegate) {
return this.$el && this.undelegateEvents(), this.$el = element instanceof Backbone.$ ? element : Backbone.$(element), this.el = this.$el[0], !1 !== delegate && this.delegateEvents(), this;
},
// Set callbacks, where `this.events` is a hash of
//
// *{"event selector": "callback"}*
//
// {
// 'mousedown .title': 'edit',
// 'click .button': 'save',
// 'click .open': function(e) { ... }
// }
//
// pairs. Callbacks will be bound to the view, with `this` set properly.
// Uses event delegation for efficiency.
// Omitting the selector binds the event to `this.el`.
// This only works for delegate-able events: not `focus`, `blur`, and
// not `change`, `submit`, and `reset` in Internet Explorer.
delegateEvents: function(events) {
if (!(events || (events = _.result(this, "events")))) return this;
for(var key in this.undelegateEvents(), events){
var method = events[key];
if (_.isFunction(method) || (method = this[events[key]]), method) {
var match = key.match(delegateEventSplitter), eventName = match[1], selector = match[2];
method = _.bind(method, this), eventName += ".delegateEvents" + this.cid, "" === selector ? this.$el.on(eventName, method) : this.$el.on(eventName, selector, method);
}
}
return this;
},
// Clears all callbacks previously bound to the view with `delegateEvents`.
// You usually don't need to use this, but may wish to if you have multiple
// Backbone views attached to the same DOM element.
undelegateEvents: function() {
return this.$el.off(".delegateEvents" + this.cid), this;
},
// Ensure that the View has a DOM element to render into.
// If `this.el` is a string, pass it through `$()`, take the first
// matching element, and re-assign it to `el`. Otherwise, create
// an element from the `id`, `className` and `tagName` properties.
_ensureElement: function() {
if (this.el) this.setElement(_.result(this, "el"), !1);
else {
var attrs = _.extend({}, _.result(this, "attributes"));
this.id && (attrs.id = _.result(this, "id")), this.className && (attrs.class = _.result(this, "className"));
var $el = Backbone.$("<" + _.result(this, "tagName") + ">").attr(attrs);
this.setElement($el, !1);
}
}
}), // Backbone.sync
// -------------
// Override this function to change the manner in which Backbone persists
// models to the server. You will be passed the type of request, and the
// model in question. By default, makes a RESTful Ajax request
// to the model's `url()`. Some possible customizations could be:
//
// * Use `setTimeout` to batch rapid-fire updates into a single request.
// * Send up the models as XML instead of JSON.
// * Persist models via WebSockets instead of Ajax.
//
// Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
// as `POST`, with a `_method` parameter containing the true HTTP method,
// as well as all requests with the body as `application/x-www-form-urlencoded`
// instead of `application/json` with the model in a param named `model`.
// Useful when interfacing with server-side languages like **PHP** that make
// it difficult to read the body of `PUT` requests.
Backbone.sync = function(method, model, options) {
var type = methodMap[method];
// Default options, unless specified.
_.defaults(options || (options = {}), {
emulateHTTP: Backbone.emulateHTTP,
emulateJSON: Backbone.emulateJSON
});
// Default JSON-request options.
var params = {
type: type,
dataType: "json"
};
// For older servers, emulate HTTP by mimicking the HTTP method with `_method`
// And an `X-HTTP-Method-Override` header.
if (options.url || (params.url = _.result(model, "url") || urlError()), null == options.data && model && ("create" === method || "update" === method || "patch" === method) && (params.contentType = "application/json", params.data = JSON.stringify(options.attrs || model.toJSON(options))), options.emulateJSON && (params.contentType = "application/x-www-form-urlencoded", params.data = params.data ? {
model: params.data
} : {}), options.emulateHTTP && ("PUT" === type || "DELETE" === type || "PATCH" === type)) {
params.type = "POST", options.emulateJSON && (params.data._method = type);
var beforeSend = options.beforeSend;
options.beforeSend = function(xhr) {
if (xhr.setRequestHeader("X-HTTP-Method-Override", type), beforeSend) return beforeSend.apply(this, arguments);
};
}
"GET" === params.type || options.emulateJSON || (params.processData = !1), "PATCH" === params.type && noXhrPatch && (params.xhr = function() {
return new ActiveXObject("Microsoft.XMLHTTP");
});
// Make the request, allowing the user to override any Ajax options.
var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
return model.trigger("request", model, xhr, options), xhr;
};
var noXhrPatch = "undefined" != typeof window && !!window.ActiveXObject && !(window.XMLHttpRequest && new XMLHttpRequest().dispatchEvent), methodMap = {
create: "POST",
update: "PUT",
patch: "PATCH",
delete: "DELETE",
read: "GET"
};
// Set the default implementation of `Backbone.ajax` to proxy through to `$`.
// Override this if you'd like to use a different library.
Backbone.ajax = function() {
return Backbone.$.ajax.apply(Backbone.$, arguments);
};
// Backbone.Router
// ---------------
// Routers map faux-URLs to actions, and fire events when routes are
// matched. Creating a new one sets its `routes` hash, if not set statically.
var Router = Backbone.Router = function(options) {
options || (options = {}), options.routes && (this.routes = options.routes), this._bindRoutes(), this.initialize.apply(this, arguments);
}, optionalParam = /\((.*?)\)/g, namedParam = /(\(\?)?:\w+/g, splatParam = /\*\w+/g, escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
// Set up all inheritable **Backbone.Router** properties and methods.
_.extend(Router.prototype, Events, {
// Initialize is an empty function by default. Override it with your own
// initialization logic.
initialize: function() {},
// Manually bind a single named route to a callback. For example:
//
// this.route('search/:query/p:num', 'search', function(query, num) {
// ...
// });
//
route: function(route, name, callback) {
_.isRegExp(route) || (route = this._routeToRegExp(route)), _.isFunction(name) && (callback = name, name = ""), callback || (callback = this[name]);
var router = this;
return Backbone.history.route(route, function(fragment) {
var args = router._extractParameters(route, fragment);
callback && callback.apply(router, args), router.trigger.apply(router, [
"route:" + name
].concat(args)), router.trigger("route", name, args), Backbone.history.trigger("route", router, name, args);
}), this;
},
// Simple proxy to `Backbone.history` to save a fragment into the history.
navigate: function(fragment, options) {
return Backbone.history.navigate(fragment, options), this;
},
// Bind all defined routes to `Backbone.history`. We have to reverse the
// order of the routes here to support behavior where the most general
// routes can be defined at the bottom of the route map.
_bindRoutes: function() {
if (this.routes) {
this.routes = _.result(this, "routes");
for(var route, routes = _.keys(this.routes); null != (route = routes.pop());)this.route(route, this.routes[route]);
}
},
// Convert a route string into a regular expression, suitable for matching
// against the current location hash.
_routeToRegExp: function(route) {
return RegExp("^" + (route = route.replace(escapeRegExp, "\\$&").replace(optionalParam, "(?:$1)?").replace(namedParam, function(match, optional) {
return optional ? match : "([^/]+)";
}).replace(splatParam, "(.*?)")) + "$");
},
// Given a route, and a URL fragment that it matches, return the array of
// extracted decoded parameters. Empty or unmatched parameters will be
// treated as `null` to normalize cross-browser behavior.
_extractParameters: function(route, fragment) {
var params = route.exec(fragment).slice(1);
return _.map(params, function(param) {
return param ? decodeURIComponent(param) : null;
});
}
});
// Backbone.History
// ----------------
// Handles cross-browser history management, based on either
// [pushState](http://diveintohtml5.info/history.html) and real URLs, or
// [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
// and URL fragments. If the browser supports neither (old IE, natch),
// falls back to polling.
var History = Backbone.History = function() {
this.handlers = [], _.bindAll(this, "checkUrl"), "undefined" != typeof window && (this.location = window.location, this.history = window.history);
}, routeStripper = /^[#\/]|\s+$/g, rootStripper = /^\/+|\/+$/g, isExplorer = /msie [\w.]+/, trailingSlash = /\/$/, pathStripper = /[?#].*$/;
// Has the history handling already been started?
History.started = !1, // Set up all inheritable **Backbone.History** properties and methods.
_.extend(History.prototype, Events, {
// The default interval to poll for hash changes, if necessary, is
// twenty times a second.
interval: 50,
// Gets the true hash value. Cannot use location.hash directly due to bug
// in Firefox where location.hash will always be decoded.
getHash: function(window1) {
var match = (window1 || this).location.href.match(/#(.*)$/);
return match ? match[1] : "";
},
// Get the cross-browser normalized URL fragment, either from the URL,
// the hash, or the override.
getFragment: function(fragment, forcePushState) {
if (null == fragment) {
if (this._hasPushState || !this._wantsHashChange || forcePushState) {
fragment = this.location.pathname;
var root = this.root.replace(trailingSlash, "");
fragment.indexOf(root) || (fragment = fragment.slice(root.length));
} else fragment = this.getHash();
}
return fragment.replace(routeStripper, "");
},
// Start the hash change handling, returning `true` if the current URL matches
// an existing route, and `false` otherwise.
start: function(options) {
if (History.started) throw Error("Backbone.history has already been started");
History.started = !0, // Figure out the initial configuration. Do we need an iframe?
// Is pushState desired ... is it available?
this.options = _.extend({
root: "/"
}, this.options, options), this.root = this.options.root, this._wantsHashChange = !1 !== this.options.hashChange, this._wantsPushState = !!this.options.pushState, this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);
var fragment = this.getFragment(), docMode = document.documentMode, oldIE = isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7);
// Normalize root to always include a leading and trailing slash.
this.root = ("/" + this.root + "/").replace(rootStripper, "/"), oldIE && this._wantsHashChange && (this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo("body")[0].contentWindow, this.navigate(fragment)), this._hasPushState ? Backbone.$(window).on("popstate", this.checkUrl) : this._wantsHashChange && "onhashchange" in window && !oldIE ? Backbone.$(window).on("hashchange", this.checkUrl) : this._wantsHashChange && (this._checkUrlInterval = setInterval(this.checkUrl, this.interval)), // Determine if we need to change the base url, for a pushState link
// opened by a non-pushState browser.
this.fragment = fragment;
var loc = this.location, atRoot = loc.pathname.replace(/[^\/]$/, "$&/") === this.root;
// Transition from hashChange to pushState or vice versa if both are
// requested.
if (this._wantsHashChange && this._wantsPushState) {
// If we've started off with a route from a `pushState`-enabled
// browser, but we're currently in a browser that doesn't support it...
if (!this._hasPushState && !atRoot) // Return immediately as browser will do redirect to new url
return this.fragment = this.getFragment(null, !0), this.location.replace(this.root + this.location.search + "#" + this.fragment), !0;
this._hasPushState && atRoot && loc.hash && (this.fragment = this.getHash().replace(routeStripper, ""), this.history.replaceState({}, document.title, this.root + this.fragment + loc.search));
}
if (!this.options.silent) return this.loadUrl();
},
// Disable Backbone.history, perhaps temporarily. Not useful in a real app,
// but possibly useful for unit testing Routers.
stop: function() {
Backbone.$(window).off("popstate", this.checkUrl).off("hashchange", this.checkUrl), clearInterval(this._checkUrlInterval), History.started = !1;
},
// Add a route to be tested when the fragment changes. Routes added later
// may override previous routes.
route: function(route, callback) {
this.handlers.unshift({
route: route,
callback: callback
});
},
// Checks the current URL to see if it has changed, and if it has,
// calls `loadUrl`, normalizing across the hidden iframe.
checkUrl: function(e) {
var current = this.getFragment();
if (current === this.fragment && this.iframe && (current = this.getFragment(this.getHash(this.iframe))), current === this.fragment) return !1;
this.iframe && this.navigate(current), this.loadUrl();
},
// Attempt to load the current URL fragment. If a route succeeds with a
// match, returns `true`. If no defined routes matches the fragment,
// returns `false`.
loadUrl: function(fragment) {
return fragment = this.fragment = this.getFragment(fragment), _.any(this.handlers, function(handler) {
if (handler.route.test(fragment)) return handler.callback(fragment), !0;
});
},
// Save a fragment into the hash history, or replace the URL state if the
// 'replace' option is passed. You are responsible for properly URL-encoding
// the fragment in advance.
//
// The options object can contain `trigger: true` if you wish to have the
// route callback be fired (not usually desirable), or `replace: true`, if
// you wish to modify the current URL without adding an entry to the history.
navigate: function(fragment, options) {
if (!History.started) return !1;
options && !0 !== options || (options = {
trigger: !!options
});
var url = this.root + (fragment = this.getFragment(fragment || ""));
if (// Strip the fragment of the query and hash for matching.
fragment = fragment.replace(pathStripper, ""), this.fragment !== fragment) {
// If pushState is available, we use it to set the fragment as a real URL.
if (this.fragment = fragment, "" === fragment && "/" !== url && (url = url.slice(0, -1)), this._hasPushState) this.history[options.replace ? "replaceState" : "pushState"]({}, document.title, url);
else {
if (!this._wantsHashChange) return this.location.assign(url);
this._updateHash(this.location, fragment, options.replace), this.iframe && fragment !== this.getFragment(this.getHash(this.iframe)) && (options.replace || this.iframe.document.open().close(), this._updateHash(this.iframe.location, fragment, options.replace));
}
if (options.trigger) return this.loadUrl(fragment);
}
},
// Update the hash location, either replacing the current entry, or adding
// a new one to the browser history.
_updateHash: function(location, fragment, replace) {
if (replace) {
var href = location.href.replace(/(javascript:|#).*$/, "");
location.replace(href + "#" + fragment);
} else // Some browsers require that `hash` contains a leading #.
location.hash = "#" + fragment;
}
}), // Create the default Backbone.history.
Backbone.history = new History(), // Set up inheritance for the model, collection, router, view and history.
Model.extend = Collection.extend = Router.extend = View.extend = History.extend = function(protoProps, staticProps) {
var child, parent = this;
child = protoProps && _.has(protoProps, "constructor") ? protoProps.constructor : function() {
return parent.apply(this, arguments);
}, // Add static properties to the constructor function, if supplied.
_.extend(child, parent, staticProps);
// Set the prototype chain to inherit from `parent`, without calling
// `parent`'s constructor function.
var Surrogate = function() {
this.constructor = child;
};
return Surrogate.prototype = parent.prototype, child.prototype = new Surrogate(), protoProps && _.extend(child.prototype, protoProps), // Set a convenience property in case the parent's prototype is needed
// later.
child.__super__ = parent.prototype, child;
};
// Throw an error when a URL is needed, and none is supplied.
var urlError = function() {
throw Error('A "url" property or function must be specified');
}, wrapError = function(model, options) {
var error = options.error;
options.error = function(resp) {
error && error(model, resp, options), model.trigger("error", model, resp, options);
};
};
}).call(this);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/jquery-1.9.1.js | JavaScript | !/*!
* jQuery JavaScript Library v1.9.1
* http://jquery.com/
*
* Includes Sizzle.js
* http://sizzlejs.com/
*
* Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2013-2-4
*/ function(window1, undefined) {
// Can't do this because several apps including ASP.NET trace
// the stack via arguments.caller.callee and Firefox dies if
// you try to trace through "use strict" call chains. (#13335)
// Support: Firefox 18+
//"use strict";
var readyList, // A central reference to the root jQuery(document)
rootjQuery, // Support: IE<9
// For `typeof node.method` instead of `node.method !== undefined`
core_strundefined = "undefined", // Use the correct document accordingly with window argument (sandbox)
document = window1.document, location = window1.location, // Map over jQuery in case of overwrite
_jQuery = window1.jQuery, // Map over the $ in case of overwrite
_$ = window1.$, // [[Class]] -> type pairs
class2type = {}, // List of deleted data cache ids, so we can reuse them
core_deletedIds = [], core_version = "1.9.1", // Save a reference to some core methods
core_concat = core_deletedIds.concat, core_push = core_deletedIds.push, core_slice = core_deletedIds.slice, core_indexOf = core_deletedIds.indexOf, core_toString = class2type.toString, core_hasOwn = class2type.hasOwnProperty, core_trim = core_version.trim, // Define a local copy of jQuery
jQuery = function(selector, context) {
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init(selector, context, rootjQuery);
}, // Used for matching numbers
core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source, // Used for splitting on whitespace
core_rnotwhite = /\S+/g, // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, // A simple way to check for HTML strings
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
// Strict HTML recognition (#11290: must start with <)
rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/, // Match a standalone tag
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, // JSON RegExp
rvalidchars = /^[\],:{}\s]*$/, rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g, // Matches dashed string for camelizing
rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, // Used by jQuery.camelCase as callback to replace()
fcamelCase = function(all, letter) {
return letter.toUpperCase();
}, // The ready event handler
completed = function(event) {
// readyState === "complete" is good enough for us to call the dom ready in oldIE
(document.addEventListener || "load" === event.type || "complete" === document.readyState) && (detach(), jQuery.ready());
}, // Clean-up method for dom ready events
detach = function() {
document.addEventListener ? (document.removeEventListener("DOMContentLoaded", completed, !1), window1.removeEventListener("load", completed, !1)) : (document.detachEvent("onreadystatechange", completed), window1.detachEvent("onload", completed));
};
function isArraylike(obj) {
var length = obj.length, type = jQuery.type(obj);
return !jQuery.isWindow(obj) && (1 === obj.nodeType && !!length || "array" === type || "function" !== type && (0 === length || "number" == typeof length && length > 0 && length - 1 in obj));
}
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
jquery: core_version,
constructor: jQuery,
init: function(selector, context, rootjQuery) {
var match, elem;
// HANDLE: $(""), $(null), $(undefined), $(false)
if (!selector) return this;
// Handle HTML strings
if ("string" == typeof selector) {
// Match html or make sure no context is specified for #id
if ((// Assume that strings that start and end with <> are HTML and skip the regex check
match = "<" === selector.charAt(0) && ">" === selector.charAt(selector.length - 1) && selector.length >= 3 ? [
null,
selector,
null
] : rquickExpr.exec(selector)) && (match[1] || !context)) {
// HANDLE: $(html) -> $(array)
if (match[1]) {
// HANDLE: $(html, props)
if (context = context instanceof jQuery ? context[0] : context, // scripts is true for back-compat
jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, !0)), rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) for(match in context)// Properties of context are called as methods if possible
jQuery.isFunction(this[match]) ? this[match](context[match]) : this.attr(match, context[match]);
return this;
// HANDLE: $(#id)
}
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if ((elem = document.getElementById(match[2])) && elem.parentNode) {
// Handle the case where IE and Opera return items
// by name instead of ID
if (elem.id !== match[2]) return rootjQuery.find(selector);
// Otherwise, we inject the element directly into the jQuery object
this.length = 1, this[0] = elem;
}
return this.context = document, this.selector = selector, this;
// HANDLE: $(expr, $(...))
}
return !context || context.jquery ? (context || rootjQuery).find(selector) : this.constructor(context).find(selector);
// HANDLE: $(DOMElement)
}
return selector.nodeType ? (this.context = this[0] = selector, this.length = 1, this) : jQuery.isFunction(selector) ? rootjQuery.ready(selector) : (selector.selector !== undefined && (this.selector = selector.selector, this.context = selector.context), jQuery.makeArray(selector, this));
},
// Start with an empty selector
selector: "",
// The default length of a jQuery object is 0
length: 0,
// The number of elements contained in the matched element set
size: function() {
return this.length;
},
toArray: function() {
return core_slice.call(this);
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function(num) {
return null == num ? this.toArray() : num < 0 ? this[this.length + num] : this[num];
},
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function(elems) {
// Build a new jQuery matched element set
var ret = jQuery.merge(this.constructor(), elems);
// Return the newly-formed element set
return(// Add the old object onto the stack (as a reference)
ret.prevObject = this, ret.context = this.context, ret);
},
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function(callback, args) {
return jQuery.each(this, callback, args);
},
ready: function(fn) {
return(// Add the callback
jQuery.ready.promise().done(fn), this);
},
slice: function() {
return this.pushStack(core_slice.apply(this, arguments));
},
first: function() {
return this.eq(0);
},
last: function() {
return this.eq(-1);
},
eq: function(i) {
var len = this.length, j = +i + (i < 0 ? len : 0);
return this.pushStack(j >= 0 && j < len ? [
this[j]
] : []);
},
map: function(callback) {
return this.pushStack(jQuery.map(this, function(elem, i) {
return callback.call(elem, i, elem);
}));
},
end: function() {
return this.prevObject || this.constructor(null);
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: core_push,
sort: [].sort,
splice: [].splice
}, // Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn, jQuery.extend = jQuery.fn.extend = function() {
var src, copyIsArray, copy, name1, options, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = !1;
for("boolean" == typeof target && (deep = target, target = arguments[1] || {}, // skip the boolean and the target
i = 2), "object" == typeof target || jQuery.isFunction(target) || (target = {}), length === i && (target = this, --i); i < length; i++)// Only deal with non-null/undefined values
if (null != (options = arguments[i])) // Extend the base object
for(name1 in options)// Prevent never-ending loop
src = target[name1], target !== (copy = options[name1]) && (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy))) ? (copyIsArray ? (copyIsArray = !1, clone = src && jQuery.isArray(src) ? src : []) : clone = src && jQuery.isPlainObject(src) ? src : {}, // Never move original objects, clone them
target[name1] = jQuery.extend(deep, clone, copy)) : undefined !== copy && (target[name1] = copy));
// Return the modified object
return target;
}, jQuery.extend({
noConflict: function(deep) {
return window1.$ === jQuery && (window1.$ = _$), deep && window1.jQuery === jQuery && (window1.jQuery = _jQuery), jQuery;
},
// Is the DOM ready to be used? Set to true once it occurs.
isReady: !1,
// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,
// Hold (or release) the ready event
holdReady: function(hold) {
hold ? jQuery.readyWait++ : jQuery.ready(!0);
},
// Handle when the DOM is ready
ready: function(wait) {
// Abort if there are pending holds or we're already ready
if (!(!0 === wait ? --jQuery.readyWait : jQuery.isReady)) {
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
if (!document.body) return setTimeout(jQuery.ready);
// If a normal DOM Ready event fired, decrement, and wait if need be
// Remember that the DOM is ready
jQuery.isReady = !0, !(!0 !== wait && --jQuery.readyWait > 0) && (// If there are functions bound, to execute
readyList.resolveWith(document, [
jQuery
]), jQuery.fn.trigger && jQuery(document).trigger("ready").off("ready"));
}
},
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function(obj) {
return "function" === jQuery.type(obj);
},
isArray: Array.isArray || function(obj) {
return "array" === jQuery.type(obj);
},
isWindow: function(obj) {
return null != obj && obj == obj.window;
},
isNumeric: function(obj) {
return !isNaN(parseFloat(obj)) && isFinite(obj);
},
type: function(obj) {
return null == obj ? String(obj) : "object" == typeof obj || "function" == typeof obj ? class2type[core_toString.call(obj)] || "object" : typeof obj;
},
isPlainObject: function(obj) {
var key;
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if (!obj || "object" !== jQuery.type(obj) || obj.nodeType || jQuery.isWindow(obj)) return !1;
try {
// Not own constructor property must be Object
if (obj.constructor && !core_hasOwn.call(obj, "constructor") && !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) return !1;
} catch (e) {
// IE8,9 Will throw exceptions on certain host objects #9897
return !1;
}
for(key in obj);
return undefined === key || core_hasOwn.call(obj, key);
},
isEmptyObject: function(obj) {
var name1;
for(name1 in obj)return !1;
return !0;
},
error: function(msg) {
throw Error(msg);
},
// data: string of html
// context (optional): If specified, the fragment will be created in this context, defaults to document
// keepScripts (optional): If true, will include scripts passed in the html string
parseHTML: function(data, context, keepScripts) {
if (!data || "string" != typeof data) return null;
"boolean" == typeof context && (keepScripts = context, context = !1), context = context || document;
var parsed = rsingleTag.exec(data), scripts = !keepScripts && [];
return(// Single tag
parsed ? [
context.createElement(parsed[1])
] : (parsed = jQuery.buildFragment([
data
], context, scripts), scripts && jQuery(scripts).remove(), jQuery.merge([], parsed.childNodes)));
},
parseJSON: function(data) {
return(// Attempt to parse using the native JSON parser first
window1.JSON && window1.JSON.parse ? window1.JSON.parse(data) : null === data ? data : "string" == typeof data && // Make sure leading/trailing whitespace is removed (IE can't handle it)
(data = jQuery.trim(data)) && rvalidchars.test(data.replace(rvalidescape, "@").replace(rvalidtokens, "]").replace(rvalidbraces, "")) ? Function("return " + data)() : void jQuery.error("Invalid JSON: " + data));
},
// Cross-browser xml parsing
parseXML: function(data) {
var xml;
if (!data || "string" != typeof data) return null;
try {
window1.DOMParser ? xml = new DOMParser().parseFromString(data, "text/xml") : (// IE
(xml = new ActiveXObject("Microsoft.XMLDOM")).async = "false", xml.loadXML(data));
} catch (e) {
xml = undefined;
}
return xml && xml.documentElement && !xml.getElementsByTagName("parsererror").length || jQuery.error("Invalid XML: " + data), xml;
},
noop: function() {},
// Evaluates a script in a global context
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
globalEval: function(data) {
data && jQuery.trim(data) && // We use execScript on Internet Explorer
// We use an anonymous function so that context is window
// rather than jQuery in Firefox
(window1.execScript || function(data) {
window1.eval.call(window1, data);
})(data);
},
// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function(string) {
return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
},
nodeName: function(elem, name1) {
return elem.nodeName && elem.nodeName.toLowerCase() === name1.toLowerCase();
},
// args is for internal usage only
each: function(obj, callback, args) {
var value, i = 0, length = obj.length, isArray = isArraylike(obj);
if (args) {
if (isArray) for(; i < length && !1 !== callback.apply(obj[i], args); i++);
else for(i in obj)if (!1 === callback.apply(obj[i], args)) break;
} else if (isArray) for(; i < length && !1 !== callback.call(obj[i], i, obj[i]); i++);
else for(i in obj)if (!1 === callback.call(obj[i], i, obj[i])) break;
return obj;
},
// Use native String.trim function wherever possible
trim: core_trim && !core_trim.call("\uFEFF\xA0") ? function(text) {
return null == text ? "" : core_trim.call(text);
} : function(text) {
return null == text ? "" : (text + "").replace(rtrim, "");
},
// results is for internal usage only
makeArray: function(arr, results) {
var ret = results || [];
return null != arr && (isArraylike(Object(arr)) ? jQuery.merge(ret, "string" == typeof arr ? [
arr
] : arr) : core_push.call(ret, arr)), ret;
},
inArray: function(elem, arr, i) {
var len;
if (arr) {
if (core_indexOf) return core_indexOf.call(arr, elem, i);
for(len = arr.length, i = i ? i < 0 ? Math.max(0, len + i) : i : 0; i < len; i++)// Skip accessing in sparse arrays
if (i in arr && arr[i] === elem) return i;
}
return -1;
},
merge: function(first, second) {
var l = second.length, i = first.length, j = 0;
if ("number" == typeof l) for(; j < l; j++)first[i++] = second[j];
else for(; second[j] !== undefined;)first[i++] = second[j++];
return first.length = i, first;
},
grep: function(elems, callback, inv) {
var ret = [], i = 0, length = elems.length;
// Go through the array, only saving the items
// that pass the validator function
for(inv = !!inv; i < length; i++)!!callback(elems[i], i) !== inv && ret.push(elems[i]);
return ret;
},
// arg is for internal usage only
map: function(elems, callback, arg) {
var value, i = 0, length = elems.length, isArray = isArraylike(elems), ret = [];
// Go through the array, translating each of the items to their
if (isArray) for(; i < length; i++)null != (value = callback(elems[i], i, arg)) && (ret[ret.length] = value);
else for(i in elems)null != (value = callback(elems[i], i, arg)) && (ret[ret.length] = value);
// Flatten any nested arrays
return core_concat.apply([], ret);
},
// A global GUID counter for objects
guid: 1,
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function(fn, context) {
var args, proxy, tmp;
return(// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
("string" == typeof context && (tmp = fn[context], context = fn, fn = tmp), jQuery.isFunction(fn)) ? (// Simulated bind
args = core_slice.call(arguments, 2), // Set the guid of unique handler to the same of original handler, so it can be removed
(proxy = function() {
return fn.apply(context || this, args.concat(core_slice.call(arguments)));
}).guid = fn.guid = fn.guid || jQuery.guid++, proxy) : undefined);
},
// Multifunctional method to get and set values of a collection
// The value/s can optionally be executed if it's a function
access: function(elems, fn, key, value, chainable, emptyGet, raw) {
var i = 0, length = elems.length, bulk = null == key;
// Sets many values
if ("object" === jQuery.type(key)) for(i in chainable = !0, key)jQuery.access(elems, fn, i, key[i], !0, emptyGet, raw);
else if (undefined !== value && (chainable = !0, jQuery.isFunction(value) || (raw = !0), bulk && (raw ? (fn.call(elems, value), fn = null) : (bulk = fn, fn = function(elem, key, value) {
return bulk.call(jQuery(elem), value);
})), fn)) for(; i < length; i++)fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
return chainable ? elems : bulk ? fn.call(elems) : length ? fn(elems[0], key) : emptyGet;
},
now: function() {
return new Date().getTime();
}
}), jQuery.ready.promise = function(obj) {
if (!readyList) {
// Catch cases where $(document).ready() is called after the browser event has already occurred.
// we once tried to use readyState "interactive" here, but it caused issues like the one
// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
if (readyList = jQuery.Deferred(), "complete" === document.readyState) // Handle it asynchronously to allow scripts the opportunity to delay ready
setTimeout(jQuery.ready);
else if (document.addEventListener) // Use the handy event callback
document.addEventListener("DOMContentLoaded", completed, !1), // A fallback to window.onload, that will always work
window1.addEventListener("load", completed, !1);
else {
// Ensure firing before onload, maybe late but safe also for iframes
document.attachEvent("onreadystatechange", completed), // A fallback to window.onload, that will always work
window1.attachEvent("onload", completed);
// If IE and not a frame
// continually check to see if the document is ready
var top = !1;
try {
top = null == window1.frameElement && document.documentElement;
} catch (e) {}
top && top.doScroll && function doScrollCheck() {
if (!jQuery.isReady) {
try {
// Use the trick by Diego Perini
// http://javascript.nwbox.com/IEContentLoaded/
top.doScroll("left");
} catch (e) {
return setTimeout(doScrollCheck, 50);
}
// detach all dom ready events
detach(), // and execute any waiting functions
jQuery.ready();
}
}();
}
}
return readyList.promise(obj);
}, // Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name1) {
class2type["[object " + name1 + "]"] = name1.toLowerCase();
}), // All jQuery objects should point back to these
rootjQuery = jQuery(document);
// String to Object options format cache
var optionsCache = {};
/*
* Create a callback list using the following parameters:
*
* options: an optional list of space-separated options that will change how
* the callback list behaves or a more traditional option object
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible options:
*
* once: will ensure the callback list can only be fired once (like a Deferred)
*
* memory: will keep track of previous values and will call any callback added
* after the list has been fired right away with the latest "memorized"
* values (like a Deferred)
*
* unique: will ensure a callback can only be added once (no duplicate in the list)
*
* stopOnFalse: interrupt callings when a callback returns false
*
*/ jQuery.Callbacks = function(options) {
// Convert options from String-formatted to Object-formatted if needed
// (we check in cache first)
options = "string" == typeof options ? optionsCache[options] || (object = optionsCache[options1 = options] = {}, jQuery.each(options1.match(core_rnotwhite) || [], function(_, flag) {
object[flag] = !0;
}), object) : jQuery.extend({}, options);
var options1, object, firing, // Last fire value (for non-forgettable lists)
memory, // Flag to know if list was already fired
fired, // End of the loop when firing
firingLength, // Index of currently firing callback (modified by remove if needed)
firingIndex, // First callback to fire (used internally by add and fireWith)
firingStart, // Actual callback list
list = [], // Stack of fire calls for repeatable lists
stack = !options.once && [], // Fire callbacks
fire = function(data) {
for(memory = options.memory && data, fired = !0, firingIndex = firingStart || 0, firingStart = 0, firingLength = list.length, firing = !0; list && firingIndex < firingLength; firingIndex++)if (!1 === list[firingIndex].apply(data[0], data[1]) && options.stopOnFalse) {
memory = !1; // To prevent further calls using add
break;
}
firing = !1, list && (stack ? stack.length && fire(stack.shift()) : memory ? list = [] : self.disable());
}, // Actual Callbacks object
self = {
// Add a callback or a collection of callbacks to the list
add: function() {
if (list) {
// First, we save the current length
var start = list.length;
(function add(args) {
jQuery.each(args, function(_, arg) {
var type = jQuery.type(arg);
"function" === type ? options.unique && self.has(arg) || list.push(arg) : arg && arg.length && "string" !== type && // Inspect recursively
add(arg);
});
})(arguments), firing ? firingLength = list.length : memory && (firingStart = start, fire(memory));
}
return this;
},
// Remove a callback from the list
remove: function() {
return list && jQuery.each(arguments, function(_, arg) {
for(var index; (index = jQuery.inArray(arg, list, index)) > -1;)list.splice(index, 1), firing && (index <= firingLength && firingLength--, index <= firingIndex && firingIndex--);
}), this;
},
// Check if a given callback is in the list.
// If no argument is given, return whether or not list has callbacks attached.
has: function(fn) {
return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);
},
// Remove all callbacks from the list
empty: function() {
return list = [], this;
},
// Have the list do nothing anymore
disable: function() {
return list = stack = memory = undefined, this;
},
// Is it disabled?
disabled: function() {
return !list;
},
// Lock the list in its current state
lock: function() {
return stack = undefined, memory || self.disable(), this;
},
// Is it locked?
locked: function() {
return !stack;
},
// Call all callbacks with the given context and arguments
fireWith: function(context, args) {
return args = [
context,
(args = args || []).slice ? args.slice() : args
], list && (!fired || stack) && (firing ? stack.push(args) : fire(args)), this;
},
// Call all the callbacks with the given arguments
fire: function() {
return self.fireWith(this, arguments), this;
},
// To know if the callbacks have already been called at least once
fired: function() {
return !!fired;
}
};
return self;
}, jQuery.extend({
Deferred: function(func) {
var tuples = [
// action, add listener, listener list, final state
[
"resolve",
"done",
jQuery.Callbacks("once memory"),
"resolved"
],
[
"reject",
"fail",
jQuery.Callbacks("once memory"),
"rejected"
],
[
"notify",
"progress",
jQuery.Callbacks("memory")
]
], state = "pending", promise = {
state: function() {
return state;
},
always: function() {
return deferred.done(arguments).fail(arguments), this;
},
then: function() {
var fns = arguments;
return jQuery.Deferred(function(newDefer) {
jQuery.each(tuples, function(i, tuple) {
var action = tuple[0], fn = jQuery.isFunction(fns[i]) && fns[i];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
deferred[tuple[1]](function() {
var returned = fn && fn.apply(this, arguments);
returned && jQuery.isFunction(returned.promise) ? returned.promise().done(newDefer.resolve).fail(newDefer.reject).progress(newDefer.notify) : newDefer[action + "With"](this === promise ? newDefer.promise() : this, fn ? [
returned
] : arguments);
});
}), fns = null;
}).promise();
},
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
promise: function(obj) {
return null != obj ? jQuery.extend(obj, promise) : promise;
}
}, deferred = {};
// All done!
return(// Keep pipe for back-compat
promise.pipe = promise.then, // Add list-specific methods
jQuery.each(tuples, function(i, tuple) {
var list = tuple[2], stateString = tuple[3];
// promise[ done | fail | progress ] = list.add
promise[tuple[1]] = list.add, stateString && list.add(function() {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
}, tuples[1 ^ i][2].disable, tuples[2][2].lock), // deferred[ resolve | reject | notify ]
deferred[tuple[0]] = function() {
return deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments), this;
}, deferred[tuple[0] + "With"] = list.fireWith;
}), // Make the deferred a promise
promise.promise(deferred), func && func.call(deferred, deferred), deferred);
},
// Deferred helper
when: function(subordinate /* , ..., subordinateN */ ) {
var progressValues, progressContexts, resolveContexts, i = 0, resolveValues = core_slice.call(arguments), length = resolveValues.length, // the count of uncompleted subordinates
remaining = 1 !== length || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0, // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
deferred = 1 === remaining ? subordinate : jQuery.Deferred(), // Update function for both resolve and progress values
updateFunc = function(i, contexts, values) {
return function(value) {
contexts[i] = this, values[i] = arguments.length > 1 ? core_slice.call(arguments) : value, values === progressValues ? deferred.notifyWith(contexts, values) : --remaining || deferred.resolveWith(contexts, values);
};
};
// add listeners to Deferred subordinates; treat others as resolved
if (length > 1) for(progressValues = Array(length), progressContexts = Array(length), resolveContexts = Array(length); i < length; i++)resolveValues[i] && jQuery.isFunction(resolveValues[i].promise) ? resolveValues[i].promise().done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject).progress(updateFunc(i, progressContexts, progressValues)) : --remaining;
return remaining || deferred.resolveWith(resolveContexts, resolveValues), deferred.promise();
}
}), jQuery.support = function() {
var support, all, a, input, select, fragment, opt, eventName, isSupported, i, div = document.createElement("div");
if (// Setup
div.setAttribute("className", "t"), div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>", // Support tests won't run in some limited or non-browser environments
all = div.getElementsByTagName("*"), a = div.getElementsByTagName("a")[0], !all || !a || !all.length) return {};
opt = // First batch of tests
(select = document.createElement("select")).appendChild(document.createElement("option")), input = div.getElementsByTagName("input")[0], a.style.cssText = "top:1px;float:left;opacity:.5", support = {
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
getSetAttribute: "t" !== div.className,
// IE strips leading whitespace when .innerHTML is used
leadingWhitespace: 3 === div.firstChild.nodeType,
// Make sure that tbody elements aren't automatically inserted
// IE will insert them into empty tables
tbody: !div.getElementsByTagName("tbody").length,
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
htmlSerialize: !!div.getElementsByTagName("link").length,
// Get the style information from getAttribute
// (IE uses .cssText instead)
style: /top/.test(a.getAttribute("style")),
// Make sure that URLs aren't manipulated
// (IE normalizes it by default)
hrefNormalized: "/a" === a.getAttribute("href"),
// Make sure that element opacity exists
// (IE uses filter instead)
// Use a regex to work around a WebKit issue. See #5145
opacity: /^0.5/.test(a.style.opacity),
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
cssFloat: !!a.style.cssFloat,
// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
checkOn: !!input.value,
// Make sure that a selected-by-default option has a working selected property.
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
optSelected: opt.selected,
// Tests for enctype support on a form (#6743)
enctype: !!document.createElement("form").enctype,
// Makes sure cloning an html5 element does not cause problems
// Where outerHTML is undefined, this still works
html5Clone: "<:nav></:nav>" !== document.createElement("nav").cloneNode(!0).outerHTML,
// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
boxModel: "CSS1Compat" === document.compatMode,
// Will be defined later
deleteExpando: !0,
noCloneEvent: !0,
inlineBlockNeedsLayout: !1,
shrinkWrapBlocks: !1,
reliableMarginRight: !0,
boxSizingReliable: !0,
pixelPosition: !1
}, // Make sure checked status is properly cloned
input.checked = !0, support.noCloneChecked = input.cloneNode(!0).checked, // Make sure that the options inside disabled selects aren't marked as disabled
// (WebKit marks them as disabled)
select.disabled = !0, support.optDisabled = !opt.disabled;
// Support: IE<9
try {
delete div.test;
} catch (e) {
support.deleteExpando = !1;
}
// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
for(i in // Check if we can trust getAttribute("value")
(input = document.createElement("input")).setAttribute("value", ""), support.input = "" === input.getAttribute("value"), // Check if an input maintains its value after becoming a radio
input.value = "t", input.setAttribute("type", "radio"), support.radioValue = "t" === input.value, // #11217 - WebKit loses check when the name is after the checked attribute
input.setAttribute("checked", "t"), input.setAttribute("name", "t"), (fragment = document.createDocumentFragment()).appendChild(input), // Check if a disconnected checkbox will retain its checked
// value of true after appended to the DOM (IE6/7)
support.appendChecked = input.checked, // WebKit doesn't clone checked state correctly in fragments
support.checkClone = fragment.cloneNode(!0).cloneNode(!0).lastChild.checked, div.attachEvent && (div.attachEvent("onclick", function() {
support.noCloneEvent = !1;
}), div.cloneNode(!0).click()), {
submit: !0,
change: !0,
focusin: !0
})div.setAttribute(eventName = "on" + i, "t"), support[i + "Bubbles"] = eventName in window1 || !1 === div.attributes[eventName].expando;
return div.style.backgroundClip = "content-box", div.cloneNode(!0).style.backgroundClip = "", support.clearCloneStyle = "content-box" === div.style.backgroundClip, // Run tests that need a body at doc ready
jQuery(function() {
var container, marginDiv, tds, divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;", body = document.getElementsByTagName("body")[0];
body && ((container = document.createElement("div")).style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px", body.appendChild(container).appendChild(div), // Support: IE8
// Check if table cells still have offsetWidth/Height when they are set
// to display:none and there are still other visible table cells in a
// table row; if so, offsetWidth/Height are not reliable for use when
// determining if an element has been hidden directly using
// display:none (it is still safe to use offsets if a parent element is
// hidden; don safety goggles and see bug #4512 for more information).
div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>", (tds = div.getElementsByTagName("td"))[0].style.cssText = "padding:0;margin:0;border:0;display:none", isSupported = 0 === tds[0].offsetHeight, tds[0].style.display = "", tds[1].style.display = "none", // Support: IE8
// Check if empty table cells still have offsetWidth/Height
support.reliableHiddenOffsets = isSupported && 0 === tds[0].offsetHeight, // Check box-sizing and margin behavior
div.innerHTML = "", div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;", support.boxSizing = 4 === div.offsetWidth, support.doesNotIncludeMarginInBodyOffset = 1 !== body.offsetTop, window1.getComputedStyle && (support.pixelPosition = "1%" !== (window1.getComputedStyle(div, null) || {}).top, support.boxSizingReliable = "4px" === (window1.getComputedStyle(div, null) || {
width: "4px"
}).width, // Check if div with explicit width and no margin-right incorrectly
// gets computed margin-right based on width of container. (#3333)
// Fails in WebKit before Feb 2011 nightlies
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
(marginDiv = div.appendChild(document.createElement("div"))).style.cssText = div.style.cssText = divReset, marginDiv.style.marginRight = marginDiv.style.width = "0", div.style.width = "1px", support.reliableMarginRight = !parseFloat((window1.getComputedStyle(marginDiv, null) || {}).marginRight)), typeof div.style.zoom !== core_strundefined && (// Support: IE<8
// Check if natively block-level elements act like inline-block
// elements when setting their display to 'inline' and giving
// them layout
div.innerHTML = "", div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1", support.inlineBlockNeedsLayout = 3 === div.offsetWidth, // Support: IE6
// Check if elements with layout shrink-wrap their children
div.style.display = "block", div.innerHTML = "<div></div>", div.firstChild.style.width = "5px", support.shrinkWrapBlocks = 3 !== div.offsetWidth, support.inlineBlockNeedsLayout && // Prevent IE 6 from affecting layout for positioned elements #11048
// Prevent IE from shrinking the body in IE 7 mode #12869
// Support: IE<8
(body.style.zoom = 1)), body.removeChild(container), div = null);
}), // Null elements to avoid leaks in IE
all = select = fragment = opt = a = input = null, support;
}();
var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, rmultiDash = /([A-Z])/g;
function internalData(elem, name1, data, pvt /* Internal Use Only */ ) {
if (jQuery.acceptData(elem)) {
var thisCache, ret, internalKey = jQuery.expando, getByName = "string" == typeof name1, // We have to handle DOM nodes and JS objects differently because IE6-7
// can't GC object references properly across the DOM-JS boundary
isNode = elem.nodeType, // Only DOM nodes need the global jQuery cache; JS object data is
// attached directly to the object so GC can occur automatically
cache = isNode ? jQuery.cache : elem, // Only defining an ID for JS objects if its cache already exists allows
// the code to shortcut on the same path as a DOM node with no cache
id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;
// Avoid doing any more work than we need to when trying to get data on an
// object that has no data at all
if (id && cache[id] && (pvt || cache[id].data) || !getByName || undefined !== data) return id || (isNode ? elem[internalKey] = id = core_deletedIds.pop() || jQuery.guid++ : id = internalKey), cache[id] || (cache[id] = {}, isNode || (cache[id].toJSON = jQuery.noop)), ("object" == typeof name1 || "function" == typeof name1) && (pvt ? cache[id] = jQuery.extend(cache[id], name1) : cache[id].data = jQuery.extend(cache[id].data, name1)), thisCache = cache[id], pvt || (thisCache.data || (thisCache.data = {}), thisCache = thisCache.data), undefined !== data && (thisCache[jQuery.camelCase(name1)] = data), getByName ? null == // First Try to find as-is property data
(ret = thisCache[name1]) && // Try to find the camelCased property
(ret = thisCache[jQuery.camelCase(name1)]) : ret = thisCache, ret;
}
}
function internalRemoveData(elem, name1, pvt) {
if (!!jQuery.acceptData(elem)) {
var i, l, thisCache, isNode = elem.nodeType, // See jQuery.data for more information
cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando;
// If there is already no cache entry for this object, there is no
// purpose in continuing
if (cache[id]) {
if (name1 && (thisCache = pvt ? cache[id] : cache[id].data)) {
for(i = 0, l = (// If "name" is an array of keys...
// When data is initially created, via ("key", "val") signature,
// keys will be converted to camelCase.
// Since there is no way to tell _how_ a key was added, remove
// both plain key and camelCase key. #12786
// This will only penalize the array argument path.
name1 = jQuery.isArray(name1) ? name1.concat(jQuery.map(name1, jQuery.camelCase)) : (name1 in thisCache) ? [
name1
] : (// split the camel cased version by spaces unless a key with the spaces exists
(name1 = jQuery.camelCase(name1)) in thisCache) ? [
name1
] : name1.split(" ")).length; i < l; i++)delete thisCache[name1[i]];
// If there is no data left in the cache, we want to continue
// and let the cache object itself get destroyed
if (!(pvt ? isEmptyDataObject : jQuery.isEmptyObject)(thisCache)) return;
}
// See jQuery.data for more information
(pvt || (delete cache[id].data, isEmptyDataObject(cache[id]))) && (isNode ? jQuery.cleanData([
elem
], !0) : jQuery.support.deleteExpando || cache != cache.window ? delete cache[id] : cache[id] = null);
}
}
}
function dataAttr(elem, key, data) {
// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if (undefined === data && 1 === elem.nodeType) {
var name1 = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
if ("string" == typeof (data = elem.getAttribute(name1))) {
try {
data = "true" === data || "false" !== data && ("null" === data ? null : +data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data);
} catch (e) {}
// Make sure we set the data so it isn't changed later
jQuery.data(elem, key, data);
} else data = undefined;
}
return data;
}
// checks a cache object for emptiness
function isEmptyDataObject(obj) {
var name1;
for(name1 in obj)// if the public data object is empty, the private is still empty
if (!("data" === name1 && jQuery.isEmptyObject(obj[name1])) && "toJSON" !== name1) return !1;
return !0;
}
jQuery.extend({
cache: {},
// Unique for each copy of jQuery on the page
// Non-digits removed to match rinlinejQuery
expando: "jQuery" + (core_version + Math.random()).replace(/\D/g, ""),
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
noData: {
embed: !0,
// Ban all objects except for Flash (which handle expandos)
object: "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
applet: !0
},
hasData: function(elem) {
return !!(elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando]) && !isEmptyDataObject(elem);
},
data: function(elem, name1, data) {
return internalData(elem, name1, data);
},
removeData: function(elem, name1) {
return internalRemoveData(elem, name1);
},
// For internal use only.
_data: function(elem, name1, data) {
return internalData(elem, name1, data, !0);
},
_removeData: function(elem, name1) {
return internalRemoveData(elem, name1, !0);
},
// A method for determining if a DOM node can handle the data expando
acceptData: function(elem) {
// Do not set data on non-element because it will not be cleared (#8335).
if (elem.nodeType && 1 !== elem.nodeType && 9 !== elem.nodeType) return !1;
var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];
// nodes accept data unless otherwise specified; rejection can be conditional
return !noData || !0 !== noData && elem.getAttribute("classid") === noData;
}
}), jQuery.fn.extend({
data: function(key, value) {
var attrs, name1, elem = this[0], i = 0, data = null;
// Gets all values
if (undefined === key) {
if (this.length && (data = jQuery.data(elem), 1 === elem.nodeType && !jQuery._data(elem, "parsedAttrs"))) {
for(attrs = elem.attributes; i < attrs.length; i++)(name1 = attrs[i].name).indexOf("data-") || dataAttr(elem, name1 = jQuery.camelCase(name1.slice(5)), data[name1]);
jQuery._data(elem, "parsedAttrs", !0);
}
return data;
}
return(// Sets multiple values
"object" == typeof key ? this.each(function() {
jQuery.data(this, key);
}) : jQuery.access(this, function(value) {
if (undefined === value) // Try to fetch any internally stored data first
return elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;
this.each(function() {
jQuery.data(this, key, value);
});
}, null, value, arguments.length > 1, null, !0));
},
removeData: function(key) {
return this.each(function() {
jQuery.removeData(this, key);
});
}
}), jQuery.extend({
queue: function(elem, type, data) {
var queue;
if (elem) return type = (type || "fx") + "queue", queue = jQuery._data(elem, type), data && (!queue || jQuery.isArray(data) ? queue = jQuery._data(elem, type, jQuery.makeArray(data)) : queue.push(data)), queue || [];
},
dequeue: function(elem, type) {
type = type || "fx";
var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks(elem, type);
"inprogress" === fn && (fn = queue.shift(), startLength--), hooks.cur = fn, fn && ("fx" === type && queue.unshift("inprogress"), // clear up the last queue stop function
delete hooks.stop, fn.call(elem, function() {
jQuery.dequeue(elem, type);
}, hooks)), !startLength && hooks && hooks.empty.fire();
},
// not intended for public consumption - generates a queueHooks object, or returns the current one
_queueHooks: function(elem, type) {
var key = type + "queueHooks";
return jQuery._data(elem, key) || jQuery._data(elem, key, {
empty: jQuery.Callbacks("once memory").add(function() {
jQuery._removeData(elem, type + "queue"), jQuery._removeData(elem, key);
})
});
}
}), jQuery.fn.extend({
queue: function(type, data) {
var setter = 2;
return ("string" != typeof type && (data = type, type = "fx", setter--), arguments.length < setter) ? jQuery.queue(this[0], type) : undefined === data ? this : this.each(function() {
var queue = jQuery.queue(this, type, data);
// ensure a hooks for this queue
jQuery._queueHooks(this, type), "fx" === type && "inprogress" !== queue[0] && jQuery.dequeue(this, type);
});
},
dequeue: function(type) {
return this.each(function() {
jQuery.dequeue(this, type);
});
},
// Based off of the plugin by Clint Helfers, with permission.
// http://blindsignals.com/index.php/2009/07/jquery-delay/
delay: function(time, type) {
return time = jQuery.fx && jQuery.fx.speeds[time] || time, type = type || "fx", this.queue(type, function(next, hooks) {
var timeout = setTimeout(next, time);
hooks.stop = function() {
clearTimeout(timeout);
};
});
},
clearQueue: function(type) {
return this.queue(type || "fx", []);
},
// Get a promise resolved when queues of a certain type
// are emptied (fx is the type by default)
promise: function(type, obj) {
var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() {
--count || defer.resolveWith(elements, [
elements
]);
};
for("string" != typeof type && (obj = type, type = undefined), type = type || "fx"; i--;)(tmp = jQuery._data(elements[i], type + "queueHooks")) && tmp.empty && (count++, tmp.empty.add(resolve));
return resolve(), defer.promise(obj);
}
});
var nodeHook, boolHook, rclass = /[\t\r\n]/g, rreturn = /\r/g, rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i, rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = jQuery.support.getSetAttribute, getSetInput = jQuery.support.input;
jQuery.fn.extend({
attr: function(name1, value) {
return jQuery.access(this, jQuery.attr, name1, value, arguments.length > 1);
},
removeAttr: function(name1) {
return this.each(function() {
jQuery.removeAttr(this, name1);
});
},
prop: function(name1, value) {
return jQuery.access(this, jQuery.prop, name1, value, arguments.length > 1);
},
removeProp: function(name1) {
return name1 = jQuery.propFix[name1] || name1, this.each(function() {
// try/catch handles cases where IE balks (such as removing a property on window)
try {
this[name1] = undefined, delete this[name1];
} catch (e) {}
});
},
addClass: function(value) {
var classes, elem, cur, clazz, j, i = 0, len = this.length, proceed = "string" == typeof value && value;
if (jQuery.isFunction(value)) return this.each(function(j) {
jQuery(this).addClass(value.call(this, j, this.className));
});
if (proceed) {
for(// The disjunction here is for better compressibility (see removeClass)
classes = (value || "").match(core_rnotwhite) || []; i < len; i++)if (cur = 1 === (elem = this[i]).nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : " ")) {
for(j = 0; clazz = classes[j++];)0 > cur.indexOf(" " + clazz + " ") && (cur += clazz + " ");
elem.className = jQuery.trim(cur);
}
}
return this;
},
removeClass: function(value) {
var classes, elem, cur, clazz, j, i = 0, len = this.length, proceed = 0 == arguments.length || "string" == typeof value && value;
if (jQuery.isFunction(value)) return this.each(function(j) {
jQuery(this).removeClass(value.call(this, j, this.className));
});
if (proceed) {
for(classes = (value || "").match(core_rnotwhite) || []; i < len; i++)if (// This expression is here for better compressibility (see addClass)
cur = 1 === (elem = this[i]).nodeType && (elem.className ? (" " + elem.className + " ").replace(rclass, " ") : "")) {
for(j = 0; clazz = classes[j++];)// Remove *all* instances
for(; cur.indexOf(" " + clazz + " ") >= 0;)cur = cur.replace(" " + clazz + " ", " ");
elem.className = value ? jQuery.trim(cur) : "";
}
}
return this;
},
toggleClass: function(value, stateVal) {
var type = typeof value, isBool = "boolean" == typeof stateVal;
return jQuery.isFunction(value) ? this.each(function(i) {
jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
}) : this.each(function() {
if ("string" === type) for(// toggle individual class names
var className, i = 0, self = jQuery(this), state = stateVal, classNames = value.match(core_rnotwhite) || []; className = classNames[i++];)// check each className given, space separated list
state = isBool ? state : !self.hasClass(className), self[state ? "addClass" : "removeClass"](className);
else (type === core_strundefined || "boolean" === type) && (this.className && // store className if set
jQuery._data(this, "__className__", this.className), // If the element has a class name or if we're passed "false",
// then remove the whole classname (if there was one, the above saved it).
// Otherwise bring back whatever was previously saved (if anything),
// falling back to the empty string if nothing was stored.
this.className = this.className || !1 === value ? "" : jQuery._data(this, "__className__") || "");
});
},
hasClass: function(selector) {
for(var className = " " + selector + " ", i = 0, l = this.length; i < l; i++)if (1 === this[i].nodeType && (" " + this[i].className + " ").replace(rclass, " ").indexOf(className) >= 0) return !0;
return !1;
},
val: function(value) {
var ret, hooks, isFunction, elem = this[0];
if (!arguments.length) return elem ? (hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]) && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined ? ret : "string" == typeof (ret = elem.value) ? ret.replace(rreturn, "") : null == ret ? "" : ret : void 0;
return isFunction = jQuery.isFunction(value), this.each(function(i) {
var val, self = jQuery(this);
1 === this.nodeType && (null == (val = isFunction ? value.call(this, i, self.val()) : value) ? val = "" : "number" == typeof val ? val += "" : jQuery.isArray(val) && (val = jQuery.map(val, function(value) {
return null == value ? "" : value + "";
})), (hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]) && "set" in hooks && hooks.set(this, val, "value") !== undefined || (this.value = val));
});
}
}), jQuery.extend({
valHooks: {
option: {
get: function(elem) {
// attributes.value is undefined in Blackberry 4.7 but
// uses .value. See #6932
var val = elem.attributes.value;
return !val || val.specified ? elem.value : elem.text;
}
},
select: {
get: function(elem) {
// Loop through all the selected options
for(var value, option, options = elem.options, index = elem.selectedIndex, one = "select-one" === elem.type || index < 0, values = one ? null : [], max = one ? index + 1 : options.length, i = index < 0 ? max : one ? index : 0; i < max; i++)// oldIE doesn't update selected after form reset (#2551)
if (((option = options[i]).selected || i === index) && // Don't return options that are disabled or in a disabled optgroup
(jQuery.support.optDisabled ? !option.disabled : null === option.getAttribute("disabled")) && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
// We don't need an array for one selects
if (// Get the specific value for the option
value = jQuery(option).val(), one) return value;
// Multi-Selects return an array
values.push(value);
}
return values;
},
set: function(elem, value) {
var values = jQuery.makeArray(value);
return jQuery(elem).find("option").each(function() {
this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;
}), values.length || (elem.selectedIndex = -1), values;
}
}
},
attr: function(elem, name1, value) {
var hooks, notxml, ret, nType = elem.nodeType;
// don't get/set attributes on text, comment and attribute nodes
if (elem && 3 !== nType && 8 !== nType && 2 !== nType) {
// Fallback to prop when attributes are not supported
if (typeof elem.getAttribute === core_strundefined) return jQuery.prop(elem, name1, value);
if ((notxml = 1 !== nType || !jQuery.isXMLDoc(elem)) && (name1 = name1.toLowerCase(), hooks = jQuery.attrHooks[name1] || (rboolean.test(name1) ? boolHook : nodeHook)), undefined !== value) {
if (null === value) jQuery.removeAttr(elem, name1);
else if (hooks && notxml && "set" in hooks && (ret = hooks.set(elem, value, name1)) !== undefined) return ret;
else return elem.setAttribute(name1, value + ""), value;
} else if (hooks && notxml && "get" in hooks && null !== (ret = hooks.get(elem, name1))) return ret;
else // Non-existent attributes return null, we normalize to undefined
return typeof elem.getAttribute !== core_strundefined && (ret = elem.getAttribute(name1)), null == ret ? undefined : ret;
}
},
removeAttr: function(elem, value) {
var name1, propName, i = 0, attrNames = value && value.match(core_rnotwhite);
if (attrNames && 1 === elem.nodeType) for(; name1 = attrNames[i++];)propName = jQuery.propFix[name1] || name1, rboolean.test(name1) ? !getSetAttribute && ruseDefault.test(name1) ? elem[jQuery.camelCase("default-" + name1)] = elem[propName] = !1 : elem[propName] = !1 : jQuery.attr(elem, name1, ""), elem.removeAttribute(getSetAttribute ? name1 : propName);
},
attrHooks: {
type: {
set: function(elem, value) {
if (!jQuery.support.radioValue && "radio" === value && jQuery.nodeName(elem, "input")) {
// Setting the type on a radio button after the value resets the value in IE6-9
// Reset value to default in case type is set after value during creation
var val = elem.value;
return elem.setAttribute("type", value), val && (elem.value = val), value;
}
}
}
},
propFix: {
tabindex: "tabIndex",
readonly: "readOnly",
for: "htmlFor",
class: "className",
maxlength: "maxLength",
cellspacing: "cellSpacing",
cellpadding: "cellPadding",
rowspan: "rowSpan",
colspan: "colSpan",
usemap: "useMap",
frameborder: "frameBorder",
contenteditable: "contentEditable"
},
prop: function(elem, name1, value) {
var ret, hooks, nType = elem.nodeType;
// don't get/set properties on text, comment and attribute nodes
if (elem && 3 !== nType && 8 !== nType && 2 !== nType) return (1 === nType && jQuery.isXMLDoc(elem) || (// Fix name and attach hooks
name1 = jQuery.propFix[name1] || name1, hooks = jQuery.propHooks[name1]), undefined !== value) ? hooks && "set" in hooks && (ret = hooks.set(elem, value, name1)) !== undefined ? ret : elem[name1] = value : hooks && "get" in hooks && null !== (ret = hooks.get(elem, name1)) ? ret : elem[name1];
},
propHooks: {
tabIndex: {
get: function(elem) {
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
var attributeNode = elem.getAttributeNode("tabindex");
return attributeNode && attributeNode.specified ? parseInt(attributeNode.value, 10) : rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ? 0 : undefined;
}
}
}
}), // Hook for boolean attributes
boolHook = {
get: function(elem, name1) {
var prop = jQuery.prop(elem, name1), // Fetch it accordingly
attr = "boolean" == typeof prop && elem.getAttribute(name1), detail = "boolean" == typeof prop ? getSetInput && getSetAttribute ? null != attr : // and conflates checked/selected into attroperties
ruseDefault.test(name1) ? elem[jQuery.camelCase("default-" + name1)] : !!attr : elem.getAttributeNode(name1);
return detail && !1 !== detail.value ? name1.toLowerCase() : undefined;
},
set: function(elem, value, name1) {
return !1 === value ? // Remove boolean attributes when set to false
jQuery.removeAttr(elem, name1) : getSetInput && getSetAttribute || !ruseDefault.test(name1) ? // IE<8 needs the *property* name
elem.setAttribute(!getSetAttribute && jQuery.propFix[name1] || name1, name1) : elem[jQuery.camelCase("default-" + name1)] = elem[name1] = !0, name1;
}
}, getSetInput && getSetAttribute || (jQuery.attrHooks.value = {
get: function(elem, name1) {
var ret = elem.getAttributeNode(name1);
return jQuery.nodeName(elem, "input") ? elem.defaultValue : ret && ret.specified ? ret.value : undefined;
},
set: function(elem, value, name1) {
if (!jQuery.nodeName(elem, "input")) // Use nodeHook if defined (#1954); otherwise setAttribute is fine
return nodeHook && nodeHook.set(elem, value, name1);
// Does not return so that setAttribute is also used
elem.defaultValue = value;
}
}), getSetAttribute || (// Use this for any attribute in IE6/7
// This fixes almost every IE6/7 issue
nodeHook = jQuery.valHooks.button = {
get: function(elem, name1) {
var ret = elem.getAttributeNode(name1);
return ret && ("id" === name1 || "name" === name1 || "coords" === name1 ? "" !== ret.value : ret.specified) ? ret.value : undefined;
},
set: function(elem, value, name1) {
// Set the existing or create a new attribute node
var ret = elem.getAttributeNode(name1);
// Break association with cloned elements by also using setAttribute (#9646)
return ret || elem.setAttributeNode(ret = elem.ownerDocument.createAttribute(name1)), ret.value = value += "", "value" === name1 || value === elem.getAttribute(name1) ? value : undefined;
}
}, // Set contenteditable to false on removals(#10429)
// Setting to empty string throws an error as an invalid value
jQuery.attrHooks.contenteditable = {
get: nodeHook.get,
set: function(elem, value, name1) {
nodeHook.set(elem, "" !== value && value, name1);
}
}, // Set width and height to auto instead of 0 on empty string( Bug #8150 )
// This is for removals
jQuery.each([
"width",
"height"
], function(i, name1) {
jQuery.attrHooks[name1] = jQuery.extend(jQuery.attrHooks[name1], {
set: function(elem, value) {
if ("" === value) return elem.setAttribute(name1, "auto"), value;
}
});
})), jQuery.support.hrefNormalized || (jQuery.each([
"href",
"src",
"width",
"height"
], function(i, name1) {
jQuery.attrHooks[name1] = jQuery.extend(jQuery.attrHooks[name1], {
get: function(elem) {
var ret = elem.getAttribute(name1, 2);
return null == ret ? undefined : ret;
}
});
}), // href/src property should get the full normalized URL (#10299/#12915)
jQuery.each([
"href",
"src"
], function(i, name1) {
jQuery.propHooks[name1] = {
get: function(elem) {
return elem.getAttribute(name1, 4);
}
};
})), jQuery.support.style || (jQuery.attrHooks.style = {
get: function(elem) {
// Return undefined in the case of empty string
// Note: IE uppercases css property names, but if we were to .toLowerCase()
// .cssText, that would destroy case senstitivity in URL's, like in "background"
return elem.style.cssText || undefined;
},
set: function(elem, value) {
return elem.style.cssText = value + "";
}
}), jQuery.support.optSelected || (jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {
get: function(elem) {
var parent = elem.parentNode;
return parent && (parent.selectedIndex, parent.parentNode && parent.parentNode.selectedIndex), null;
}
})), jQuery.support.enctype || (jQuery.propFix.enctype = "encoding"), jQuery.support.checkOn || jQuery.each([
"radio",
"checkbox"
], function() {
jQuery.valHooks[this] = {
get: function(elem) {
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
return null === elem.getAttribute("value") ? "on" : elem.value;
}
};
}), jQuery.each([
"radio",
"checkbox"
], function() {
jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {
set: function(elem, value) {
if (jQuery.isArray(value)) return elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0;
}
});
});
var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|contextmenu)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
function returnTrue() {
return !0;
}
function returnFalse() {
return !1;
}
/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/ jQuery.event = {
global: {},
add: function(elem, types, handler, data, selector) {
var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery._data(elem);
// Don't attach events to noData or text/comment nodes (but allow plain objects)
if (elemData) {
for(handler.handler && (handler = (handleObjIn = handler).handler, selector = handleObjIn.selector), handler.guid || (handler.guid = jQuery.guid++), (events = elemData.events) || (events = elemData.events = {}), (eventHandle = elemData.handle) || // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
((eventHandle = elemData.handle = function(e) {
// Discard the second event of a jQuery.event.trigger() and
// when an event is called after a page has unloaded
return e && jQuery.event.triggered === e.type ? undefined : jQuery.event.dispatch.apply(eventHandle.elem, arguments);
}).elem = elem), t = // Handle multiple events separated by a space
// jQuery(...).bind("mouseover mouseout", fn);
(types = (types || "").match(core_rnotwhite) || [
""
]).length; t--;)type = origType = (tmp = rtypenamespace.exec(types[t]) || [])[1], namespaces = (tmp[2] || "").split(".").sort(), // If event changes its type, use the special event handlers for the changed type
special = jQuery.event.special[type] || {}, // If selector defined, determine special event api type, otherwise given type
type = (selector ? special.delegateType : special.bindType) || type, // Update special based on newly reset type
special = jQuery.event.special[type] || {}, // handleObj is passed to all event handlers
handleObj = jQuery.extend({
type: type,
origType: origType,
data: data,
handler: handler,
guid: handler.guid,
selector: selector,
needsContext: selector && jQuery.expr.match.needsContext.test(selector),
namespace: namespaces.join(".")
}, handleObjIn), (handlers = events[type]) || ((handlers = events[type] = []).delegateCount = 0, (!special.setup || !1 === special.setup.call(elem, data, namespaces, eventHandle)) && (elem.addEventListener ? elem.addEventListener(type, eventHandle, !1) : elem.attachEvent && elem.attachEvent("on" + type, eventHandle))), special.add && (special.add.call(elem, handleObj), handleObj.handler.guid || (handleObj.handler.guid = handler.guid)), selector ? handlers.splice(handlers.delegateCount++, 0, handleObj) : handlers.push(handleObj), // Keep track of which events have ever been used, for event optimization
jQuery.event.global[type] = !0;
// Nullify elem to prevent memory leaks in IE
elem = null;
}
},
// Detach an event or set of events from an element
remove: function(elem, types, handler, selector, mappedTypes) {
var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery.hasData(elem) && jQuery._data(elem);
if (elemData && (events = elemData.events)) {
for(t = // Once for each type.namespace in types; type may be omitted
(types = (types || "").match(core_rnotwhite) || [
""
]).length; t--;){
// Unbind all events (on this namespace, if provided) for the element
if (type = origType = (tmp = rtypenamespace.exec(types[t]) || [])[1], namespaces = (tmp[2] || "").split(".").sort(), !type) {
for(type in events)jQuery.event.remove(elem, type + types[t], handler, selector, !0);
continue;
}
for(special = jQuery.event.special[type] || {}, handlers = events[type = (selector ? special.delegateType : special.bindType) || type] || [], tmp = tmp[2] && RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"), // Remove matching events
origCount = j = handlers.length; j--;)handleObj = handlers[j], (mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || "**" === selector && handleObj.selector) && (handlers.splice(j, 1), handleObj.selector && handlers.delegateCount--, special.remove && special.remove.call(elem, handleObj));
origCount && !handlers.length && (special.teardown && !1 !== special.teardown.call(elem, namespaces, elemData.handle) || jQuery.removeEvent(elem, type, elemData.handle), delete events[type]);
}
jQuery.isEmptyObject(events) && (delete elemData.handle, // removeData also checks for emptiness and clears the expando if empty
// so use it instead of delete
jQuery._removeData(elem, "events"));
}
},
trigger: function(event, data, elem, onlyHandlers) {
var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [
elem || document
], type = core_hasOwn.call(event, "type") ? event.type : event, namespaces = core_hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
// Don't do events on text and comment nodes
if (cur = tmp = elem = elem || document, !(3 === elem.nodeType || 8 === elem.nodeType || rfocusMorph.test(type + jQuery.event.triggered))) {
if (type.indexOf(".") >= 0 && (type = // Namespaced trigger; create a regexp to match event type in handle()
(namespaces = type.split(".")).shift(), namespaces.sort()), ontype = 0 > type.indexOf(":") && "on" + type, // Caller can pass in a jQuery.Event object, Object, or just an event type string
(event = event[jQuery.expando] ? event : new jQuery.Event(type, "object" == typeof event && event)).isTrigger = !0, event.namespace = namespaces.join("."), event.namespace_re = event.namespace ? RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null, // Clean up the event in case it is being reused
event.result = undefined, event.target || (event.target = elem), // Clone any incoming data and prepend the event, creating the handler arg list
data = null == data ? [
event
] : jQuery.makeArray(data, [
event
]), // Allow special events to draw outside the lines
special = jQuery.event.special[type] || {}, onlyHandlers || !special.trigger || !1 !== special.trigger.apply(elem, data)) {
// Determine event propagation path in advance, per W3C events spec (#9951)
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
for(bubbleType = special.delegateType || type, rfocusMorph.test(bubbleType + type) || (cur = cur.parentNode); cur; cur = cur.parentNode)eventPath.push(cur), tmp = cur;
tmp === (elem.ownerDocument || document) && eventPath.push(tmp.defaultView || tmp.parentWindow || window1);
}
for(// Fire handlers on the event path
i = 0; (cur = eventPath[i++]) && !event.isPropagationStopped();)event.type = i > 1 ? bubbleType : special.bindType || type, // jQuery handler
(handle = (jQuery._data(cur, "events") || {})[event.type] && jQuery._data(cur, "handle")) && handle.apply(cur, data), // Native handler
(handle = ontype && cur[ontype]) && jQuery.acceptData(cur) && handle.apply && !1 === handle.apply(cur, data) && event.preventDefault();
// If nobody prevented the default action, do it now
if (event.type = type, !onlyHandlers && !event.isDefaultPrevented() && (!special._default || !1 === special._default.apply(elem.ownerDocument, data)) && !("click" === type && jQuery.nodeName(elem, "a")) && jQuery.acceptData(elem) && ontype && elem[type] && !jQuery.isWindow(elem)) {
// Don't re-trigger an onFOO event when we call its FOO() method
(tmp = elem[ontype]) && (elem[ontype] = null), // Prevent re-triggering of the same event, since we already bubbled it above
jQuery.event.triggered = type;
try {
elem[type]();
} catch (e) {
// IE<9 dies on focus/blur to hidden element (#1486,#12518)
// only reproducible on winXP IE8 native, not IE9 in IE8 mode
}
jQuery.event.triggered = undefined, tmp && (elem[ontype] = tmp);
}
return event.result;
}
}
},
dispatch: function(event) {
// Make a writable jQuery.Event from the native event object
event = jQuery.event.fix(event);
var i, ret, handleObj, matched, j, handlerQueue = [], args = core_slice.call(arguments), handlers = (jQuery._data(this, "events") || {})[event.type] || [], special = jQuery.event.special[event.type] || {};
// Call the preDispatch hook for the mapped type, and let it bail if desired
if (// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[0] = event, event.delegateTarget = this, !special.preDispatch || !1 !== special.preDispatch.call(this, event)) {
for(// Determine handlers
handlerQueue = jQuery.event.handlers.call(this, event, handlers), // Run delegates first; they may want to stop propagation beneath us
i = 0; (matched = handlerQueue[i++]) && !event.isPropagationStopped();)for(event.currentTarget = matched.elem, j = 0; (handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped();)// Triggered event must either 1) have no namespace, or
// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
(!event.namespace_re || event.namespace_re.test(handleObj.namespace)) && (event.handleObj = handleObj, event.data = handleObj.data, undefined !== (ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args)) && !1 === (event.result = ret) && (event.preventDefault(), event.stopPropagation()));
return special.postDispatch && special.postDispatch.call(this, event), event.result;
}
},
handlers: function(event, handlers) {
var sel, handleObj, matches, i, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
// Find delegate handlers
// Black-hole SVG <use> instance trees (#13180)
// Avoid non-left-click bubbling in Firefox (#3861)
if (delegateCount && cur.nodeType && (!event.button || "click" !== event.type)) {
for(; cur != this; cur = cur.parentNode || this)// Don't check non-elements (#13208)
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
if (1 === cur.nodeType && (!0 !== cur.disabled || "click" !== event.type)) {
for(i = 0, matches = []; i < delegateCount; i++)matches[// Don't conflict with Object.prototype properties (#13203)
sel = (handleObj = handlers[i]).selector + " "] === undefined && (matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) >= 0 : jQuery.find(sel, this, null, [
cur
]).length), matches[sel] && matches.push(handleObj);
matches.length && handlerQueue.push({
elem: cur,
handlers: matches
});
}
}
return delegateCount < handlers.length && handlerQueue.push({
elem: this,
handlers: handlers.slice(delegateCount)
}), handlerQueue;
},
fix: function(event) {
if (event[jQuery.expando]) return event;
// Create a writable copy of the event object and normalize some properties
var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type];
for(fixHook || (this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent.test(type) ? this.keyHooks : {}), copy = fixHook.props ? this.props.concat(fixHook.props) : this.props, event = new jQuery.Event(originalEvent), i = copy.length; i--;)event[prop = copy[i]] = originalEvent[prop];
return event.target || (event.target = originalEvent.srcElement || document), 3 === event.target.nodeType && (event.target = event.target.parentNode), // Support: IE<9
// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
event.metaKey = !!event.metaKey, fixHook.filter ? fixHook.filter(event, originalEvent) : event;
},
// Includes some event props shared by KeyEvent and MouseEvent
props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
fixHooks: {},
keyHooks: {
props: "char charCode key keyCode".split(" "),
filter: function(event, original) {
return null == event.which && (event.which = null != original.charCode ? original.charCode : original.keyCode), event;
}
},
mouseHooks: {
props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
filter: function(event, original) {
var body, eventDoc, doc, button = original.button, fromElement = original.fromElement;
return null == event.pageX && null != original.clientX && (doc = (eventDoc = event.target.ownerDocument || document).documentElement, body = eventDoc.body, event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0), event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0)), !event.relatedTarget && fromElement && (event.relatedTarget = fromElement === event.target ? original.toElement : fromElement), event.which || undefined === button || (event.which = 1 & button ? 1 : 2 & button ? 3 : 4 & button ? 2 : 0), event;
}
},
special: {
load: {
// Prevent triggered image.load events from bubbling to window.load
noBubble: !0
},
click: {
// For checkbox, fire native event so checked state will be right
trigger: function() {
if (jQuery.nodeName(this, "input") && "checkbox" === this.type && this.click) return this.click(), !1;
}
},
focus: {
// Fire native event if possible so blur/focus sequence is correct
trigger: function() {
if (this !== document.activeElement && this.focus) try {
return this.focus(), !1;
} catch (e) {
// Support: IE<9
// If we error on focus to hidden element (#1486, #12518),
// let .trigger() run the handlers
}
},
delegateType: "focusin"
},
blur: {
trigger: function() {
if (this === document.activeElement && this.blur) return this.blur(), !1;
},
delegateType: "focusout"
},
beforeunload: {
postDispatch: function(event) {
// Even when returnValue equals to undefined Firefox will still show alert
event.result !== undefined && (event.originalEvent.returnValue = event.result);
}
}
},
simulate: function(type, elem, event, bubble) {
// Piggyback on a donor event to simulate a different one.
// Fake originalEvent to avoid donor's stopPropagation, but if the
// simulated event prevents default then we do the same on the donor.
var e = jQuery.extend(new jQuery.Event(), event, {
type: type,
isSimulated: !0,
originalEvent: {}
});
bubble ? jQuery.event.trigger(e, null, elem) : jQuery.event.dispatch.call(elem, e), e.isDefaultPrevented() && event.preventDefault();
}
}, jQuery.removeEvent = document.removeEventListener ? function(elem, type, handle) {
elem.removeEventListener && elem.removeEventListener(type, handle, !1);
} : function(elem, type, handle) {
var name1 = "on" + type;
elem.detachEvent && (typeof elem[name1] === core_strundefined && (elem[name1] = null), elem.detachEvent(name1, handle));
}, jQuery.Event = function(src, props) {
// Allow instantiation without the 'new' keyword
if (!(this instanceof jQuery.Event)) return new jQuery.Event(src, props);
src && src.type ? (this.originalEvent = src, this.type = src.type, // Events bubbling up the document may have been marked as prevented
// by a handler lower down the tree; reflect the correct value.
this.isDefaultPrevented = src.defaultPrevented || !1 === src.returnValue || src.getPreventDefault && src.getPreventDefault() ? returnTrue : returnFalse) : this.type = src, props && jQuery.extend(this, props), // Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || jQuery.now(), // Mark it as fixed
this[jQuery.expando] = !0;
}, // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
preventDefault: function() {
var e = this.originalEvent;
this.isDefaultPrevented = returnTrue, e && (e.preventDefault ? e.preventDefault() : e.returnValue = !1);
},
stopPropagation: function() {
var e = this.originalEvent;
this.isPropagationStopped = returnTrue, e && (e.stopPropagation && e.stopPropagation(), // Support: IE
// Set the cancelBubble property of the original event to true
e.cancelBubble = !0);
},
stopImmediatePropagation: function() {
this.isImmediatePropagationStopped = returnTrue, this.stopPropagation();
}
}, // Create mouseenter/leave events using mouseover/out and event-time checks
jQuery.each({
mouseenter: "mouseover",
mouseleave: "mouseout"
}, function(orig, fix) {
jQuery.event.special[orig] = {
delegateType: fix,
bindType: fix,
handle: function(event) {
var ret, related = event.relatedTarget, handleObj = event.handleObj;
return related && (related === this || jQuery.contains(this, related)) || (event.type = handleObj.origType, ret = handleObj.handler.apply(this, arguments), event.type = fix), ret;
}
};
}), jQuery.support.submitBubbles || (jQuery.event.special.submit = {
setup: function() {
// Only need this for delegated form submit events
if (jQuery.nodeName(this, "form")) return !1;
// Lazy-add a submit handler when a descendant form may potentially be submitted
jQuery.event.add(this, "click._submit keypress._submit", function(e) {
// Node name check avoids a VML-related crash in IE (#9807)
var elem = e.target, form = jQuery.nodeName(elem, "input") || jQuery.nodeName(elem, "button") ? elem.form : undefined;
form && !jQuery._data(form, "submitBubbles") && (jQuery.event.add(form, "submit._submit", function(event) {
event._submit_bubble = !0;
}), jQuery._data(form, "submitBubbles", !0));
});
// return undefined since we don't need an event listener
},
postDispatch: function(event) {
// If form was submitted by the user, bubble the event up the tree
event._submit_bubble && (delete event._submit_bubble, this.parentNode && !event.isTrigger && jQuery.event.simulate("submit", this.parentNode, event, !0));
},
teardown: function() {
// Only need this for delegated form submit events
if (jQuery.nodeName(this, "form")) return !1;
// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
jQuery.event.remove(this, "._submit");
}
}), jQuery.support.changeBubbles || (jQuery.event.special.change = {
setup: function() {
if (rformElems.test(this.nodeName)) return ("checkbox" === this.type || "radio" === this.type) && (jQuery.event.add(this, "propertychange._change", function(event) {
"checked" === event.originalEvent.propertyName && (this._just_changed = !0);
}), jQuery.event.add(this, "click._change", function(event) {
this._just_changed && !event.isTrigger && (this._just_changed = !1), // Allow triggered, simulated change events (#11500)
jQuery.event.simulate("change", this, event, !0);
})), !1;
// Delegated event; lazy-add a change handler on descendant inputs
jQuery.event.add(this, "beforeactivate._change", function(e) {
var elem = e.target;
rformElems.test(elem.nodeName) && !jQuery._data(elem, "changeBubbles") && (jQuery.event.add(elem, "change._change", function(event) {
!this.parentNode || event.isSimulated || event.isTrigger || jQuery.event.simulate("change", this.parentNode, event, !0);
}), jQuery._data(elem, "changeBubbles", !0));
});
},
handle: function(event) {
var elem = event.target;
// Swallow native change events from checkbox/radio, we already triggered them above
if (this !== elem || event.isSimulated || event.isTrigger || "radio" !== elem.type && "checkbox" !== elem.type) return event.handleObj.handler.apply(this, arguments);
},
teardown: function() {
return jQuery.event.remove(this, "._change"), !rformElems.test(this.nodeName);
}
}), jQuery.support.focusinBubbles || jQuery.each({
focus: "focusin",
blur: "focusout"
}, function(orig, fix) {
// Attach a single capturing handler while someone wants focusin/focusout
var attaches = 0, handler = function(event) {
jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), !0);
};
jQuery.event.special[fix] = {
setup: function() {
0 == attaches++ && document.addEventListener(orig, handler, !0);
},
teardown: function() {
0 == --attaches && document.removeEventListener(orig, handler, !0);
}
};
}), jQuery.fn.extend({
on: function(types, selector, data, fn, /*INTERNAL*/ one) {
var type, origFn;
// Types can be a map of types/handlers
if ("object" == typeof types) {
for(type in "string" != typeof selector && (// ( types-Object, data )
data = data || selector, selector = undefined), types)this.on(type, selector, data, types[type], one);
return this;
}
if (null == data && null == fn ? (// ( types, fn )
fn = selector, data = selector = undefined) : null == fn && ("string" == typeof selector ? (// ( types, selector, fn )
fn = data, data = undefined) : (// ( types, data, fn )
fn = data, data = selector, selector = undefined)), !1 === fn) fn = returnFalse;
else if (!fn) return this;
return 1 === one && (origFn = fn, // Use same guid so caller can remove using origFn
(fn = function(event) {
return(// Can use an empty set, since event contains the info
jQuery().off(event), origFn.apply(this, arguments));
}).guid = origFn.guid || (origFn.guid = jQuery.guid++)), this.each(function() {
jQuery.event.add(this, types, fn, data, selector);
});
},
one: function(types, selector, data, fn) {
return this.on(types, selector, data, fn, 1);
},
off: function(types, selector, fn) {
var handleObj, type;
if (types && types.preventDefault && types.handleObj) return(// ( event ) dispatched jQuery.Event
handleObj = types.handleObj, jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler), this);
if ("object" == typeof types) {
// ( types-object [, selector] )
for(type in types)this.off(type, selector, types[type]);
return this;
}
return (!1 === selector || "function" == typeof selector) && (// ( types [, fn] )
fn = selector, selector = undefined), !1 === fn && (fn = returnFalse), this.each(function() {
jQuery.event.remove(this, types, fn, selector);
});
},
bind: function(types, data, fn) {
return this.on(types, null, data, fn);
},
unbind: function(types, fn) {
return this.off(types, null, fn);
},
delegate: function(selector, types, data, fn) {
return this.on(types, selector, data, fn);
},
undelegate: function(selector, types, fn) {
// ( namespace ) or ( selector, types [, fn] )
return 1 == arguments.length ? this.off(selector, "**") : this.off(types, selector || "**", fn);
},
trigger: function(type, data) {
return this.each(function() {
jQuery.event.trigger(type, data, this);
});
},
triggerHandler: function(type, data) {
var elem = this[0];
if (elem) return jQuery.event.trigger(type, data, elem, !0);
}
}), /*!
* Sizzle CSS Selector Engine
* Copyright 2012 jQuery Foundation and other contributors
* Released under the MIT license
* http://sizzlejs.com/
*/ function(window1, undefined) {
var i, cachedruns, Expr, getText, isXML, compile, hasDuplicate, outermostContext, // Local document vars
setDocument, document, docElem, documentIsXML, rbuggyQSA, rbuggyMatches, matches, contains, sortOrder, // Instance-specific data
expando = "sizzle" + -new Date(), preferredDoc = window1.document, support = {}, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), // General-purpose constants
strundefined = "undefined", // Array methods
arr = [], pop = arr.pop, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf if we can't use a native one
indexOf = arr.indexOf || function(elem) {
for(var i = 0, len = this.length; i < len; i++)if (this[i] === elem) return i;
return -1;
}, // Regular expressions
// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]", // http://www.w3.org/TR/css3-syntax/#characters
characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", // Loosely modeled on CSS identifier characters
// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
identifier = characterEncoding.replace("w", "w#"), attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + "*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", // Prefer arguments quoted,
// then not containing pseudos/brackets,
// then attribute selectors/non-parenthetical expressions,
// then anything else
// These preferences are here to reduce the number of selectors
// needing tokenize in the PSEUDO preFilter
pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace(3, 8) + ")*)|.*)\\)|)", // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rtrim = RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), rcomma = RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = RegExp("^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*"), rpseudo = new RegExp(pseudos), ridentifier = RegExp("^" + identifier + "$"), matchExpr = {
ID: RegExp("^#(" + characterEncoding + ")"),
CLASS: RegExp("^\\.(" + characterEncoding + ")"),
NAME: RegExp("^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]"),
TAG: RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
ATTR: RegExp("^" + attributes),
PSEUDO: RegExp("^" + pseudos),
CHILD: RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
// For use in libraries implementing .is()
// We use this for POS matching in `select`
needsContext: RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
}, rsibling = /[\x20\t\r\n\f]*[+~]/, rnative = /^[^{]+\{\s*\[native code/, // Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rescape = /'|\\/g, rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g, funescape = function(_, escaped) {
var high = "0x" + escaped - 0x10000;
// NaN means non-codepoint
return high != high ? escaped : high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xd800, 0x3ff & high | 0xdc00);
};
// Use a stripped-down slice if we can't use a native one
try {
slice.call(preferredDoc.documentElement.childNodes, 0)[0].nodeType;
} catch (e) {
slice = function(i) {
for(var elem, results = []; elem = this[i++];)results.push(elem);
return results;
};
}
/**
* For feature detection
* @param {Function} fn The function to test for native support
*/ function isNative(fn) {
return rnative.test(fn + "");
}
/**
* Create key-value caches of limited size
* @returns {Function(string, Object)} Returns the Object data after storing it on itself with
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
* deleting the oldest entry
*/ function createCache() {
var cache, keys = [];
return cache = function(key, value) {
return keys.push(key += " ") > Expr.cacheLength && // Only keep the most recent entries
delete cache[keys.shift()], cache[key] = value;
};
}
/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/ function markFunction(fn) {
return fn[expando] = !0, fn;
}
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/ function assert(fn) {
var div = document.createElement("div");
try {
return fn(div);
} catch (e) {
return !1;
} finally{
// release memory in IE
div = null;
}
}
function Sizzle(selector, context, results, seed) {
var match, elem, m, nodeType, // QSA vars
i, groups, old, nid, newContext, newSelector;
if ((context ? context.ownerDocument || context : preferredDoc) !== document && setDocument(context), context = context || document, results = results || [], !selector || "string" != typeof selector) return results;
if (1 !== (nodeType = context.nodeType) && 9 !== nodeType) return [];
if (!documentIsXML && !seed) {
// Shortcuts
if (match = rquickExpr.exec(selector)) {
// Speed-up: Sizzle("#ID")
if (m = match[1]) {
if (9 === nodeType) {
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if (!(elem = context.getElementById(m)) || !elem.parentNode) return results;
// Handle the case where IE, Opera, and Webkit return items
// by name instead of ID
if (elem.id === m) return results.push(elem), results;
} else // Context is not a document
if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) && contains(context, elem) && elem.id === m) return results.push(elem), results;
} else if (match[2]) return push.apply(results, slice.call(context.getElementsByTagName(selector), 0)), results;
else if ((m = match[3]) && support.getByClassName && context.getElementsByClassName) return push.apply(results, slice.call(context.getElementsByClassName(m), 0)), results;
}
// QSA path
if (support.qsa && !rbuggyQSA.test(selector)) {
// qSA works strangely on Element-rooted queries
// We can work around this by specifying an extra ID on the root
// and working up from there (Thanks to Andrew Dupont for the technique)
// IE 8 doesn't work on object elements
if (old = !0, nid = expando, newContext = context, newSelector = 9 === nodeType && selector, 1 === nodeType && "object" !== context.nodeName.toLowerCase()) {
for(groups = tokenize(selector), (old = context.getAttribute("id")) ? nid = old.replace(rescape, "\\$&") : context.setAttribute("id", nid), nid = "[id='" + nid + "'] ", i = groups.length; i--;)groups[i] = nid + toSelector(groups[i]);
newContext = rsibling.test(selector) && context.parentNode || context, newSelector = groups.join(",");
}
if (newSelector) try {
return push.apply(results, slice.call(newContext.querySelectorAll(newSelector), 0)), results;
} catch (qsaError) {} finally{
old || context.removeAttribute("id");
}
}
}
// All others
return function(selector, context, results, seed) {
var i, tokens, token, type, find, match = tokenize(selector);
if (!seed && 1 === match.length) {
if (// Take a shortcut and set the context if the root selector is an ID
(tokens = match[0] = match[0].slice(0)).length > 2 && "ID" === (token = tokens[0]).type && 9 === context.nodeType && !documentIsXML && Expr.relative[tokens[1].type]) {
if (!(context = Expr.find.ID(token.matches[0].replace(runescape, funescape), context)[0])) return results;
selector = selector.slice(tokens.shift().value.length);
}
for(// Fetch a seed set for right-to-left matching
i = matchExpr.needsContext.test(selector) ? 0 : tokens.length; // Abort if we hit a combinator
i-- && (token = tokens[i], !Expr.relative[type = token.type]);)if ((find = Expr.find[type]) && (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && context.parentNode || context))) {
if (// If seed is empty or no tokens remain, we can return early
tokens.splice(i, 1), !(selector = seed.length && toSelector(tokens))) return push.apply(results, slice.call(seed, 0)), results;
break;
}
}
return(// Compile and execute a filtering function
// Provide `match` to avoid retokenization if we modified the selector above
compile(selector, match)(seed, context, documentIsXML, results, rsibling.test(selector)), results);
}(selector.replace(rtrim, "$1"), context, results, seed);
}
function siblingCheck(a, b) {
var cur = b && a, diff = cur && (~b.sourceIndex || -2147483648) - (~a.sourceIndex || -2147483648);
// Use IE sourceIndex if available on both nodes
if (diff) return diff;
// Check if b follows a
if (cur) {
for(; cur = cur.nextSibling;)if (cur === b) return -1;
}
return a ? 1 : -1;
}
// Returns a function to use in pseudos for positionals
function createPositionalPseudo(fn) {
return markFunction(function(argument) {
return argument *= 1, markFunction(function(seed, matches) {
// Match elements found at the specified indexes
for(var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length; i--;)seed[j = matchIndexes[i]] && (seed[j] = !(matches[j] = seed[j]));
});
});
}
// Add button/input type pseudos
for(i in /**
* Detect xml
* @param {Element|Object} elem An element or a document
*/ isXML = Sizzle.isXML = function(elem) {
// documentElement is verified for cases where it doesn't yet exist
// (such as loading iframes in IE - #4833)
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
return !!documentElement && "HTML" !== documentElement.nodeName;
}, /**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/ setDocument = Sizzle.setDocument = function(node) {
var doc = node ? node.ownerDocument || node : preferredDoc;
return doc !== document && 9 === doc.nodeType && doc.documentElement && (// Set our document
document = doc, docElem = doc.documentElement, // Support tests
documentIsXML = isXML(doc), // Check if getElementsByTagName("*") returns only elements
support.tagNameNoComments = assert(function(div) {
return div.appendChild(doc.createComment("")), !div.getElementsByTagName("*").length;
}), // Check if attributes should be retrieved by attribute nodes
support.attributes = assert(function(div) {
div.innerHTML = "<select></select>";
var type = typeof div.lastChild.getAttribute("multiple");
// IE8 returns a string for some attributes even when not present
return "boolean" !== type && "string" !== type;
}), // Check if getElementsByClassName can be trusted
support.getByClassName = assert(function(div) {
return(// Opera can't find a second classname (in 9.6)
div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>", !!div.getElementsByClassName && !!div.getElementsByClassName("e").length && (// Safari 3.2 caches class attributes and doesn't catch changes
div.lastChild.className = "e", 2 === div.getElementsByClassName("e").length));
}), // Check if getElementById returns elements by name
// Check if getElementsByName privileges form controls or returns elements by ID
support.getByName = assert(function(div) {
// Inject content
div.id = expando + 0, div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>", docElem.insertBefore(div, docElem.firstChild);
// Test
var pass = doc.getElementsByName && // buggy browsers will return fewer than the correct 2
doc.getElementsByName(expando).length === 2 + // buggy browsers will return more than the correct 0
doc.getElementsByName(expando + 0).length;
return support.getIdNotName = !doc.getElementById(expando), // Cleanup
docElem.removeChild(div), pass;
}), // IE6/7 return modified attributes
Expr.attrHandle = assert(function(div) {
return div.innerHTML = "<a href='#'></a>", div.firstChild && typeof div.firstChild.getAttribute !== strundefined && "#" === div.firstChild.getAttribute("href");
}) ? {} : {
href: function(elem) {
return elem.getAttribute("href", 2);
},
type: function(elem) {
return elem.getAttribute("type");
}
}, support.getIdNotName ? (Expr.find.ID = function(id, context) {
if (typeof context.getElementById !== strundefined && !documentIsXML) {
var m = context.getElementById(id);
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
return m && m.parentNode ? [
m
] : [];
}
}, Expr.filter.ID = function(id) {
var attrId = id.replace(runescape, funescape);
return function(elem) {
return elem.getAttribute("id") === attrId;
};
}) : (Expr.find.ID = function(id, context) {
if (typeof context.getElementById !== strundefined && !documentIsXML) {
var m = context.getElementById(id);
return m ? m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? [
m
] : void 0 : [];
}
}, Expr.filter.ID = function(id) {
var attrId = id.replace(runescape, funescape);
return function(elem) {
var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
return node && node.value === attrId;
};
}), // Tag
Expr.find.TAG = support.tagNameNoComments ? function(tag, context) {
if (typeof context.getElementsByTagName !== strundefined) return context.getElementsByTagName(tag);
} : function(tag, context) {
var elem, tmp = [], i = 0, results = context.getElementsByTagName(tag);
// Filter out possible comments
if ("*" === tag) {
for(; elem = results[i++];)1 === elem.nodeType && tmp.push(elem);
return tmp;
}
return results;
}, // Name
Expr.find.NAME = support.getByName && function(tag, context) {
if (typeof context.getElementsByName !== strundefined) return context.getElementsByName(name);
}, // Class
Expr.find.CLASS = support.getByClassName && function(className, context) {
if (typeof context.getElementsByClassName !== strundefined && !documentIsXML) return context.getElementsByClassName(className);
}, // QSA and matchesSelector support
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [], // qSa(:focus) reports false when true (Chrome 21),
// no need to also add to buggyMatches since matches checks buggyQSA
// A support test would require too much code (would include document ready)
rbuggyQSA = [
":focus"
], (support.qsa = isNative(doc.querySelectorAll)) && (// Build QSA regex
// Regex strategy adopted from Diego Perini
assert(function(div) {
// Select is set to empty string on purpose
// This is to test IE's treatment of not explictly
// setting a boolean content attribute,
// since its presence should be enough
// http://bugs.jquery.com/ticket/12359
div.innerHTML = "<select><option selected=''></option></select>", div.querySelectorAll("[selected]").length || rbuggyQSA.push("\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)"), div.querySelectorAll(":checked").length || rbuggyQSA.push(":checked");
}), assert(function(div) {
// Opera 10-12/IE8 - ^= $= *= and empty values
// Should not select anything
div.innerHTML = "<input type='hidden' i=''/>", div.querySelectorAll("[i^='']").length && rbuggyQSA.push("[*^$]=" + whitespace + "*(?:\"\"|'')"), div.querySelectorAll(":enabled").length || rbuggyQSA.push(":enabled", ":disabled"), // Opera 10-11 does not throw on post-comma invalid pseudos
div.querySelectorAll("*,:x"), rbuggyQSA.push(",.*:");
})), (support.matchesSelector = isNative(matches = docElem.matchesSelector || docElem.mozMatchesSelector || docElem.webkitMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) && assert(function(div) {
// Check to see if it's possible to do matchesSelector
// on a disconnected node (IE 9)
support.disconnectedMatch = matches.call(div, "div"), // This should fail with an exception
// Gecko does not error, returns false instead
matches.call(div, "[s!='']:x"), rbuggyMatches.push("!=", pseudos);
}), rbuggyQSA = new RegExp(rbuggyQSA.join("|")), rbuggyMatches = new RegExp(rbuggyMatches.join("|")), // Element contains another
// Purposefully does not implement inclusive descendent
// As in, an element does not contain itself
contains = isNative(docElem.contains) || docElem.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;
}, // Document order sorting
sortOrder = docElem.compareDocumentPosition ? function(a, b) {
var compare;
if (a === b) return hasDuplicate = !0, 0;
if (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition(b)) return 1 & compare || a.parentNode && 11 === a.parentNode.nodeType ? a === doc || contains(preferredDoc, a) ? -1 : b === doc || contains(preferredDoc, b) ? 1 : 0 : 4 & compare ? -1 : 1;
return a.compareDocumentPosition ? -1 : 1;
} : function(a, b) {
var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [
a
], bp = [
b
];
// Exit early if the nodes are identical
if (a === b) return hasDuplicate = !0, 0;
if (!aup || !bup) return a === doc ? -1 : b === doc ? 1 : aup ? -1 : +!!bup;
if (aup === bup) return siblingCheck(a, b);
for(// Otherwise we need full lists of their ancestors for comparison
cur = a; cur = cur.parentNode;)ap.unshift(cur);
for(cur = b; cur = cur.parentNode;)bp.unshift(cur);
// Walk down the tree looking for a discrepancy
for(; ap[i] === bp[i];)i++;
return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : +(bp[i] === preferredDoc);
}, // Always assume the presence of duplicates if sort doesn't
// pass them to our comparison function (as in Google Chrome).
hasDuplicate = !1, [
0,
0
].sort(sortOrder), support.detectDuplicates = hasDuplicate), document;
}, Sizzle.matches = function(expr, elements) {
return Sizzle(expr, null, null, elements);
}, Sizzle.matchesSelector = function(elem, expr) {
// rbuggyQSA always contains :focus, so no need for an existence check
if ((elem.ownerDocument || elem) !== document && setDocument(elem), // Make sure that attribute selectors are quoted
expr = expr.replace(rattributeQuotes, "='$1']"), support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr)) try {
var ret = matches.call(elem, expr);
// IE 9's matchesSelector returns false on disconnected nodes
if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document
// fragment in IE 9
elem.document && 11 !== elem.document.nodeType) return ret;
} catch (e) {}
return Sizzle(expr, document, null, [
elem
]).length > 0;
}, Sizzle.contains = function(context, elem) {
return (context.ownerDocument || context) !== document && setDocument(context), contains(context, elem);
}, Sizzle.attr = function(elem, name1) {
var val;
return ((elem.ownerDocument || elem) !== document && setDocument(elem), documentIsXML || (name1 = name1.toLowerCase()), val = Expr.attrHandle[name1]) ? val(elem) : documentIsXML || support.attributes ? elem.getAttribute(name1) : ((val = elem.getAttributeNode(name1)) || elem.getAttribute(name1)) && !0 === elem[name1] ? name1 : val && val.specified ? val.value : null;
}, Sizzle.error = function(msg) {
throw Error("Syntax error, unrecognized expression: " + msg);
}, // Document sorting and removing duplicates
Sizzle.uniqueSort = function(results) {
var elem, duplicates = [], i = 1, j = 0;
if (// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates, results.sort(sortOrder), hasDuplicate) {
for(; elem = results[i]; i++)elem === results[i - 1] && (j = duplicates.push(i));
for(; j--;)results.splice(duplicates[j], 1);
}
return results;
}, /**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/ getText = Sizzle.getText = function(elem) {
var node, ret = "", i = 0, nodeType = elem.nodeType;
if (nodeType) {
if (1 === nodeType || 9 === nodeType || 11 === nodeType) {
// Use textContent for elements
// innerText usage removed for consistency of new lines (see #11153)
if ("string" == typeof elem.textContent) return elem.textContent;
// Traverse its children
for(elem = elem.firstChild; elem; elem = elem.nextSibling)ret += getText(elem);
} else if (3 === nodeType || 4 === nodeType) return elem.nodeValue;
} else // If no nodeType, this is expected to be an array
for(; node = elem[i]; i++)// Do not traverse comment nodes
ret += getText(node);
// Do not include comment or processing instruction nodes
return ret;
}, Expr = Sizzle.selectors = {
// Can be adjusted by the user
cacheLength: 50,
createPseudo: markFunction,
match: matchExpr,
find: {},
relative: {
">": {
dir: "parentNode",
first: !0
},
" ": {
dir: "parentNode"
},
"+": {
dir: "previousSibling",
first: !0
},
"~": {
dir: "previousSibling"
}
},
preFilter: {
ATTR: function(match) {
return match[1] = match[1].replace(runescape, funescape), // Move the given value to match[3] whether quoted or unquoted
match[3] = (match[4] || match[5] || "").replace(runescape, funescape), "~=" === match[2] && (match[3] = " " + match[3] + " "), match.slice(0, 4);
},
CHILD: function(match) {
return(/* matches from matchExpr["CHILD"]
1 type (only|nth|...)
2 what (child|of-type)
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4 xn-component of xn+y argument ([+-]?\d*n|)
5 sign of xn-component
6 x of xn-component
7 sign of y-component
8 y of y-component
*/ match[1] = match[1].toLowerCase(), "nth" === match[1].slice(0, 3) ? (match[3] || Sizzle.error(match[0]), // numeric x and y parameters for Expr.filter.CHILD
// remember that false/true cast respectively to 0/1
match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * ("even" === match[3] || "odd" === match[3])), match[5] = +(match[7] + match[8] || "odd" === match[3])) : match[3] && Sizzle.error(match[0]), match);
},
PSEUDO: function(match) {
var excess, unquoted = !match[5] && match[2];
return matchExpr.CHILD.test(match[0]) ? null : (match[4] ? match[2] = match[4] : unquoted && rpseudo.test(unquoted) && // Get excess from tokenize (recursively)
(excess = tokenize(unquoted, !0)) && // advance to the next closing parenthesis
(excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length) && (// excess is a negative index
match[0] = match[0].slice(0, excess), match[2] = unquoted.slice(0, excess)), match.slice(0, 3));
}
},
filter: {
TAG: function(nodeName) {
return "*" === nodeName ? function() {
return !0;
} : (nodeName = nodeName.replace(runescape, funescape).toLowerCase(), function(elem) {
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
});
},
CLASS: function(className) {
var pattern = classCache[className + " "];
return pattern || (pattern = RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)"), classCache(className, function(elem) {
return pattern.test(elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "");
}));
},
ATTR: function(name1, operator, check) {
return function(elem) {
var result = Sizzle.attr(elem, name1);
return null == result ? "!=" === operator : !operator || (result += "", "=" === operator ? result === check : "!=" === operator ? result !== check : "^=" === operator ? check && 0 === result.indexOf(check) : "*=" === operator ? check && result.indexOf(check) > -1 : "$=" === operator ? check && result.slice(-check.length) === check : "~=" === operator ? (" " + result + " ").indexOf(check) > -1 : "|=" === operator && (result === check || result.slice(0, check.length + 1) === check + "-"));
};
},
CHILD: function(type, what, argument, first, last) {
var simple = "nth" !== type.slice(0, 3), forward = "last" !== type.slice(-4), ofType = "of-type" === what;
return 1 === first && 0 === last ? function(elem) {
return !!elem.parentNode;
} : function(elem, context, xml) {
var cache, outerCache, node, diff, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name1 = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType;
if (parent) {
// :(first|last|only)-(child|of-type)
if (simple) {
for(; dir;){
for(node = elem; node = node[dir];)if (ofType ? node.nodeName.toLowerCase() === name1 : 1 === node.nodeType) return !1;
// Reverse direction for :only-* (if we haven't yet done so)
start = dir = "only" === type && !start && "nextSibling";
}
return !0;
}
// non-xml :nth-child(...) stores cache data on `parent`
if (start = [
forward ? parent.firstChild : parent.lastChild
], forward && useCache) {
for(nodeIndex = (cache = // Seek `elem` from a previously-cached index
(outerCache = parent[expando] || (parent[expando] = {}))[type] || [])[0] === dirruns && cache[1], diff = cache[0] === dirruns && cache[2], node = nodeIndex && parent.childNodes[nodeIndex]; node = ++nodeIndex && node && node[dir] || // Fallback to seeking `elem` from the start
(diff = nodeIndex = 0) || start.pop();)// When found, cache indexes on `parent` and break
if (1 === node.nodeType && ++diff && node === elem) {
outerCache[type] = [
dirruns,
nodeIndex,
diff
];
break;
}
} else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) diff = cache[1];
else // Use the same loop as above to seek `elem` from the start
for(; (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) && (!((ofType ? node.nodeName.toLowerCase() === name1 : 1 === node.nodeType) && ++diff) || (useCache && ((node[expando] || (node[expando] = {}))[type] = [
dirruns,
diff
]), node !== elem)););
return(// Incorporate the offset, then check against cycle size
(diff -= last) === first || diff % first == 0 && diff / first >= 0);
}
};
},
PSEUDO: function(pseudo, argument) {
// pseudo-class names are case-insensitive
// http://www.w3.org/TR/selectors/#pseudo-classes
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
// Remember that setFilters inherits from pseudos
var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
return(// The user may use createPseudo to indicate that
// arguments are needed to create the filter function
// just as Sizzle does
fn[expando] ? fn(argument) : fn.length > 1 ? (args = [
pseudo,
pseudo,
"",
argument
], Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
for(var idx, matched = fn(seed, argument), i = matched.length; i--;)idx = indexOf.call(seed, matched[i]), seed[idx] = !(matches[idx] = matched[i]);
}) : function(elem) {
return fn(elem, 0, args);
}) : fn);
}
},
pseudos: {
// Potentially complex pseudos
not: markFunction(function(selector) {
// Trim the selector passed to compile
// to avoid treating leading and trailing
// spaces as combinators
var input = [], results = [], matcher = compile(selector.replace(rtrim, "$1"));
return matcher[expando] ? markFunction(function(seed, matches, context, xml) {
// Match elements unmatched by `matcher`
for(var elem, unmatched = matcher(seed, null, xml, []), i = seed.length; i--;)(elem = unmatched[i]) && (seed[i] = !(matches[i] = elem));
}) : function(elem, context, xml) {
return input[0] = elem, matcher(input, null, xml, results), !results.pop();
};
}),
has: markFunction(function(selector) {
return function(elem) {
return Sizzle(selector, elem).length > 0;
};
}),
contains: markFunction(function(text) {
return function(elem) {
return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
};
}),
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
lang: markFunction(function(lang) {
return ridentifier.test(lang || "") || Sizzle.error("unsupported lang: " + lang), lang = lang.replace(runescape, funescape).toLowerCase(), function(elem) {
var elemLang;
do if (elemLang = documentIsXML ? elem.getAttribute("xml:lang") || elem.getAttribute("lang") : elem.lang) return (elemLang = elemLang.toLowerCase()) === lang || 0 === elemLang.indexOf(lang + "-");
while ((elem = elem.parentNode) && 1 === elem.nodeType)
return !1;
};
}),
// Miscellaneous
target: function(elem) {
var hash = window1.location && window1.location.hash;
return hash && hash.slice(1) === elem.id;
},
root: function(elem) {
return elem === docElem;
},
focus: function(elem) {
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
},
// Boolean properties
enabled: function(elem) {
return !1 === elem.disabled;
},
disabled: function(elem) {
return !0 === elem.disabled;
},
checked: function(elem) {
// In CSS3, :checked should return both checked and selected elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
var nodeName = elem.nodeName.toLowerCase();
return "input" === nodeName && !!elem.checked || "option" === nodeName && !!elem.selected;
},
selected: function(elem) {
return elem.parentNode && elem.parentNode.selectedIndex, !0 === elem.selected;
},
// Contents
empty: function(elem) {
// http://www.w3.org/TR/selectors/#empty-pseudo
// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
// not comment, processing instructions, or others
// Thanks to Diego Perini for the nodeName shortcut
// Greater than "@" means alpha characters (specifically not starting with "#" or "?")
for(elem = elem.firstChild; elem; elem = elem.nextSibling)if (elem.nodeName > "@" || 3 === elem.nodeType || 4 === elem.nodeType) return !1;
return !0;
},
parent: function(elem) {
return !Expr.pseudos.empty(elem);
},
// Element/input types
header: function(elem) {
return rheader.test(elem.nodeName);
},
input: function(elem) {
return rinputs.test(elem.nodeName);
},
button: function(elem) {
var name1 = elem.nodeName.toLowerCase();
return "input" === name1 && "button" === elem.type || "button" === name1;
},
text: function(elem) {
var attr;
// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
// use getAttribute instead to test this case
return "input" === elem.nodeName.toLowerCase() && "text" === elem.type && (null == (attr = elem.getAttribute("type")) || attr.toLowerCase() === elem.type);
},
// Position-in-collection
first: createPositionalPseudo(function() {
return [
0
];
}),
last: createPositionalPseudo(function(matchIndexes, length) {
return [
length - 1
];
}),
eq: createPositionalPseudo(function(matchIndexes, length, argument) {
return [
argument < 0 ? argument + length : argument
];
}),
even: createPositionalPseudo(function(matchIndexes, length) {
for(var i = 0; i < length; i += 2)matchIndexes.push(i);
return matchIndexes;
}),
odd: createPositionalPseudo(function(matchIndexes, length) {
for(var i = 1; i < length; i += 2)matchIndexes.push(i);
return matchIndexes;
}),
lt: createPositionalPseudo(function(matchIndexes, length, argument) {
for(var i = argument < 0 ? argument + length : argument; --i >= 0;)matchIndexes.push(i);
return matchIndexes;
}),
gt: createPositionalPseudo(function(matchIndexes, length, argument) {
for(var i = argument < 0 ? argument + length : argument; ++i < length;)matchIndexes.push(i);
return matchIndexes;
})
}
}, {
radio: !0,
checkbox: !0,
file: !0,
password: !0,
image: !0
})Expr.pseudos[i] = // Returns a function to use in pseudos for input types
function(type) {
return function(elem) {
return "input" === elem.nodeName.toLowerCase() && elem.type === type;
};
}(i);
for(i in {
submit: !0,
reset: !0
})Expr.pseudos[i] = // Returns a function to use in pseudos for buttons
function(type) {
return function(elem) {
var name1 = elem.nodeName.toLowerCase();
return ("input" === name1 || "button" === name1) && elem.type === type;
};
}(i);
function tokenize(selector, parseOnly) {
var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
if (cached) return parseOnly ? 0 : cached.slice(0);
for(soFar = selector, groups = [], preFilters = Expr.preFilter; soFar;){
// Filters
for(type in (!matched || (match = rcomma.exec(soFar))) && (match && // Don't consume trailing commas as valid
(soFar = soFar.slice(match[0].length) || soFar), groups.push(tokens = [])), matched = !1, (match = rcombinators.exec(soFar)) && (matched = match.shift(), tokens.push({
value: matched,
// Cast descendant combinators to space
type: match[0].replace(rtrim, " ")
}), soFar = soFar.slice(matched.length)), Expr.filter)(match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match))) && (matched = match.shift(), tokens.push({
value: matched,
type: type,
matches: match
}), soFar = soFar.slice(matched.length));
if (!matched) break;
}
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
}
function toSelector(tokens) {
for(var i = 0, len = tokens.length, selector = ""; i < len; i++)selector += tokens[i].value;
return selector;
}
function addCombinator(matcher, combinator, base) {
var dir = combinator.dir, checkNonElements = base && "parentNode" === dir, doneName = done++;
return combinator.first ? function(elem, context, xml) {
for(; elem = elem[dir];)if (1 === elem.nodeType || checkNonElements) return matcher(elem, context, xml);
} : function(elem, context, xml) {
var data, cache, outerCache, dirkey = dirruns + " " + doneName;
// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
if (xml) {
for(; elem = elem[dir];)if ((1 === elem.nodeType || checkNonElements) && matcher(elem, context, xml)) return !0;
} else for(; elem = elem[dir];)if (1 === elem.nodeType || checkNonElements) {
if ((cache = (outerCache = elem[expando] || (elem[expando] = {}))[dir]) && cache[0] === dirkey) {
if (!0 === (data = cache[1]) || data === cachedruns) return !0 === data;
} else if ((cache = outerCache[dir] = [
dirkey
])[1] = matcher(elem, context, xml) || cachedruns, !0 === cache[1]) return !0;
}
};
}
function elementMatcher(matchers) {
return matchers.length > 1 ? function(elem, context, xml) {
for(var i = matchers.length; i--;)if (!matchers[i](elem, context, xml)) return !1;
return !0;
} : matchers[0];
}
function condense(unmatched, map, filter, context, xml) {
for(var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = null != map; i < len; i++)(elem = unmatched[i]) && (!filter || filter(elem, context, xml)) && (newUnmatched.push(elem), mapped && map.push(i));
return newUnmatched;
}
// Easy API for creating new setFilters
function setFilters() {}
compile = Sizzle.compile = function(selector, group /* Internal Use Only */ ) {
var matcherCachedRuns, bySet, byElement, superMatcher, i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
if (!cached) {
for(group || (group = tokenize(selector)), i = group.length; i--;)(cached = function matcherFromTokens(tokens) {
for(var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i = +!!leadingRelative, // The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator(function(elem) {
return elem === checkContext;
}, implicitRelative, !0), matchAnyContext = addCombinator(function(elem) {
return indexOf.call(checkContext, elem) > -1;
}, implicitRelative, !0), matchers = [
function(elem, context, xml) {
return !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
}
]; i < len; i++)if (matcher = Expr.relative[tokens[i].type]) matchers = [
addCombinator(elementMatcher(matchers), matcher)
];
else {
// Return special upon seeing a positional matcher
if ((matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches))[expando]) {
for(// Find the next relative operator (if any) for proper handling
j = ++i; j < len && !Expr.relative[tokens[j].type]; j++);
return function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
return postFilter && !postFilter[expando] && (postFilter = setMatcher(postFilter)), postFinder && !postFinder[expando] && (postFinder = setMatcher(postFinder, postSelector)), markFunction(function(seed, results, context, xml) {
var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, // Get initial elements from seed or context
elems = seed || function(selector, contexts, results) {
for(var i = 0, len = contexts.length; i < len; i++)Sizzle(selector, contexts[i], results);
return results;
}(selector || "*", context.nodeType ? [
context
] : context, []), // Prefilter to get matcher input, preserving a map for seed-results synchronization
matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : matcherIn;
// Apply postFilter
if (matcher && matcher(matcherIn, matcherOut, context, xml), postFilter) for(temp = condense(matcherOut, postMap), postFilter(temp, [], context, xml), // Un-match failing elements by moving them back to matcherIn
i = temp.length; i--;)(elem = temp[i]) && (matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem));
if (seed) {
if (postFinder || preFilter) {
if (postFinder) {
for(// Get the final matcherOut by condensing this intermediate into postFinder contexts
temp = [], i = matcherOut.length; i--;)(elem = matcherOut[i]) && // Restore matcherIn since elem is not yet a final match
temp.push(matcherIn[i] = elem);
postFinder(null, matcherOut = [], temp, xml);
}
for(// Move matched elements from seed to results to keep them synchronized
i = matcherOut.length; i--;)(elem = matcherOut[i]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1 && (seed[temp] = !(results[temp] = elem));
}
} else matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut), postFinder ? postFinder(null, results, matcherOut, xml) : push.apply(results, matcherOut);
});
}(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1)).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
}
matchers.push(matcher);
}
return elementMatcher(matchers);
}(group[i]))[expando] ? setMatchers.push(cached) : elementMatchers.push(cached);
// Cache the compiled function
cached = compilerCache(selector, (matcherCachedRuns = 0, bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, expandContext) {
var elem, j, matcher, setMatched = [], matchedCount = 0, i = "0", unmatched = seed && [], outermost = null != expandContext, contextBackup = outermostContext, // We must always have either seed elements or context
elems = seed || byElement && Expr.find.TAG("*", expandContext && context.parentNode || context), // Use integer dirruns iff this is the outermost matcher
dirrunsUnique = dirruns += null == contextBackup ? 1 : Math.random() || 0.1;
// Add elements passing elementMatchers directly to results
// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
for(outermost && (outermostContext = context !== document && context, cachedruns = matcherCachedRuns); null != (elem = elems[i]); i++){
if (byElement && elem) {
for(j = 0; matcher = elementMatchers[j++];)if (matcher(elem, context, xml)) {
results.push(elem);
break;
}
outermost && (dirruns = dirrunsUnique, cachedruns = ++matcherCachedRuns);
}
// Track unmatched elements for set filters
bySet && ((elem = !matcher && elem) && matchedCount--, seed && unmatched.push(elem));
}
if (// Apply set filters to unmatched elements
matchedCount += i, bySet && i !== matchedCount) {
for(j = 0; matcher = setMatchers[j++];)matcher(unmatched, setMatched, context, xml);
if (seed) {
// Reintegrate element matches to eliminate the need for sorting
if (matchedCount > 0) for(; i--;)unmatched[i] || setMatched[i] || (setMatched[i] = pop.call(results));
// Discard index placeholder values to get only actual matches
setMatched = condense(setMatched);
}
// Add matches to results
push.apply(results, setMatched), outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1 && Sizzle.uniqueSort(results);
}
return outermost && (dirruns = dirrunsUnique, outermostContext = contextBackup), unmatched;
}, bySet ? markFunction(superMatcher) : superMatcher));
}
return cached;
}, // Deprecated
Expr.pseudos.nth = Expr.pseudos.eq, Expr.filters = setFilters.prototype = Expr.pseudos, Expr.setFilters = new setFilters(), // Initialize with the default document
setDocument(), // Override sizzle attribute retrieval
Sizzle.attr = jQuery.attr, jQuery.find = Sizzle, jQuery.expr = Sizzle.selectors, jQuery.expr[":"] = jQuery.expr.pseudos, jQuery.unique = Sizzle.uniqueSort, jQuery.text = Sizzle.getText, jQuery.isXMLDoc = Sizzle.isXML, jQuery.contains = Sizzle.contains;
}(window1);
var runtil = /Until$/, rparentsprev = /^(?:parents|prev(?:Until|All))/, isSimple = /^.[^:#\[\.,]*$/, rneedsContext = jQuery.expr.match.needsContext, // methods guaranteed to produce a unique set when starting from a unique set
guaranteedUnique = {
children: !0,
contents: !0,
next: !0,
prev: !0
};
function sibling(cur, dir) {
do cur = cur[dir];
while (cur && 1 !== cur.nodeType)
return cur;
}
// Implement the identical functionality for filter and not
function winnow(elements, qualifier, keep) {
if (// Can't pass null or undefined to indexOf in Firefox 4
// Set to 0 to skip string check
qualifier = qualifier || 0, jQuery.isFunction(qualifier)) return jQuery.grep(elements, function(elem, i) {
return !!qualifier.call(elem, i, elem) === keep;
});
if (qualifier.nodeType) return jQuery.grep(elements, function(elem) {
return elem === qualifier === keep;
});
if ("string" == typeof qualifier) {
var filtered = jQuery.grep(elements, function(elem) {
return 1 === elem.nodeType;
});
if (isSimple.test(qualifier)) return jQuery.filter(qualifier, filtered, !keep);
qualifier = jQuery.filter(qualifier, filtered);
}
return jQuery.grep(elements, function(elem) {
return jQuery.inArray(elem, qualifier) >= 0 === keep;
});
}
function createSafeFragment(document) {
var list = nodeNames.split("|"), safeFrag = document.createDocumentFragment();
if (safeFrag.createElement) for(; list.length;)safeFrag.createElement(list.pop());
return safeFrag;
}
jQuery.fn.extend({
find: function(selector) {
var i, ret, self, len = this.length;
if ("string" != typeof selector) return self = this, this.pushStack(jQuery(selector).filter(function() {
for(i = 0; i < len; i++)if (jQuery.contains(self[i], this)) return !0;
}));
for(i = 0, ret = []; i < len; i++)jQuery.find(selector, this[i], ret);
return(// Needed because $( selector, context ) becomes $( context ).find( selector )
(ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret)).selector = (this.selector ? this.selector + " " : "") + selector, ret);
},
has: function(target) {
var i, targets = jQuery(target, this), len = targets.length;
return this.filter(function() {
for(i = 0; i < len; i++)if (jQuery.contains(this, targets[i])) return !0;
});
},
not: function(selector) {
return this.pushStack(winnow(this, selector, !1));
},
filter: function(selector) {
return this.pushStack(winnow(this, selector, !0));
},
is: function(selector) {
return !!selector && ("string" == typeof selector ? // so $("p:first").is("p:last") won't return true for a doc with two "p".
rneedsContext.test(selector) ? jQuery(selector, this.context).index(this[0]) >= 0 : jQuery.filter(selector, this).length > 0 : this.filter(selector).length > 0);
},
closest: function(selectors, context) {
for(var cur, i = 0, l = this.length, ret = [], pos = rneedsContext.test(selectors) || "string" != typeof selectors ? jQuery(selectors, context || this.context) : 0; i < l; i++)for(cur = this[i]; cur && cur.ownerDocument && cur !== context && 11 !== cur.nodeType;){
if (pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors)) {
ret.push(cur);
break;
}
cur = cur.parentNode;
}
return this.pushStack(ret.length > 1 ? jQuery.unique(ret) : ret);
},
// Determine the position of an element within
// the matched set of elements
index: function(elem) {
return(// No argument, return index in parent
elem ? "string" == typeof elem ? jQuery.inArray(this[0], jQuery(elem)) : jQuery.inArray(// If it receives a jQuery object, the first element is used
elem.jquery ? elem[0] : elem, this) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1);
},
add: function(selector, context) {
var set = "string" == typeof selector ? jQuery(selector, context) : jQuery.makeArray(selector && selector.nodeType ? [
selector
] : selector), all = jQuery.merge(this.get(), set);
return this.pushStack(jQuery.unique(all));
},
addBack: function(selector) {
return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
}
}), jQuery.fn.andSelf = jQuery.fn.addBack, jQuery.each({
parent: function(elem) {
var parent = elem.parentNode;
return parent && 11 !== parent.nodeType ? parent : null;
},
parents: function(elem) {
return jQuery.dir(elem, "parentNode");
},
parentsUntil: function(elem, i, until) {
return jQuery.dir(elem, "parentNode", until);
},
next: function(elem) {
return sibling(elem, "nextSibling");
},
prev: function(elem) {
return sibling(elem, "previousSibling");
},
nextAll: function(elem) {
return jQuery.dir(elem, "nextSibling");
},
prevAll: function(elem) {
return jQuery.dir(elem, "previousSibling");
},
nextUntil: function(elem, i, until) {
return jQuery.dir(elem, "nextSibling", until);
},
prevUntil: function(elem, i, until) {
return jQuery.dir(elem, "previousSibling", until);
},
siblings: function(elem) {
return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
},
children: function(elem) {
return jQuery.sibling(elem.firstChild);
},
contents: function(elem) {
return jQuery.nodeName(elem, "iframe") ? elem.contentDocument || elem.contentWindow.document : jQuery.merge([], elem.childNodes);
}
}, function(name1, fn) {
jQuery.fn[name1] = function(until, selector) {
var ret = jQuery.map(this, fn, until);
return runtil.test(name1) || (selector = until), selector && "string" == typeof selector && (ret = jQuery.filter(selector, ret)), ret = this.length > 1 && !guaranteedUnique[name1] ? jQuery.unique(ret) : ret, this.length > 1 && rparentsprev.test(name1) && (ret = ret.reverse()), this.pushStack(ret);
};
}), jQuery.extend({
filter: function(expr, elems, not) {
return not && (expr = ":not(" + expr + ")"), 1 === elems.length ? jQuery.find.matchesSelector(elems[0], expr) ? [
elems[0]
] : [] : jQuery.find.matches(expr, elems);
},
dir: function(elem, dir, until) {
for(var matched = [], cur = elem[dir]; cur && 9 !== cur.nodeType && (undefined === until || 1 !== cur.nodeType || !jQuery(cur).is(until));)1 === cur.nodeType && matched.push(cur), cur = cur[dir];
return matched;
},
sibling: function(n, elem) {
for(var r = []; n; n = n.nextSibling)1 === n.nodeType && n !== elem && r.push(n);
return r;
}
});
var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, rnoshimcache = RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"), rleadingWhitespace = /^\s+/, rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, rtagName = /<([\w:]+)/, rtbody = /<tbody/i, rhtml = /<|&#?\w+;/, rnoInnerhtml = /<(?:script|style|link)/i, manipulation_rcheckableType = /^(?:checkbox|radio)$/i, // checked="checked" or checked
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptType = /^$|\/(?:java|ecma)script/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, // We have to close these tags to support XHTML (#13200)
wrapMap = {
option: [
1,
"<select multiple='multiple'>",
"</select>"
],
legend: [
1,
"<fieldset>",
"</fieldset>"
],
area: [
1,
"<map>",
"</map>"
],
param: [
1,
"<object>",
"</object>"
],
thead: [
1,
"<table>",
"</table>"
],
tr: [
2,
"<table><tbody>",
"</tbody></table>"
],
col: [
2,
"<table><tbody></tbody><colgroup>",
"</colgroup></table>"
],
td: [
3,
"<table><tbody><tr>",
"</tr></tbody></table>"
],
// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
// unless wrapped in a div with non-breaking characters in front of it.
_default: jQuery.support.htmlSerialize ? [
0,
"",
""
] : [
1,
"X<div>",
"</div>"
]
}, fragmentDiv = createSafeFragment(document).appendChild(document.createElement("div"));
// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript(elem) {
var attr = elem.getAttributeNode("type");
return elem.type = (attr && attr.specified) + "/" + elem.type, elem;
}
function restoreScript(elem) {
var match = rscriptTypeMasked.exec(elem.type);
return match ? elem.type = match[1] : elem.removeAttribute("type"), elem;
}
// Mark scripts as having already been evaluated
function setGlobalEval(elems, refElements) {
for(var elem, i = 0; null != (elem = elems[i]); i++)jQuery._data(elem, "globalEval", !refElements || jQuery._data(refElements[i], "globalEval"));
}
function cloneCopyEvent(src, dest) {
if (1 === dest.nodeType && jQuery.hasData(src)) {
var type, i, l, oldData = jQuery._data(src), curData = jQuery._data(dest, oldData), events = oldData.events;
if (events) for(type in delete curData.handle, curData.events = {}, events)for(i = 0, l = events[type].length; i < l; i++)jQuery.event.add(dest, type, events[type][i]);
// make the cloned public data object a copy from the original
curData.data && (curData.data = jQuery.extend({}, curData.data));
}
}
function getAll(context, tag) {
var elems, elem, i = 0, found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName(tag || "*") : typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll(tag || "*") : undefined;
if (!found) for(found = [], elems = context.childNodes || context; null != (elem = elems[i]); i++)!tag || jQuery.nodeName(elem, tag) ? found.push(elem) : jQuery.merge(found, getAll(elem, tag));
return undefined === tag || tag && jQuery.nodeName(context, tag) ? jQuery.merge([
context
], found) : found;
}
// Used in buildFragment, fixes the defaultChecked property
function fixDefaultChecked(elem) {
manipulation_rcheckableType.test(elem.type) && (elem.defaultChecked = elem.checked);
}
wrapMap.optgroup = wrapMap.option, wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead, wrapMap.th = wrapMap.td, jQuery.fn.extend({
text: function(value) {
return jQuery.access(this, function(value) {
return undefined === value ? jQuery.text(this) : this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(value));
}, null, value, arguments.length);
},
wrapAll: function(html) {
if (jQuery.isFunction(html)) return this.each(function(i) {
jQuery(this).wrapAll(html.call(this, i));
});
if (this[0]) {
// The elements to wrap the target around
var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(!0);
this[0].parentNode && wrap.insertBefore(this[0]), wrap.map(function() {
for(var elem = this; elem.firstChild && 1 === elem.firstChild.nodeType;)elem = elem.firstChild;
return elem;
}).append(this);
}
return this;
},
wrapInner: function(html) {
return jQuery.isFunction(html) ? this.each(function(i) {
jQuery(this).wrapInner(html.call(this, i));
}) : this.each(function() {
var self = jQuery(this), contents = self.contents();
contents.length ? contents.wrapAll(html) : self.append(html);
});
},
wrap: function(html) {
var isFunction = jQuery.isFunction(html);
return this.each(function(i) {
jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
});
},
unwrap: function() {
return this.parent().each(function() {
jQuery.nodeName(this, "body") || jQuery(this).replaceWith(this.childNodes);
}).end();
},
append: function() {
return this.domManip(arguments, !0, function(elem) {
(1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && this.appendChild(elem);
});
},
prepend: function() {
return this.domManip(arguments, !0, function(elem) {
(1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && this.insertBefore(elem, this.firstChild);
});
},
before: function() {
return this.domManip(arguments, !1, function(elem) {
this.parentNode && this.parentNode.insertBefore(elem, this);
});
},
after: function() {
return this.domManip(arguments, !1, function(elem) {
this.parentNode && this.parentNode.insertBefore(elem, this.nextSibling);
});
},
// keepData is for internal use only--do not document
remove: function(selector, keepData) {
for(var elem, i = 0; null != (elem = this[i]); i++)(!selector || jQuery.filter(selector, [
elem
]).length > 0) && (keepData || 1 !== elem.nodeType || jQuery.cleanData(getAll(elem)), elem.parentNode && (keepData && jQuery.contains(elem.ownerDocument, elem) && setGlobalEval(getAll(elem, "script")), elem.parentNode.removeChild(elem)));
return this;
},
empty: function() {
for(var elem, i = 0; null != (elem = this[i]); i++){
// Remove any remaining nodes
for(1 === elem.nodeType && jQuery.cleanData(getAll(elem, !1)); elem.firstChild;)elem.removeChild(elem.firstChild);
elem.options && jQuery.nodeName(elem, "select") && (elem.options.length = 0);
}
return this;
},
clone: function(dataAndEvents, deepDataAndEvents) {
return dataAndEvents = null != dataAndEvents && dataAndEvents, deepDataAndEvents = null == deepDataAndEvents ? dataAndEvents : deepDataAndEvents, this.map(function() {
return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
});
},
html: function(value) {
return jQuery.access(this, function(value) {
var elem = this[0] || {}, i = 0, l = this.length;
if (undefined === value) return 1 === elem.nodeType ? elem.innerHTML.replace(rinlinejQuery, "") : undefined;
// See if we can take a shortcut and just use innerHTML
if ("string" == typeof value && !rnoInnerhtml.test(value) && (jQuery.support.htmlSerialize || !rnoshimcache.test(value)) && (jQuery.support.leadingWhitespace || !rleadingWhitespace.test(value)) && !wrapMap[(rtagName.exec(value) || [
"",
""
])[1].toLowerCase()]) {
value = value.replace(rxhtmlTag, "<$1></$2>");
try {
for(; i < l; i++)// Remove element nodes and prevent memory leaks
elem = this[i] || {}, 1 === elem.nodeType && (jQuery.cleanData(getAll(elem, !1)), elem.innerHTML = value);
elem = 0;
// If using innerHTML throws an exception, use the fallback method
} catch (e) {}
}
elem && this.empty().append(value);
}, null, value, arguments.length);
},
replaceWith: function(value) {
return jQuery.isFunction(value) || "string" == typeof value || (value = jQuery(value).not(this).detach()), this.domManip([
value
], !0, function(elem) {
var next = this.nextSibling, parent = this.parentNode;
parent && (jQuery(this).remove(), parent.insertBefore(elem, next));
});
},
detach: function(selector) {
return this.remove(selector, !0);
},
domManip: function(args, table, callback) {
// Flatten any nested arrays
args = core_concat.apply([], args);
var elem, tag, first, node, hasScripts, scripts, doc, fragment, i = 0, l = this.length, set = this, iNoClone = l - 1, value = args[0], isFunction = jQuery.isFunction(value);
// We can't cloneNode fragments that contain checked, in WebKit
if (isFunction || !(l <= 1 || "string" != typeof value || jQuery.support.checkClone || !rchecked.test(value))) return this.each(function(index) {
var self = set.eq(index);
isFunction && (args[0] = value.call(this, index, table ? self.html() : undefined)), self.domManip(args, table, callback);
});
if (l && (first = (fragment = jQuery.buildFragment(args, this[0].ownerDocument, !1, this)).firstChild, 1 === fragment.childNodes.length && (fragment = first), first)) {
// Use the original fragment for the last item instead of the first because it can end up
// being emptied incorrectly in certain situations (#8070).
for(table = table && jQuery.nodeName(first, "tr"), hasScripts = (scripts = jQuery.map(getAll(fragment, "script"), disableScript)).length; i < l; i++){
node = fragment, i !== iNoClone && (node = jQuery.clone(node, !0, !0), hasScripts && jQuery.merge(scripts, getAll(node, "script"))), callback.call(table && jQuery.nodeName(this[i], "table") ? (elem = this[i], tag = "tbody", elem.getElementsByTagName(tag)[0] || elem.appendChild(elem.ownerDocument.createElement(tag))) : this[i], node, i);
}
if (hasScripts) // Evaluate executable scripts on first document insertion
for(doc = scripts[scripts.length - 1].ownerDocument, // Reenable scripts
jQuery.map(scripts, restoreScript), i = 0; i < hasScripts; i++)node = scripts[i], rscriptType.test(node.type || "") && !jQuery._data(node, "globalEval") && jQuery.contains(doc, node) && (node.src ? // Hope ajax is available...
jQuery.ajax({
url: node.src,
type: "GET",
dataType: "script",
async: !1,
global: !1,
throws: !0
}) : jQuery.globalEval((node.text || node.textContent || node.innerHTML || "").replace(rcleanScript, "")));
// Fix #11809: Avoid leaking memory
fragment = first = null;
}
return this;
}
}), jQuery.each({
appendTo: "append",
prependTo: "prepend",
insertBefore: "before",
insertAfter: "after",
replaceAll: "replaceWith"
}, function(name1, original) {
jQuery.fn[name1] = function(selector) {
for(var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; i <= last; i++)elems = i === last ? this : this.clone(!0), jQuery(insert[i])[original](elems), // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
core_push.apply(ret, elems.get());
return this.pushStack(ret);
};
}), jQuery.extend({
clone: function(elem, dataAndEvents, deepDataAndEvents) {
var destElements, node, clone, i, srcElements, inPage = jQuery.contains(elem.ownerDocument, elem);
if (jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test("<" + elem.nodeName + ">") ? clone = elem.cloneNode(!0) : (fragmentDiv.innerHTML = elem.outerHTML, fragmentDiv.removeChild(clone = fragmentDiv.firstChild)), (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && (1 === elem.nodeType || 11 === elem.nodeType) && !jQuery.isXMLDoc(elem)) // Fix all IE cloning issues
for(i = 0, // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
destElements = getAll(clone), srcElements = getAll(elem); null != (node = srcElements[i]); ++i)// Ensure that the destination node is not null; Fixes #9587
destElements[i] && function(src, dest) {
var nodeName, e, data;
// We do not need to do anything for non-Elements
if (1 === dest.nodeType) {
// IE6-8 copies events bound via attachEvent when using cloneNode.
if (nodeName = dest.nodeName.toLowerCase(), !jQuery.support.noCloneEvent && dest[jQuery.expando]) {
for(e in (data = jQuery._data(dest)).events)jQuery.removeEvent(dest, e, data.handle);
// Event data gets referenced instead of copied if the expando gets copied too
dest.removeAttribute(jQuery.expando);
}
"script" === nodeName && dest.text !== src.text ? (disableScript(dest).text = src.text, restoreScript(dest)) : "object" === nodeName ? (dest.parentNode && (dest.outerHTML = src.outerHTML), jQuery.support.html5Clone && src.innerHTML && !jQuery.trim(dest.innerHTML) && (dest.innerHTML = src.innerHTML)) : "input" === nodeName && manipulation_rcheckableType.test(src.type) ? (// IE6-8 fails to persist the checked state of a cloned checkbox
// or radio button. Worse, IE6-7 fail to give the cloned element
// a checked appearance if the defaultChecked value isn't also set
dest.defaultChecked = dest.checked = src.checked, dest.value !== src.value && (dest.value = src.value)) : "option" === nodeName ? dest.defaultSelected = dest.selected = src.defaultSelected : ("input" === nodeName || "textarea" === nodeName) && (dest.defaultValue = src.defaultValue);
}
}(node, destElements[i]);
// Copy the events from the original to the clone
if (dataAndEvents) {
if (deepDataAndEvents) for(i = 0, srcElements = srcElements || getAll(elem), destElements = destElements || getAll(clone); null != (node = srcElements[i]); i++)cloneCopyEvent(node, destElements[i]);
else cloneCopyEvent(elem, clone);
}
// Return the cloned set
return(// Preserve script evaluation history
(destElements = getAll(clone, "script")).length > 0 && setGlobalEval(destElements, !inPage && getAll(elem, "script")), destElements = srcElements = node = null, clone);
},
buildFragment: function(elems, context, scripts, selection) {
for(var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, // Ensure a safe fragment
safe = createSafeFragment(context), nodes = [], i = 0; i < l; i++)if ((elem = elems[i]) || 0 === elem) {
// Add nodes directly
if ("object" === jQuery.type(elem)) jQuery.merge(nodes, elem.nodeType ? [
elem
] : elem);
else if (rhtml.test(elem)) {
for(tmp = tmp || safe.appendChild(context.createElement("div")), wrap = wrapMap[// Deserialize a standard representation
tag = (rtagName.exec(elem) || [
"",
""
])[1].toLowerCase()] || wrapMap._default, tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, "<$1></$2>") + wrap[2], // Descend through wrappers to the right content
j = wrap[0]; j--;)tmp = tmp.lastChild;
// Remove IE's autoinserted <tbody> from table fragments
if (!jQuery.support.leadingWhitespace && rleadingWhitespace.test(elem) && nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0])), !jQuery.support.tbody) for(j = // String was a <table>, *may* have spurious <tbody>
(elem = "table" !== tag || rtbody.test(elem) ? "<table>" !== wrap[1] || rtbody.test(elem) ? 0 : tmp : tmp.firstChild) && elem.childNodes.length; j--;)jQuery.nodeName(tbody = elem.childNodes[j], "tbody") && !tbody.childNodes.length && elem.removeChild(tbody);
// Fix #12392 for oldIE
for(jQuery.merge(nodes, tmp.childNodes), // Fix #12392 for WebKit and IE > 9
tmp.textContent = ""; tmp.firstChild;)tmp.removeChild(tmp.firstChild);
// Remember the top-level container for proper cleanup
tmp = safe.lastChild;
} else nodes.push(context.createTextNode(elem));
}
for(tmp && safe.removeChild(tmp), jQuery.support.appendChecked || jQuery.grep(getAll(nodes, "input"), fixDefaultChecked), i = 0; elem = nodes[i++];)// #4087 - If origin and destination elements are the same, and this is
// that element, do not do anything
if ((!selection || -1 === jQuery.inArray(elem, selection)) && (contains = jQuery.contains(elem.ownerDocument, elem), // Append to fragment
tmp = getAll(safe.appendChild(elem), "script"), contains && setGlobalEval(tmp), scripts)) for(j = 0; elem = tmp[j++];)rscriptType.test(elem.type || "") && scripts.push(elem);
return tmp = null, safe;
},
cleanData: function(elems, /* internal */ acceptData) {
for(var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, deleteExpando = jQuery.support.deleteExpando, special = jQuery.event.special; null != (elem = elems[i]); i++)if ((acceptData || jQuery.acceptData(elem)) && (data = (id = elem[internalKey]) && cache[id])) {
if (data.events) for(type in data.events)special[type] ? jQuery.event.remove(elem, type) : jQuery.removeEvent(elem, type, data.handle);
// Remove cache only if it was not already removed by jQuery.event.remove
cache[id] && (delete cache[id], deleteExpando ? delete elem[internalKey] : typeof elem.removeAttribute !== core_strundefined ? elem.removeAttribute(internalKey) : elem[internalKey] = null, core_deletedIds.push(id));
}
}
});
var iframe, getStyles, curCSS, ralpha = /alpha\([^)]*\)/i, ropacity = /opacity\s*=\s*([^)]*)/, rposition = /^(top|right|bottom|left)$/, // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
rdisplayswap = /^(none|table(?!-c[ea]).+)/, rmargin = /^margin/, rnumsplit = RegExp("^(" + core_pnum + ")(.*)$", "i"), rnumnonpx = RegExp("^(" + core_pnum + ")(?!px)[a-z%]+$", "i"), rrelNum = RegExp("^([+-])=(" + core_pnum + ")", "i"), elemdisplay = {
BODY: "block"
}, cssShow = {
position: "absolute",
visibility: "hidden",
display: "block"
}, cssNormalTransform = {
letterSpacing: 0,
fontWeight: 400
}, cssExpand = [
"Top",
"Right",
"Bottom",
"Left"
], cssPrefixes = [
"Webkit",
"O",
"Moz",
"ms"
];
// return a css property mapped to a potentially vendor prefixed property
function vendorPropName(style, name1) {
// shortcut for names that are not vendor prefixed
if (name1 in style) return name1;
for(// check for vendor prefixed names
var capName = name1.charAt(0).toUpperCase() + name1.slice(1), origName = name1, i = cssPrefixes.length; i--;)if ((name1 = cssPrefixes[i] + capName) in style) return name1;
return origName;
}
function isHidden(elem, el) {
return(// isHidden might be called from jQuery#filter function;
// in that case, element will be second argument
elem = el || elem, "none" === jQuery.css(elem, "display") || !jQuery.contains(elem.ownerDocument, elem));
}
function showHide(elements, show) {
for(var display, elem, hidden, values = [], index = 0, length = elements.length; index < length; index++)(elem = elements[index]).style && (values[index] = jQuery._data(elem, "olddisplay"), display = elem.style.display, show ? (values[index] || "none" !== display || (elem.style.display = ""), "" === elem.style.display && isHidden(elem) && (values[index] = jQuery._data(elem, "olddisplay", css_defaultDisplay(elem.nodeName)))) : values[index] || (hidden = isHidden(elem), (display && "none" !== display || !hidden) && jQuery._data(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display"))));
// Set the display of most of the elements in a second loop
// to avoid the constant reflow
for(index = 0; index < length; index++)(elem = elements[index]).style && (show && "none" !== elem.style.display && "" !== elem.style.display || (elem.style.display = show ? values[index] || "" : "none"));
return elements;
}
function setPositiveNumber(elem, value, subtract) {
var matches = rnumsplit.exec(value);
return matches ? Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px") : value;
}
function augmentWidthOrHeight(elem, name1, extra, isBorderBox, styles) {
for(var i = extra === (isBorderBox ? "border" : "content") ? 4 : +("width" === name1), val = 0; i < 4; i += 2)"margin" === extra && (val += jQuery.css(elem, extra + cssExpand[i], !0, styles)), isBorderBox ? ("content" === extra && (val -= jQuery.css(elem, "padding" + cssExpand[i], !0, styles)), "margin" !== extra && (val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", !0, styles))) : (// at this point, extra isn't content, so add padding
val += jQuery.css(elem, "padding" + cssExpand[i], !0, styles), "padding" !== extra && (val += jQuery.css(elem, "border" + cssExpand[i] + "Width", !0, styles)));
return val;
}
function getWidthOrHeight(elem, name1, extra) {
// Start with offset property, which is equivalent to the border-box value
var valueIsBorderBox = !0, val = "width" === name1 ? elem.offsetWidth : elem.offsetHeight, styles = getStyles(elem), isBorderBox = jQuery.support.boxSizing && "border-box" === jQuery.css(elem, "boxSizing", !1, styles);
// some non-html elements return undefined for offsetWidth, so check for null/undefined
// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
if (val <= 0 || null == val) {
// Computed unit is not pixels. Stop here and return.
if ((// Fall back to computed then uncomputed css if necessary
(val = curCSS(elem, name1, styles)) < 0 || null == val) && (val = elem.style[name1]), rnumnonpx.test(val)) return val;
// we need the check for style in case a browser which returns unreliable values
// for getComputedStyle silently falls back to the reliable elem.style
valueIsBorderBox = isBorderBox && (jQuery.support.boxSizingReliable || val === elem.style[name1]), // Normalize "", auto, and prepare for extra
val = parseFloat(val) || 0;
}
// use the active box-sizing model to add/subtract irrelevant styles
return val + augmentWidthOrHeight(elem, name1, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles) + "px";
}
// Try to determine the default display value of an element
function css_defaultDisplay(nodeName) {
var doc = document, display = elemdisplay[nodeName];
return display || ("none" !== (display = actualDisplay(nodeName, doc)) && display || (// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
(doc = (// Use the already-created iframe if possible
(iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>").css("cssText", "display:block !important")).appendTo(doc.documentElement))[0].contentWindow || iframe[0].contentDocument).document).write("<!doctype html><html><body>"), doc.close(), display = actualDisplay(nodeName, doc), iframe.detach()), // Store the correct default display
elemdisplay[nodeName] = display), display;
}
// Called ONLY from within css_defaultDisplay
function actualDisplay(name1, doc) {
var elem = jQuery(doc.createElement(name1)).appendTo(doc.body), display = jQuery.css(elem[0], "display");
return elem.remove(), display;
}
jQuery.fn.extend({
css: function(name1, value) {
return jQuery.access(this, function(elem, name1, value) {
var len, styles, map = {}, i = 0;
if (jQuery.isArray(name1)) {
for(styles = getStyles(elem), len = name1.length; i < len; i++)map[name1[i]] = jQuery.css(elem, name1[i], !1, styles);
return map;
}
return undefined !== value ? jQuery.style(elem, name1, value) : jQuery.css(elem, name1);
}, name1, value, arguments.length > 1);
},
show: function() {
return showHide(this, !0);
},
hide: function() {
return showHide(this);
},
toggle: function(state) {
var bool = "boolean" == typeof state;
return this.each(function() {
(bool ? state : isHidden(this)) ? jQuery(this).show() : jQuery(this).hide();
});
}
}), jQuery.extend({
// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
opacity: {
get: function(elem, computed) {
if (computed) {
// We should always get a number back from opacity
var ret = curCSS(elem, "opacity");
return "" === ret ? "1" : ret;
}
}
}
},
// Exclude the following css properties to add px
cssNumber: {
columnCount: !0,
fillOpacity: !0,
fontWeight: !0,
lineHeight: !0,
opacity: !0,
orphans: !0,
widows: !0,
zIndex: !0,
zoom: !0
},
// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {
// normalize float css property
float: jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
},
// Get and set the style property on a DOM Node
style: function(elem, name1, value, extra) {
// Don't set styles on text and comment nodes
if (elem && 3 !== elem.nodeType && 8 !== elem.nodeType && elem.style) {
// Make sure that we're working with the right name
var ret, type, hooks, origName = jQuery.camelCase(name1), style = elem.style;
// Check if we're setting a value
if (name1 = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName)), // gets hook for the prefixed version
// followed by the unprefixed version
hooks = jQuery.cssHooks[name1] || jQuery.cssHooks[origName], undefined === value) return(// If a hook was provided get the non-computed value from there
hooks && "get" in hooks && (ret = hooks.get(elem, !1, extra)) !== undefined ? ret : style[name1]);
// Make sure that NaN and null values aren't set. See: #7116
if ("string" == (type = typeof value) && (ret = rrelNum.exec(value)) && (value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name1)), // Fixes bug #9237
type = "number"), !(null == value || "number" === type && isNaN(value))) // If a hook was provided, use that value, otherwise just set the specified value
{
if ("number" !== type || jQuery.cssNumber[origName] || (value += "px"), jQuery.support.clearCloneStyle || "" !== value || 0 !== name1.indexOf("background") || (style[name1] = "inherit"), !hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
// Fixes bug #5509
try {
style[name1] = value;
} catch (e) {}
}
}
},
css: function(elem, name1, extra, styles) {
var num, val, hooks, origName = jQuery.camelCase(name1);
return(// Return, converting to number if forced or a qualifier was provided and val looks numeric
(// Make sure that we're working with the right name
name1 = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName)), // gets hook for the prefixed version
// followed by the unprefixed version
(hooks = jQuery.cssHooks[name1] || jQuery.cssHooks[origName]) && "get" in hooks && (val = hooks.get(elem, !0, extra)), undefined === val && (val = curCSS(elem, name1, styles)), "normal" === val && name1 in cssNormalTransform && (val = cssNormalTransform[name1]), "" === extra || extra) ? (num = parseFloat(val), !0 === extra || jQuery.isNumeric(num) ? num || 0 : val) : val);
},
// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function(elem, options, callback, args) {
var ret, name1, old = {};
// Remember the old values, and insert the new ones
for(name1 in options)old[name1] = elem.style[name1], elem.style[name1] = options[name1];
// Revert the old values
for(name1 in ret = callback.apply(elem, args || []), options)elem.style[name1] = old[name1];
return ret;
}
}), window1.getComputedStyle ? (getStyles = function(elem) {
return window1.getComputedStyle(elem, null);
}, curCSS = function(elem, name1, _computed) {
var width, minWidth, maxWidth, computed = _computed || getStyles(elem), // getPropertyValue is only needed for .css('filter') in IE9, see #12537
ret = computed ? computed.getPropertyValue(name1) || computed[name1] : undefined, style = elem.style;
return computed && ("" !== ret || jQuery.contains(elem.ownerDocument, elem) || (ret = jQuery.style(elem, name1)), rnumnonpx.test(ret) && rmargin.test(name1) && (// Remember the original values
width = style.width, minWidth = style.minWidth, maxWidth = style.maxWidth, // Put in the new values to get a computed value out
style.minWidth = style.maxWidth = style.width = ret, ret = computed.width, // Revert the changed values
style.width = width, style.minWidth = minWidth, style.maxWidth = maxWidth)), ret;
}) : document.documentElement.currentStyle && (getStyles = function(elem) {
return elem.currentStyle;
}, curCSS = function(elem, name1, _computed) {
var left, rs, rsLeft, computed = _computed || getStyles(elem), ret = computed ? computed[name1] : undefined, style = elem.style;
return null == ret && style && style[name1] && (ret = style[name1]), rnumnonpx.test(ret) && !rposition.test(name1) && (// Remember the original values
left = style.left, (rsLeft = (rs = elem.runtimeStyle) && rs.left) && (rs.left = elem.currentStyle.left), style.left = "fontSize" === name1 ? "1em" : ret, ret = style.pixelLeft + "px", // Revert the changed values
style.left = left, rsLeft && (rs.left = rsLeft)), "" === ret ? "auto" : ret;
}), jQuery.each([
"height",
"width"
], function(i, name1) {
jQuery.cssHooks[name1] = {
get: function(elem, computed, extra) {
if (computed) // certain elements can have dimension info if we invisibly show them
// however, it must have a current display style that would benefit from this
return 0 === elem.offsetWidth && rdisplayswap.test(jQuery.css(elem, "display")) ? jQuery.swap(elem, cssShow, function() {
return getWidthOrHeight(elem, name1, extra);
}) : getWidthOrHeight(elem, name1, extra);
},
set: function(elem, value, extra) {
var styles = extra && getStyles(elem);
return setPositiveNumber(elem, value, extra ? augmentWidthOrHeight(elem, name1, extra, jQuery.support.boxSizing && "border-box" === jQuery.css(elem, "boxSizing", !1, styles), styles) : 0);
}
};
}), jQuery.support.opacity || (jQuery.cssHooks.opacity = {
get: function(elem, computed) {
// IE uses filters for opacity
return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ? 0.01 * parseFloat(RegExp.$1) + "" : computed ? "1" : "";
},
set: function(elem, value) {
var style = elem.style, currentStyle = elem.currentStyle, opacity = jQuery.isNumeric(value) ? "alpha(opacity=" + 100 * value + ")" : "", filter = currentStyle && currentStyle.filter || style.filter || "";
// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
// if value === "", then remove inline opacity #12685
// IE has trouble with opacity if it does not have layout
// Force it by setting the zoom level
style.zoom = 1, (!(value >= 1) && "" !== value || "" !== jQuery.trim(filter.replace(ralpha, "")) || !style.removeAttribute || (// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
// if "filter:" is present at all, clearType is disabled, we want to avoid this
// style.removeAttribute is IE Only, but so apparently is this code path...
style.removeAttribute("filter"), "" !== value && (!currentStyle || currentStyle.filter))) && // otherwise, set new filter values
(style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + opacity);
}
}), // These hooks cannot be added until DOM ready because the support test
// for it is not run until after DOM ready
jQuery(function() {
jQuery.support.reliableMarginRight || (jQuery.cssHooks.marginRight = {
get: function(elem, computed) {
if (computed) // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
// Work around by temporarily setting element display to inline-block
return jQuery.swap(elem, {
display: "inline-block"
}, curCSS, [
elem,
"marginRight"
]);
}
}), !jQuery.support.pixelPosition && jQuery.fn.position && jQuery.each([
"top",
"left"
], function(i, prop) {
jQuery.cssHooks[prop] = {
get: function(elem, computed) {
if (computed) // if curCSS returns percentage, fallback to offset
return computed = curCSS(elem, prop), rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
}
};
});
}), jQuery.expr && jQuery.expr.filters && (jQuery.expr.filters.hidden = function(elem) {
// Support: Opera <= 12.12
// Opera reports offsetWidths and offsetHeights less than zero on some elements
return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 || !jQuery.support.reliableHiddenOffsets && "none" === (elem.style && elem.style.display || jQuery.css(elem, "display"));
}, jQuery.expr.filters.visible = function(elem) {
return !jQuery.expr.filters.hidden(elem);
}), // These hooks are used by animate to expand properties
jQuery.each({
margin: "",
padding: "",
border: "Width"
}, function(prefix, suffix) {
jQuery.cssHooks[prefix + suffix] = {
expand: function(value) {
for(var i = 0, expanded = {}, // assumes a single number if not a string
parts = "string" == typeof value ? value.split(" ") : [
value
]; i < 4; i++)expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
return expanded;
}
}, rmargin.test(prefix) || (jQuery.cssHooks[prefix + suffix].set = setPositiveNumber);
});
var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;
jQuery.fn.extend({
serialize: function() {
return jQuery.param(this.serializeArray());
},
serializeArray: function() {
return this.map(function() {
// Can add propHook for "elements" to filter or add form elements
var elements = jQuery.prop(this, "elements");
return elements ? jQuery.makeArray(elements) : this;
}).filter(function() {
var type = this.type;
// Use .is(":disabled") so that fieldset[disabled] works
return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !manipulation_rcheckableType.test(type));
}).map(function(i, elem) {
var val = jQuery(this).val();
return null == val ? null : jQuery.isArray(val) ? jQuery.map(val, function(val) {
return {
name: elem.name,
value: val.replace(rCRLF, "\r\n")
};
}) : {
name: elem.name,
value: val.replace(rCRLF, "\r\n")
};
}).get();
}
}), //Serialize an array of form elements or a set of
//key/values into a query string
jQuery.param = function(a, traditional) {
var prefix, s = [], add = function(key, value) {
// If value is a function, invoke it and return its value
value = jQuery.isFunction(value) ? value() : null == value ? "" : value, s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
};
// If an array was passed in, assume that it is an array of form elements.
if (undefined === traditional && (traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional), jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) // Serialize the form elements
jQuery.each(a, function() {
add(this.name, this.value);
});
else // If traditional, encode the "old" way (the way 1.3.2 or older
// did it), otherwise encode params recursively.
for(prefix in a)(function buildParams(prefix, obj, traditional, add) {
var name1;
if (jQuery.isArray(obj)) // Serialize array item.
jQuery.each(obj, function(i, v) {
traditional || rbracket.test(prefix) ? // Treat each array item as a scalar.
add(prefix, v) : // Item is non-scalar (array or object), encode its numeric index.
buildParams(prefix + "[" + ("object" == typeof v ? i : "") + "]", v, traditional, add);
});
else if (traditional || "object" !== jQuery.type(obj)) // Serialize scalar item.
add(prefix, obj);
else // Serialize object item.
for(name1 in obj)buildParams(prefix + "[" + name1 + "]", obj[name1], traditional, add);
})(prefix, a[prefix], traditional, add);
// Return the resulting serialization
return s.join("&").replace(r20, "+");
}, jQuery.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "), function(i, name1) {
// Handle event binding
jQuery.fn[name1] = function(data, fn) {
return arguments.length > 0 ? this.on(name1, null, data, fn) : this.trigger(name1);
};
}), jQuery.fn.hover = function(fnOver, fnOut) {
return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
};
var ajaxLocParts, ajaxLocation, ajax_nonce = jQuery.now(), ajax_rquery = /\?/, rhash = /#.*$/, rts = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/gm, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/, // Keep a copy of the old load method
_load = jQuery.fn.load, /* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
* - BEFORE asking for a transport
* - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/ prefilters = {}, /* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/ transports = {}, // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat("*");
// #8138, IE may throw an exception when accessing
// a field from window.location if document.domain has been set
try {
ajaxLocation = location.href;
} catch (e) {
// Use the href attribute of an A element
// since IE will modify it given document.location
(ajaxLocation = document.createElement("a")).href = "", ajaxLocation = ajaxLocation.href;
}
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports(structure) {
// dataTypeExpression is optional and defaults to "*"
return function(dataTypeExpression, func) {
"string" != typeof dataTypeExpression && (func = dataTypeExpression, dataTypeExpression = "*");
var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(core_rnotwhite) || [];
if (jQuery.isFunction(func)) // For each dataType in the dataTypeExpression
for(; dataType = dataTypes[i++];)// Prepend if requested
"+" === dataType[0] ? (structure[dataType = dataType.slice(1) || "*"] = structure[dataType] || []).unshift(func) : (structure[dataType] = structure[dataType] || []).push(func);
};
}
// Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
var inspected = {}, seekingTransport = structure === transports;
function inspect(dataType) {
var selected;
return inspected[dataType] = !0, jQuery.each(structure[dataType] || [], function(_, prefilterOrFactory) {
var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
return "string" != typeof dataTypeOrTransport || seekingTransport || inspected[dataTypeOrTransport] ? seekingTransport ? !(selected = dataTypeOrTransport) : void 0 : (options.dataTypes.unshift(dataTypeOrTransport), inspect(dataTypeOrTransport), !1);
}), selected;
}
return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
}
// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
function ajaxExtend(target, src) {
var deep, key, flatOptions = jQuery.ajaxSettings.flatOptions || {};
for(key in src)src[key] !== undefined && ((flatOptions[key] ? target : deep || (deep = {}))[key] = src[key]);
return deep && jQuery.extend(!0, target, deep), target;
}
// Segment location into parts
ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [], jQuery.fn.load = function(url, params, callback) {
if ("string" != typeof url && _load) return _load.apply(this, arguments);
var selector, response, type, self = this, off = url.indexOf(" ");
return off >= 0 && (selector = url.slice(off, url.length), url = url.slice(0, off)), jQuery.isFunction(params) ? (// We assume that it's the callback
callback = params, params = undefined) : params && "object" == typeof params && (type = "POST"), self.length > 0 && jQuery.ajax({
url: url,
// if "type" variable is undefined, then "GET" method will be used
type: type,
dataType: "html",
data: params
}).done(function(responseText) {
// Save response for use in complete callback
response = arguments, self.html(selector ? // Exclude scripts to avoid IE 'Permission Denied' errors
jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
}).complete(callback && function(jqXHR, status) {
self.each(callback, response || [
jqXHR.responseText,
status,
jqXHR
]);
}), this;
}, // Attach a bunch of functions for handling common AJAX events
jQuery.each([
"ajaxStart",
"ajaxStop",
"ajaxComplete",
"ajaxError",
"ajaxSuccess",
"ajaxSend"
], function(i, type) {
jQuery.fn[type] = function(fn) {
return this.on(type, fn);
};
}), jQuery.each([
"get",
"post"
], function(i, method) {
jQuery[method] = function(url, data, callback, type) {
return jQuery.isFunction(data) && (type = type || callback, callback = data, data = undefined), jQuery.ajax({
url: url,
type: method,
dataType: type,
data: data,
success: callback
});
};
}), jQuery.extend({
// Counter for holding the number of active queries
active: 0,
// Last-Modified header cache for next request
lastModified: {},
etag: {},
ajaxSettings: {
url: ajaxLocation,
type: "GET",
isLocal: /^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(ajaxLocParts[1]),
global: !0,
processData: !0,
async: !0,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/ accepts: {
"*": allTypes,
text: "text/plain",
html: "text/html",
xml: "application/xml, text/xml",
json: "application/json, text/javascript"
},
contents: {
xml: /xml/,
html: /html/,
json: /json/
},
responseFields: {
xml: "responseXML",
text: "responseText"
},
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
converters: {
// Convert anything to text
"* text": window1.String,
// Text to html (true = no transformation)
"text html": !0,
// Evaluate text as a json expression
"text json": jQuery.parseJSON,
// Parse text as xml
"text xml": jQuery.parseXML
},
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
flatOptions: {
url: !0,
context: !0
}
},
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function(target, settings) {
return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
},
ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
ajaxTransport: addToPrefiltersOrTransports(transports),
// Main method
ajax: function(url, options) {
"object" == typeof url && (options = url, url = undefined), // Force options to be an object
options = options || {};
var parts, // Loop variable
i, // URL without anti-cache param
cacheURL, // Response headers as string
responseHeadersString, // timeout handle
timeoutTimer, // To know if global events are to be dispatched
fireGlobals, transport, // Response headers
responseHeaders, // Create the final options object
s = jQuery.ajaxSetup({}, options), // Callbacks context
callbackContext = s.context || s, // Context for global events is callbackContext if it is a DOM node or jQuery collection
globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event, // Deferreds
deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks("once memory"), // Status-dependent callbacks
statusCode = s.statusCode || {}, // Headers (they are sent all at once)
requestHeaders = {}, requestHeadersNames = {}, // The jqXHR state
state = 0, // Default abort message
strAbort = "canceled", // Fake xhr
jqXHR = {
readyState: 0,
// Builds headers hashtable if needed
getResponseHeader: function(key) {
var match;
if (2 === state) {
if (!responseHeaders) for(responseHeaders = {}; match = rheaders.exec(responseHeadersString);)responseHeaders[match[1].toLowerCase()] = match[2];
match = responseHeaders[key.toLowerCase()];
}
return null == match ? null : match;
},
// Raw string
getAllResponseHeaders: function() {
return 2 === state ? responseHeadersString : null;
},
// Caches the header
setRequestHeader: function(name1, value) {
var lname = name1.toLowerCase();
return state || (requestHeaders[name1 = requestHeadersNames[lname] = requestHeadersNames[lname] || name1] = value), this;
},
// Overrides response content-type header
overrideMimeType: function(type) {
return state || (s.mimeType = type), this;
},
// Status-dependent callbacks
statusCode: function(map) {
var code;
if (map) {
if (state < 2) for(code in map)// Lazy-add the new callback in a way that preserves old ones
statusCode[code] = [
statusCode[code],
map[code]
];
else // Execute the appropriate callbacks
jqXHR.always(map[jqXHR.status]);
}
return this;
},
// Cancel the request
abort: function(statusText) {
var finalText = statusText || strAbort;
return transport && transport.abort(finalText), done(0, finalText), this;
}
};
// If request was aborted inside a prefilter, stop there
if (// Attach deferreds
deferred.promise(jqXHR).complete = completeDeferred.add, jqXHR.success = jqXHR.done, jqXHR.error = jqXHR.fail, // Remove hash character (#7531: and string promotion)
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
// Handle falsy url in the settings object (#10093: consistency with old signature)
// We also use the url parameter if available
s.url = ((url || s.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//"), // Alias method option to type as per ticket #12004
s.type = options.method || options.type || s.method || s.type, // Extract dataTypes list
s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(core_rnotwhite) || [
""
], null == s.crossDomain && (parts = rurl.exec(s.url.toLowerCase()), s.crossDomain = !!(parts && (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] || (parts[3] || ("http:" === parts[1] ? 80 : 443)) != (ajaxLocParts[3] || ("http:" === ajaxLocParts[1] ? 80 : 443))))), s.data && s.processData && "string" != typeof s.data && (s.data = jQuery.param(s.data, s.traditional)), // Apply prefilters
inspectPrefiltersOrTransports(prefilters, s, options, jqXHR), 2 === state) return jqXHR;
// Check for headers option
for(i in // We can fire global events as of now if asked to
(fireGlobals = s.global) && 0 == jQuery.active++ && jQuery.event.trigger("ajaxStart"), // Uppercase the type
s.type = s.type.toUpperCase(), // Determine if request has content
s.hasContent = !rnoContent.test(s.type), // Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
cacheURL = s.url, s.hasContent || (s.data && (cacheURL = s.url += (ajax_rquery.test(cacheURL) ? "&" : "?") + s.data, // #9682: remove data so that it's not used in an eventual retry
delete s.data), !1 === s.cache && (s.url = rts.test(cacheURL) ? cacheURL.replace(rts, "$1_=" + ajax_nonce++) : cacheURL + (ajax_rquery.test(cacheURL) ? "&" : "?") + "_=" + ajax_nonce++)), s.ifModified && (jQuery.lastModified[cacheURL] && jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]), jQuery.etag[cacheURL] && jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL])), (s.data && s.hasContent && !1 !== s.contentType || options.contentType) && jqXHR.setRequestHeader("Content-Type", s.contentType), // Set the Accepts header for the server, depending on the dataType
jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + ("*" !== s.dataTypes[0] ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]), s.headers)jqXHR.setRequestHeader(i, s.headers[i]);
// Allow custom headers/mimetypes and early abort
if (s.beforeSend && (!1 === s.beforeSend.call(callbackContext, jqXHR, s) || 2 === state)) // Abort if not done already and return
return jqXHR.abort();
// Install callbacks on deferreds
for(i in // aborting is no longer a cancellation
strAbort = "abort", {
success: 1,
error: 1,
complete: 1
})jqXHR[i](s[i]);
// If no transport, we auto-abort
if (// Get transport
transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR)) {
jqXHR.readyState = 1, fireGlobals && globalEventContext.trigger("ajaxSend", [
jqXHR,
s
]), s.async && s.timeout > 0 && (timeoutTimer = setTimeout(function() {
jqXHR.abort("timeout");
}, s.timeout));
try {
state = 1, transport.send(requestHeaders, done);
} catch (e) {
// Propagate exception as error if not done
if (state < 2) done(-1, e);
else throw e;
}
} else done(-1, "No Transport");
// Callback for when everything is done
function done(status, nativeStatusText, responses, headers) {
var isSuccess, success, error, response, modified, statusText = nativeStatusText;
// Called once
2 !== state && (// State is "done" now
state = 2, timeoutTimer && clearTimeout(timeoutTimer), // Dereference transport for early garbage collection
// (no matter how long the jqXHR object will be used)
transport = undefined, // Cache response headers
responseHeadersString = headers || "", // Set readyState
jqXHR.readyState = 4 * (status > 0), responses && (response = /* Handles responses to an ajax request:
* - sets all responseXXX fields accordingly
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/ function(s, jqXHR, responses) {
var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes, responseFields = s.responseFields;
// Fill responseXXX fields
for(type in responseFields)type in responses && (jqXHR[responseFields[type]] = responses[type]);
// Remove auto dataType and get content-type in the process
for(; "*" === dataTypes[0];)dataTypes.shift(), undefined === ct && (ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"));
// Check if we're dealing with a known content-type
if (ct) {
for(type in contents)if (contents[type] && contents[type].test(ct)) {
dataTypes.unshift(type);
break;
}
}
// Check to see if we have a response for the expected dataType
if (dataTypes[0] in responses) finalDataType = dataTypes[0];
else {
// Try convertible dataTypes
for(type in responses){
if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
finalDataType = type;
break;
}
firstDataType || (firstDataType = type);
}
// Or just use first one
finalDataType = finalDataType || firstDataType;
}
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if (finalDataType) return finalDataType !== dataTypes[0] && dataTypes.unshift(finalDataType), responses[finalDataType];
}(s, jqXHR, responses)), status >= 200 && status < 300 || 304 === status ? (s.ifModified && ((modified = jqXHR.getResponseHeader("Last-Modified")) && (jQuery.lastModified[cacheURL] = modified), (modified = jqXHR.getResponseHeader("etag")) && (jQuery.etag[cacheURL] = modified)), 204 === status ? (isSuccess = !0, statusText = "nocontent") : 304 === status ? (isSuccess = !0, statusText = "notmodified") : (statusText = (isSuccess = // Chain conversions given the request and the original response
function(s, response) {
var conv2, current, conv, tmp, converters = {}, i = 0, // Work with a copy of dataTypes in case we need to modify it for conversion
dataTypes = s.dataTypes.slice(), prev = dataTypes[0];
// Create converters map with lowercased keys
if (s.dataFilter && (response = s.dataFilter(response, s.dataType)), dataTypes[1]) for(conv in s.converters)converters[conv.toLowerCase()] = s.converters[conv];
// Convert to each sequential dataType, tolerating list modification
for(; current = dataTypes[++i];)// There's only work to do if current dataType is non-auto
if ("*" !== current) {
// Convert response if prev dataType is non-auto and differs from current
if ("*" !== prev && prev !== current) {
// If none found, seek a pair
if (!// Seek a direct converter
(conv = converters[prev + " " + current] || converters["* " + current])) {
for(conv2 in converters)if (// If conv2 outputs current
(tmp = conv2.split(" "))[1] === current && // If prev can be converted to accepted input
(conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]])) {
// Condense equivalence converters
!0 === conv ? conv = converters[conv2] : !0 !== converters[conv2] && (current = tmp[0], dataTypes.splice(i--, 0, current));
break;
}
}
// Apply converter (if not an equivalence)
if (!0 !== conv) {
// Unless errors are allowed to bubble, catch and return them
if (conv && s.throws) response = conv(response);
else try {
response = conv(response);
} catch (e) {
return {
state: "parsererror",
error: conv ? e : "No conversion from " + prev + " to " + current
};
}
}
}
// Update prev for next iteration
prev = current;
}
return {
state: "success",
data: response
};
}(s, response)).state, success = isSuccess.data, isSuccess = !(error = isSuccess.error))) : (// We extract error from statusText
// then normalize statusText and status for non-aborts
error = statusText, (status || !statusText) && (statusText = "error", status < 0 && (status = 0))), // Set data for the fake xhr object
jqXHR.status = status, jqXHR.statusText = (nativeStatusText || statusText) + "", isSuccess ? deferred.resolveWith(callbackContext, [
success,
statusText,
jqXHR
]) : deferred.rejectWith(callbackContext, [
jqXHR,
statusText,
error
]), // Status-dependent callbacks
jqXHR.statusCode(statusCode), statusCode = undefined, fireGlobals && globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [
jqXHR,
s,
isSuccess ? success : error
]), // Complete
completeDeferred.fireWith(callbackContext, [
jqXHR,
statusText
]), !fireGlobals || (globalEventContext.trigger("ajaxComplete", [
jqXHR,
s
]), --jQuery.active || jQuery.event.trigger("ajaxStop")));
}
return jqXHR;
},
getScript: function(url, callback) {
return jQuery.get(url, undefined, callback, "script");
},
getJSON: function(url, data, callback) {
return jQuery.get(url, data, callback, "json");
}
}), // Install script dataType
jQuery.ajaxSetup({
accepts: {
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
},
contents: {
script: /(?:java|ecma)script/
},
converters: {
"text script": function(text) {
return jQuery.globalEval(text), text;
}
}
}), // Handle cache's special case and global
jQuery.ajaxPrefilter("script", function(s) {
s.cache === undefined && (s.cache = !1), s.crossDomain && (s.type = "GET", s.global = !1);
}), // Bind script tag hack transport
jQuery.ajaxTransport("script", function(s) {
// This transport only deals with cross domain requests
if (s.crossDomain) {
var script, head = document.head || jQuery("head")[0] || document.documentElement;
return {
send: function(_, callback) {
(script = document.createElement("script")).async = !0, s.scriptCharset && (script.charset = s.scriptCharset), script.src = s.url, // Attach handlers for all browsers
script.onload = script.onreadystatechange = function(_, isAbort) {
(isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) && (// Handle memory leak in IE
script.onload = script.onreadystatechange = null, script.parentNode && script.parentNode.removeChild(script), // Dereference the script
script = null, isAbort || callback(200, "success"));
}, // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
// Use native DOM manipulation to avoid our domManip AJAX trickery
head.insertBefore(script, head.firstChild);
},
abort: function() {
script && script.onload(undefined, !0);
}
};
}
});
var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;
// Default jsonp settings
jQuery.ajaxSetup({
jsonp: "callback",
jsonpCallback: function() {
var callback = oldCallbacks.pop() || jQuery.expando + "_" + ajax_nonce++;
return this[callback] = !0, callback;
}
}), // Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) {
var callbackName, overwritten, responseContainer, jsonProp = !1 !== s.jsonp && (rjsonp.test(s.url) ? "url" : "string" == typeof s.data && !(s.contentType || "").indexOf("application/x-www-form-urlencoded") && rjsonp.test(s.data) && "data");
// Handle iff the expected data type is "jsonp" or we have a parameter to set
if (jsonProp || "jsonp" === s.dataTypes[0]) // Delegate to script
return(// Get callback name, remembering preexisting value associated with it
callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback, jsonProp ? s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName) : !1 !== s.jsonp && (s.url += (ajax_rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName), // Use data converter to retrieve json after script execution
s.converters["script json"] = function() {
return responseContainer || jQuery.error(callbackName + " was not called"), responseContainer[0];
}, // force json dataType
s.dataTypes[0] = "json", // Install callback
overwritten = window1[callbackName], window1[callbackName] = function() {
responseContainer = arguments;
}, // Clean-up function (fires after converters)
jqXHR.always(function() {
// Restore preexisting value
window1[callbackName] = overwritten, s[callbackName] && (// make sure that re-using the options doesn't screw things around
s.jsonpCallback = originalSettings.jsonpCallback, // save the callback name for future use
oldCallbacks.push(callbackName)), responseContainer && jQuery.isFunction(overwritten) && overwritten(responseContainer[0]), responseContainer = overwritten = undefined;
}), "script");
});
var xhrCallbacks, xhrSupported, xhrId = 0, // #5280: Internet Explorer will keep connections alive if we don't abort on unload
xhrOnUnloadAbort = window1.ActiveXObject && function() {
// Abort all pending requests
var key;
for(key in xhrCallbacks)xhrCallbacks[key](undefined, !0);
};
// Functions to create xhrs
function createStandardXHR() {
try {
return new window1.XMLHttpRequest();
} catch (e) {}
}
// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window1.ActiveXObject ? /* Microsoft failed to properly
* implement the XMLHttpRequest in IE7 (can't request local files),
* so we use the ActiveXObject when it is available
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
* we need a fallback.
*/ function() {
return !this.isLocal && createStandardXHR() || function() {
try {
return new window1.ActiveXObject("Microsoft.XMLHTTP");
} catch (e) {}
}();
} : createStandardXHR, // Determine support properties
xhrSupported = jQuery.ajaxSettings.xhr(), jQuery.support.cors = !!xhrSupported && "withCredentials" in xhrSupported, (xhrSupported = jQuery.support.ajax = !!xhrSupported) && jQuery.ajaxTransport(function(s) {
// Cross domain only allowed if supported through XMLHttpRequest
if (!s.crossDomain || jQuery.support.cors) {
var callback;
return {
send: function(headers, complete) {
// Get a new xhr
var handle, i, xhr = s.xhr();
// Apply custom fields if provided
if (s.username ? xhr.open(s.type, s.url, s.async, s.username, s.password) : xhr.open(s.type, s.url, s.async), s.xhrFields) for(i in s.xhrFields)xhr[i] = s.xhrFields[i];
s.mimeType && xhr.overrideMimeType && xhr.overrideMimeType(s.mimeType), s.crossDomain || headers["X-Requested-With"] || (headers["X-Requested-With"] = "XMLHttpRequest");
// Need an extra try/catch for cross domain requests in Firefox 3
try {
for(i in headers)xhr.setRequestHeader(i, headers[i]);
} catch (err) {}
// Do send the request
// This may raise an exception which is actually
// handled in jQuery.ajax (so no try/catch here)
xhr.send(s.hasContent && s.data || null), // Listener
callback = function(_, isAbort) {
var status, responseHeaders, statusText, responses;
// Firefox throws exceptions when accessing properties
// of an xhr when a network error occurred
// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
try {
// Was never called and is aborted or complete
if (callback && (isAbort || 4 === xhr.readyState)) {
// If it's an abort
if (// Only called once
callback = undefined, handle && (xhr.onreadystatechange = jQuery.noop, xhrOnUnloadAbort && delete xhrCallbacks[handle]), isAbort) // Abort it manually if needed
4 !== xhr.readyState && xhr.abort();
else {
responses = {}, status = xhr.status, responseHeaders = xhr.getAllResponseHeaders(), "string" == typeof xhr.responseText && (responses.text = xhr.responseText);
// Firefox throws an exception when accessing
// statusText for faulty cross-domain requests
try {
statusText = xhr.statusText;
} catch (e) {
// We normalize with Webkit giving an empty statusText
statusText = "";
}
status || !s.isLocal || s.crossDomain ? 1223 === status && (status = 204) : status = responses.text ? 200 : 404;
}
}
} catch (firefoxAccessException) {
isAbort || complete(-1, firefoxAccessException);
}
// Call complete if needed
responses && complete(status, statusText, responses, responseHeaders);
}, s.async ? 4 === xhr.readyState ? // (IE6 & IE7) if it's in cache and has been
// retrieved directly we need to fire the callback
setTimeout(callback) : (handle = ++xhrId, xhrOnUnloadAbort && (xhrCallbacks || (xhrCallbacks = {}, jQuery(window1).unload(xhrOnUnloadAbort)), // Add to list of active xhrs callbacks
xhrCallbacks[handle] = callback), xhr.onreadystatechange = callback) : // if we're in sync mode we fire the callback
callback();
},
abort: function() {
callback && callback(undefined, !0);
}
};
}
});
var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rfxnum = RegExp("^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i"), rrun = /queueHooks$/, animationPrefilters = [
function(elem, props, opts) {
/*jshint validthis:true */ var prop, index, length, value, dataShow, toggle, tween, hooks, oldfire, anim = this, style = elem.style, orig = {}, handled = [], hidden = elem.nodeType && isHidden(elem);
// show/hide pass
for(index in opts.queue || (null == (hooks = jQuery._queueHooks(elem, "fx")).unqueued && (hooks.unqueued = 0, oldfire = hooks.empty.fire, hooks.empty.fire = function() {
hooks.unqueued || oldfire();
}), hooks.unqueued++, anim.always(function() {
// doing this makes sure that the complete handler will be called
// before this completes
anim.always(function() {
hooks.unqueued--, jQuery.queue(elem, "fx").length || hooks.empty.fire();
});
})), 1 === elem.nodeType && ("height" in props || "width" in props) && (// Make sure that nothing sneaks out
// Record all 3 overflow attributes because IE does not
// change the overflow attribute when overflowX and
// overflowY are set to the same value
opts.overflow = [
style.overflow,
style.overflowX,
style.overflowY
], "inline" === jQuery.css(elem, "display") && "none" === jQuery.css(elem, "float") && (jQuery.support.inlineBlockNeedsLayout && "inline" !== css_defaultDisplay(elem.nodeName) ? style.zoom = 1 : style.display = "inline-block")), opts.overflow && (style.overflow = "hidden", jQuery.support.shrinkWrapBlocks || anim.always(function() {
style.overflow = opts.overflow[0], style.overflowX = opts.overflow[1], style.overflowY = opts.overflow[2];
})), props)if (value = props[index], rfxtypes.exec(value)) {
if (delete props[index], toggle = toggle || "toggle" === value, value === (hidden ? "hide" : "show")) continue;
handled.push(index);
}
if (length = handled.length) for(("hidden" in (dataShow = jQuery._data(elem, "fxshow") || jQuery._data(elem, "fxshow", {}))) && (hidden = dataShow.hidden), toggle && (dataShow.hidden = !hidden), hidden ? jQuery(elem).show() : anim.done(function() {
jQuery(elem).hide();
}), anim.done(function() {
var prop;
for(prop in jQuery._removeData(elem, "fxshow"), orig)jQuery.style(elem, prop, orig[prop]);
}), index = 0; index < length; index++)prop = handled[index], tween = anim.createTween(prop, hidden ? dataShow[prop] : 0), orig[prop] = dataShow[prop] || jQuery.style(elem, prop), prop in dataShow || (dataShow[prop] = tween.start, hidden && (tween.end = tween.start, tween.start = +("width" === prop || "height" === prop)));
}
], tweeners = {
"*": [
function(prop, value) {
var end, unit, tween = this.createTween(prop, value), parts = rfxnum.exec(value), target = tween.cur(), start = +target || 0, scale = 1, maxIterations = 20;
if (parts) {
// We need to compute starting value
if (end = +parts[2], "px" !== (unit = parts[3] || (jQuery.cssNumber[prop] ? "" : "px")) && start) {
// Iteratively approximate from a nonzero starting point
// Prefer the current property, because this process will be trivial if it uses the same units
// Fallback to end or a simple constant
start = jQuery.css(tween.elem, prop, !0) || end || 1;
do // Adjust and apply
start /= // If previous iteration zeroed out, double until we get *something*
// Use a string for doubling factor so we don't accidentally see scale as unchanged below
scale = scale || ".5", jQuery.style(tween.elem, prop, start + unit);
while (scale !== (scale = tween.cur() / target) && 1 !== scale && --maxIterations)
}
tween.unit = unit, tween.start = start, // If a +=/-= token was provided, we're doing a relative animation
tween.end = parts[1] ? start + (parts[1] + 1) * end : end;
}
return tween;
}
]
};
// Animations created synchronously will run synchronously
function createFxNow() {
return setTimeout(function() {
fxNow = undefined;
}), fxNow = jQuery.now();
}
function Animation(elem, properties, options) {
var result, stopped, index = 0, length = animationPrefilters.length, deferred = jQuery.Deferred().always(function() {
// don't match elem in the :animated selector
delete tick.elem;
}), tick = function() {
if (stopped) return !1;
for(var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + animation.duration - currentTime), percent = 1 - (remaining / animation.duration || 0), index = 0, length = animation.tweens.length; index < length; index++)animation.tweens[index].run(percent);
return (deferred.notifyWith(elem, [
animation,
percent,
remaining
]), percent < 1 && length) ? remaining : (deferred.resolveWith(elem, [
animation
]), !1);
}, animation = deferred.promise({
elem: elem,
props: jQuery.extend({}, properties),
opts: jQuery.extend(!0, {
specialEasing: {}
}, options),
originalProperties: properties,
originalOptions: options,
startTime: fxNow || createFxNow(),
duration: options.duration,
tweens: [],
createTween: function(prop, end) {
var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
return animation.tweens.push(tween), tween;
},
stop: function(gotoEnd) {
var index = 0, // if we are going to the end, we want to run all the tweens
// otherwise we skip this part
length = gotoEnd ? animation.tweens.length : 0;
if (stopped) return this;
for(stopped = !0; index < length; index++)animation.tweens[index].run(1);
return gotoEnd ? deferred.resolveWith(elem, [
animation,
gotoEnd
]) : deferred.rejectWith(elem, [
animation,
gotoEnd
]), this;
}
}), props = animation.props;
for(function(props, specialEasing) {
var value, name1, index, easing, hooks;
// camelCase, specialEasing and expand cssHook pass
for(index in props)if (easing = specialEasing[name1 = jQuery.camelCase(index)], value = props[index], jQuery.isArray(value) && (easing = value[1], value = props[index] = value[0]), index !== name1 && (props[name1] = value, delete props[index]), (hooks = jQuery.cssHooks[name1]) && "expand" in hooks) // not quite $.extend, this wont overwrite keys already present.
// also - reusing 'index' from above because we have the correct "name"
for(index in value = hooks.expand(value), delete props[name1], value)index in props || (props[index] = value[index], specialEasing[index] = easing);
else specialEasing[name1] = easing;
}(props, animation.opts.specialEasing); index < length; index++)if (result = animationPrefilters[index].call(animation, elem, props, animation.opts)) return result;
// attach callbacks from options
return jQuery.each(props, function(prop, value) {
for(var collection = (tweeners[prop] || []).concat(tweeners["*"]), index = 0, length = collection.length; index < length; index++)if (collection[index].call(animation, prop, value)) // we're done with this property
return;
}), jQuery.isFunction(animation.opts.start) && animation.opts.start.call(elem, animation), jQuery.fx.timer(jQuery.extend(tick, {
elem: elem,
anim: animation,
queue: animation.opts.queue
})), animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
}
function Tween(elem, options, prop, end, easing) {
return new Tween.prototype.init(elem, options, prop, end, easing);
}
// Generate parameters to create a standard animation
function genFx(type, includeWidth) {
var which, attrs = {
height: type
}, i = 0;
for(// if we include width, step value is 1 to do all cssExpand values,
// if we don't include width, step value is 2 to skip over Left and Right
includeWidth = +!!includeWidth; i < 4; i += 2 - includeWidth)attrs["margin" + (which = cssExpand[i])] = attrs["padding" + which] = type;
return includeWidth && (attrs.opacity = attrs.width = type), attrs;
}
function getWindow(elem) {
return jQuery.isWindow(elem) ? elem : 9 === elem.nodeType && (elem.defaultView || elem.parentWindow);
}
jQuery.Animation = jQuery.extend(Animation, {
tweener: function(props, callback) {
jQuery.isFunction(props) ? (callback = props, props = [
"*"
]) : props = props.split(" ");
for(var prop, index = 0, length = props.length; index < length; index++)tweeners[prop = props[index]] = tweeners[prop] || [], tweeners[prop].unshift(callback);
},
prefilter: function(callback, prepend) {
prepend ? animationPrefilters.unshift(callback) : animationPrefilters.push(callback);
}
}), jQuery.Tween = Tween, Tween.prototype = {
constructor: Tween,
init: function(elem, options, prop, end, easing, unit) {
this.elem = elem, this.prop = prop, this.easing = easing || "swing", this.options = options, this.start = this.now = this.cur(), this.end = end, this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
},
cur: function() {
var hooks = Tween.propHooks[this.prop];
return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
},
run: function(percent) {
var eased, hooks = Tween.propHooks[this.prop];
return this.options.duration ? this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration) : this.pos = eased = percent, this.now = (this.end - this.start) * eased + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), hooks && hooks.set ? hooks.set(this) : Tween.propHooks._default.set(this), this;
}
}, Tween.prototype.init.prototype = Tween.prototype, Tween.propHooks = {
_default: {
get: function(tween) {
var result;
return null == tween.elem[tween.prop] || tween.elem.style && null != tween.elem.style[tween.prop] ? // passing an empty string as a 3rd parameter to .css will automatically
// attempt a parseFloat and fallback to a string if the parse fails
// so, simple values such as "10px" are parsed to Float.
// complex values such as "rotate(1rad)" are returned as is.
(result = jQuery.css(tween.elem, tween.prop, "")) && "auto" !== result ? result : 0 : tween.elem[tween.prop];
},
set: function(tween) {
// use step hook for back compat - use cssHook if its there - use .style if its
// available and use plain properties where available
jQuery.fx.step[tween.prop] ? jQuery.fx.step[tween.prop](tween) : tween.elem.style && (null != tween.elem.style[jQuery.cssProps[tween.prop]] || jQuery.cssHooks[tween.prop]) ? jQuery.style(tween.elem, tween.prop, tween.now + tween.unit) : tween.elem[tween.prop] = tween.now;
}
}
}, // Remove in 2.0 - this supports IE8's panic based approach
// to setting things on disconnected nodes
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
set: function(tween) {
tween.elem.nodeType && tween.elem.parentNode && (tween.elem[tween.prop] = tween.now);
}
}, jQuery.each([
"toggle",
"show",
"hide"
], function(i, name1) {
var cssFn = jQuery.fn[name1];
jQuery.fn[name1] = function(speed, easing, callback) {
return null == speed || "boolean" == typeof speed ? cssFn.apply(this, arguments) : this.animate(genFx(name1, !0), speed, easing, callback);
};
}), jQuery.fn.extend({
fadeTo: function(speed, to, easing, callback) {
// show any hidden elements after setting opacity to 0
return this.filter(isHidden).css("opacity", 0).show()// animate to the value specified
.end().animate({
opacity: to
}, speed, easing, callback);
},
animate: function(prop, speed, easing, callback) {
var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, callback), doAnimation = function() {
// Operate on a copy of prop so per-property easing won't be lost
var anim = Animation(this, jQuery.extend({}, prop), optall);
doAnimation.finish = function() {
anim.stop(!0);
}, (empty || jQuery._data(this, "finish")) && anim.stop(!0);
};
return doAnimation.finish = doAnimation, empty || !1 === optall.queue ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
},
stop: function(type, clearQueue, gotoEnd) {
var stopQueue = function(hooks) {
var stop = hooks.stop;
delete hooks.stop, stop(gotoEnd);
};
return "string" != typeof type && (gotoEnd = clearQueue, clearQueue = type, type = undefined), clearQueue && !1 !== type && this.queue(type || "fx", []), this.each(function() {
var dequeue = !0, index = null != type && type + "queueHooks", timers = jQuery.timers, data = jQuery._data(this);
if (index) data[index] && data[index].stop && stopQueue(data[index]);
else for(index in data)data[index] && data[index].stop && rrun.test(index) && stopQueue(data[index]);
for(index = timers.length; index--;)timers[index].elem === this && (null == type || timers[index].queue === type) && (timers[index].anim.stop(gotoEnd), dequeue = !1, timers.splice(index, 1));
// start the next in the queue if the last step wasn't forced
// timers currently will call their complete callbacks, which will dequeue
// but only if they were gotoEnd
(dequeue || !gotoEnd) && jQuery.dequeue(this, type);
});
},
finish: function(type) {
return !1 !== type && (type = type || "fx"), this.each(function() {
var index, data = jQuery._data(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length : 0;
// look for any active animations, and finish them
for(// enable finishing flag on private data
data.finish = !0, // empty the queue first
jQuery.queue(this, type, []), hooks && hooks.cur && hooks.cur.finish && hooks.cur.finish.call(this), index = timers.length; index--;)timers[index].elem === this && timers[index].queue === type && (timers[index].anim.stop(!0), timers.splice(index, 1));
// look for any animations in the old queue and finish them
for(index = 0; index < length; index++)queue[index] && queue[index].finish && queue[index].finish.call(this);
// turn off finishing flag
delete data.finish;
});
}
}), // Generate shortcuts for custom animations
jQuery.each({
slideDown: genFx("show"),
slideUp: genFx("hide"),
slideToggle: genFx("toggle"),
fadeIn: {
opacity: "show"
},
fadeOut: {
opacity: "hide"
},
fadeToggle: {
opacity: "toggle"
}
}, function(name1, props) {
jQuery.fn[name1] = function(speed, easing, callback) {
return this.animate(props, speed, easing, callback);
};
}), jQuery.speed = function(speed, easing, fn) {
var opt = speed && "object" == typeof speed ? jQuery.extend({}, speed) : {
complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
duration: speed,
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
};
return opt.duration = jQuery.fx.off ? 0 : "number" == typeof opt.duration ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default, (null == opt.queue || !0 === opt.queue) && (opt.queue = "fx"), // Queueing
opt.old = opt.complete, opt.complete = function() {
jQuery.isFunction(opt.old) && opt.old.call(this), opt.queue && jQuery.dequeue(this, opt.queue);
}, opt;
}, jQuery.easing = {
linear: function(p) {
return p;
},
swing: function(p) {
return 0.5 - Math.cos(p * Math.PI) / 2;
}
}, jQuery.timers = [], jQuery.fx = Tween.prototype.init, jQuery.fx.tick = function() {
var timer, timers = jQuery.timers, i = 0;
for(fxNow = jQuery.now(); i < timers.length; i++)// Checks the timer has not already been removed
(timer = timers[i])() || timers[i] !== timer || timers.splice(i--, 1);
timers.length || jQuery.fx.stop(), fxNow = undefined;
}, jQuery.fx.timer = function(timer) {
timer() && jQuery.timers.push(timer) && jQuery.fx.start();
}, jQuery.fx.interval = 13, jQuery.fx.start = function() {
timerId || (timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval));
}, jQuery.fx.stop = function() {
clearInterval(timerId), timerId = null;
}, jQuery.fx.speeds = {
slow: 600,
fast: 200,
// Default speed
_default: 400
}, // Back Compat <1.8 extension point
jQuery.fx.step = {}, jQuery.expr && jQuery.expr.filters && (jQuery.expr.filters.animated = function(elem) {
return jQuery.grep(jQuery.timers, function(fn) {
return elem === fn.elem;
}).length;
}), jQuery.fn.offset = function(options) {
if (arguments.length) return undefined === options ? this : this.each(function(i) {
jQuery.offset.setOffset(this, options, i);
});
var docElem, win, box = {
top: 0,
left: 0
}, elem = this[0], doc = elem && elem.ownerDocument;
return doc ? (docElem = doc.documentElement, jQuery.contains(docElem, elem)) ? (typeof elem.getBoundingClientRect !== core_strundefined && (box = elem.getBoundingClientRect()), win = getWindow(doc), {
top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
}) : box : void 0;
}, jQuery.offset = {
setOffset: function(elem, options, i) {
var position = jQuery.css(elem, "position");
"static" === position && (elem.style.position = "relative");
var curTop, curLeft, curElem = jQuery(elem), curOffset = curElem.offset(), curCSSTop = jQuery.css(elem, "top"), curCSSLeft = jQuery.css(elem, "left"), calculatePosition = ("absolute" === position || "fixed" === position) && jQuery.inArray("auto", [
curCSSTop,
curCSSLeft
]) > -1, props = {}, curPosition = {};
calculatePosition ? (curTop = (curPosition = curElem.position()).top, curLeft = curPosition.left) : (curTop = parseFloat(curCSSTop) || 0, curLeft = parseFloat(curCSSLeft) || 0), jQuery.isFunction(options) && (options = options.call(elem, i, curOffset)), null != options.top && (props.top = options.top - curOffset.top + curTop), null != options.left && (props.left = options.left - curOffset.left + curLeft), "using" in options ? options.using.call(elem, props) : curElem.css(props);
}
}, jQuery.fn.extend({
position: function() {
if (this[0]) {
var offsetParent, offset, parentOffset = {
top: 0,
left: 0
}, elem = this[0];
// Subtract parent offsets and element margins
// note: when an element has margin: auto the offsetLeft and marginLeft
// are the same in Safari causing offset.left to incorrectly be 0
return "fixed" === jQuery.css(elem, "position") ? // we assume that getBoundingClientRect is available when computed position is fixed
offset = elem.getBoundingClientRect() : (// Get *real* offsetParent
offsetParent = this.offsetParent(), // Get correct offsets
offset = this.offset(), jQuery.nodeName(offsetParent[0], "html") || (parentOffset = offsetParent.offset()), // Add offsetParent borders
parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", !0), parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", !0)), {
top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", !0),
left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", !0)
};
}
},
offsetParent: function() {
return this.map(function() {
for(var offsetParent = this.offsetParent || document.documentElement; offsetParent && !jQuery.nodeName(offsetParent, "html") && "static" === jQuery.css(offsetParent, "position");)offsetParent = offsetParent.offsetParent;
return offsetParent || document.documentElement;
});
}
}), // Create scrollLeft and scrollTop methods
jQuery.each({
scrollLeft: "pageXOffset",
scrollTop: "pageYOffset"
}, function(method, prop) {
var top = /Y/.test(prop);
jQuery.fn[method] = function(val) {
return jQuery.access(this, function(elem, method, val) {
var win = getWindow(elem);
if (undefined === val) return win ? prop in win ? win[prop] : win.document.documentElement[method] : elem[method];
win ? win.scrollTo(top ? jQuery(win).scrollLeft() : val, top ? val : jQuery(win).scrollTop()) : elem[method] = val;
}, method, val, arguments.length, null);
};
}), // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
jQuery.each({
Height: "height",
Width: "width"
}, function(name1, type) {
jQuery.each({
padding: "inner" + name1,
content: type,
"": "outer" + name1
}, function(defaultExtra, funcName) {
// margin is only for outerHeight, outerWidth
jQuery.fn[funcName] = function(margin, value) {
var chainable = arguments.length && (defaultExtra || "boolean" != typeof margin), extra = defaultExtra || (!0 === margin || !0 === value ? "margin" : "border");
return jQuery.access(this, function(elem, type, value) {
var doc;
return jQuery.isWindow(elem) ? elem.document.documentElement["client" + name1] : 9 === elem.nodeType ? (doc = elem.documentElement, Math.max(elem.body["scroll" + name1], doc["scroll" + name1], elem.body["offset" + name1], doc["offset" + name1], doc["client" + name1])) : undefined === value ? jQuery.css(elem, type, extra) : jQuery.style(elem, type, value, extra);
}, type, chainable ? margin : undefined, chainable, null);
};
});
}), // Limit scope pollution from any deprecated API
// (function() {
// })();
// Expose jQuery to the global object
window1.jQuery = window1.$ = jQuery, "function" == typeof define && define.amd && define.amd.jQuery && define("jquery", [], function() {
return jQuery;
});
}(window);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/jquery.mobile-1.4.2.js | JavaScript | !/*!
* jQuery Mobile 1.4.2
* Git HEAD hash: 9d9a42a27d0c693e8b5569c3a10d771916af5045 <> Date: Fri Feb 28 2014 17:32:01 UTC
* http://jquerymobile.com
*
* Copyright 2010, 2014 jQuery Foundation, Inc. and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
*/ function(root, doc, factory) {
"function" == typeof define && define.amd ? // AMD. Register as an anonymous module.
define([
"jquery"
], function($) {
return factory($, root, doc), $.mobile;
}) : // Browser globals
factory(root.jQuery, root, doc);
}(this, document, function(jQuery, window, document1, undefined) {
var undefined1, nsNormalizeDict, oldFind, rbrace, jqmDataRE, window1, compensateToolbars, undefined2, uuid, slice, _cleanData, rcapitals, replaceFunction, bool, docElem, refNode, // fakeBody required for <FF4 when executed in <head>
fakeBody, div, support, self, $win, dummyFnToInitNavigate, undefined3, path, $base, dialogHashKey, undefined4, path1, initialHref, undefined5, props, testElement, vendorPrefixes, heldCall, curr, diff, handler, lastCall, baseElement, // base element management, defined depending on dynamic base tag support
// TODO move to external widget
base, undefined6, originalWidget, // Record the original, non-mobileinit-modified version of $.mobile.keepNative
// so we can later determine whether someone has modified $.mobile.keepNative
keepNativeFactoryDefault, orig, undefined7, pageTransitionQueue, // indicates whether or not page is in process of transitioning
isPageTransitioning, window2, undefined8, rInitialLetter, // Construct iconpos class from iconpos value
iconposClass, meta, initialContent, disabledZoom, enabledZoom, disabledInitially, undefined9, rDividerListItem, origDefaultFilterCallback;
jQuery.mobile = {}, function($, window, undefined) {
$.extend($.mobile, {
// Version of the jQuery Mobile Framework
version: "1.4.2",
// Deprecated and no longer used in 1.4 remove in 1.5
// Define the url parameter used for referencing widget-generated sub-pages.
// Translates to example.html&ui-page=subpageIdentifier
// hash segment before &ui-page= is used to make Ajax request
subPageUrlKey: "ui-page",
hideUrlBar: !0,
// Keepnative Selector
keepNative: ":jqmData(role='none'), :jqmData(role='nojs')",
// Deprecated in 1.4 remove in 1.5
// Class assigned to page currently in view, and during transitions
activePageClass: "ui-page-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "active" button state, from CSS framework
activeBtnClass: "ui-btn-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "focus" form element state, from CSS framework
focusClass: "ui-focus",
// Automatically handle clicks and form submissions through Ajax, when same-domain
ajaxEnabled: !0,
// Automatically load and show pages based on location.hash
hashListeningEnabled: !0,
// disable to prevent jquery from bothering with links
linkBindingEnabled: !0,
// Set default page transition - 'none' for no transitions
defaultPageTransition: "fade",
// Set maximum window width for transitions to apply - 'false' for no limit
maxTransitionWidth: !1,
// Minimum scroll distance that will be remembered when returning to a page
// Deprecated remove in 1.5
minScrollBack: 0,
// Set default dialog transition - 'none' for no transitions
defaultDialogTransition: "pop",
// Error response message - appears when an Ajax page request fails
pageLoadErrorMessage: "Error Loading Page",
// For error messages, which theme does the box uses?
pageLoadErrorMessageTheme: "a",
// replace calls to window.history.back with phonegaps navigation helper
// where it is provided on the window object
phonegapNavigationEnabled: !1,
//automatically initialize the DOM when it's ready
autoInitializePage: !0,
pushStateEnabled: !0,
// allows users to opt in to ignoring content by marking a parent element as
// data-ignored
ignoreContentEnabled: !1,
buttonMarkup: {
hoverDelay: 200
},
// disable the alteration of the dynamic base tag or links in the case
// that a dynamic base tag isn't supported
dynamicBaseEnabled: !0,
// default the property to remove dependency on assignment in init module
pageContainer: $(),
//enable cross-domain page support
allowCrossDomainPages: !1,
dialogHashKey: "&ui-state=dialog"
});
}(jQuery, 0), nsNormalizeDict = {}, oldFind = jQuery.find, rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, jqmDataRE = /:jqmData\(([^)]*)\)/g, jQuery.extend(jQuery.mobile, {
// Namespace used framework-wide for data-attrs. Default is no namespace
ns: "",
// Retrieve an attribute from an element and perform some massaging of the value
getAttribute: function(element, key) {
var data;
(element = element.jquery ? element[0] : element) && element.getAttribute && (data = element.getAttribute("data-" + jQuery.mobile.ns + key));
// Copied from core's src/data.js:dataAttr()
// Convert from a string to a proper data type
try {
data = "true" === data || "false" !== data && ("null" === data ? null : +data + "" === data ? +data : rbrace.test(data) ? JSON.parse(data) : data);
} catch (err) {}
return data;
},
// Expose our cache for testing purposes.
nsNormalizeDict: nsNormalizeDict,
// Take a data attribute property, prepend the namespace
// and then camel case the attribute string. Add the result
// to our nsNormalizeDict so we don't have to do this again.
nsNormalize: function(prop) {
return nsNormalizeDict[prop] || (nsNormalizeDict[prop] = jQuery.camelCase(jQuery.mobile.ns + prop));
},
// Find the closest javascript page element to gather settings data jsperf test
// http://jsperf.com/single-complex-selector-vs-many-complex-selectors/edit
// possibly naive, but it shows that the parsing overhead for *just* the page selector vs
// the page and dialog selector is negligable. This could probably be speed up by
// doing a similar parent node traversal to the one found in the inherited theme code above
closestPageData: function($target) {
return $target.closest(":jqmData(role='page'), :jqmData(role='dialog')").data("mobile-page");
}
}), // Mobile version of data and removeData and hasData methods
// ensures all data is set and retrieved using jQuery Mobile's data namespace
jQuery.fn.jqmData = function(prop, value) {
var result;
return void 0 !== prop && (prop && (prop = jQuery.mobile.nsNormalize(prop)), result = arguments.length < 2 || undefined1 === value ? this.data(prop) : this.data(prop, value)), result;
}, jQuery.jqmData = function(elem, prop, value) {
var result;
return void 0 !== prop && (result = jQuery.data(elem, prop ? jQuery.mobile.nsNormalize(prop) : prop, value)), result;
}, jQuery.fn.jqmRemoveData = function(prop) {
return this.removeData(jQuery.mobile.nsNormalize(prop));
}, jQuery.jqmRemoveData = function(elem, prop) {
return jQuery.removeData(elem, jQuery.mobile.nsNormalize(prop));
}, jQuery.find = function(selector, context, ret, extra) {
return selector.indexOf(":jqmData") > -1 && (selector = selector.replace(jqmDataRE, "[data-" + (jQuery.mobile.ns || "") + "$1]")), oldFind.call(this, selector, context, ret, extra);
}, jQuery.extend(jQuery.find, oldFind), /*!
* jQuery UI Core c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/category/ui-core/
*/ function($, undefined) {
var orig, removeData, uuid = 0, runiqueId = /^ui-id-\d+$/;
// selectors
function focusable(element, isTabIndexNotNaN) {
var map, mapName, img, nodeName = element.nodeName.toLowerCase();
return "area" === nodeName ? (mapName = (map = element.parentNode).name, !!element.href && !!mapName && "map" === map.nodeName.toLowerCase() && !!(img = $("img[usemap=#" + mapName + "]")[0]) && visible(img)) : (/input|select|textarea|button|object/.test(nodeName) ? !element.disabled : "a" === nodeName && element.href || isTabIndexNotNaN) && // the element and all of its ancestors must be visible
visible(element);
}
function visible(element) {
return $.expr.filters.visible(element) && !$(element).parents().addBack().filter(function() {
return "hidden" === $.css(this, "visibility");
}).length;
}
// $.ui might exist from components with no dependencies, e.g., $.ui.position
$.ui = $.ui || {}, $.extend($.ui, {
version: "c0ab71056b936627e8a7821f03c044aec6280a40",
keyCode: {
BACKSPACE: 8,
COMMA: 188,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
PERIOD: 190,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38
}
}), // plugins
$.fn.extend({
focus: (orig = $.fn.focus, function(delay, fn) {
return "number" == typeof delay ? this.each(function() {
var elem = this;
setTimeout(function() {
$(elem).focus(), fn && fn.call(elem);
}, delay);
}) : orig.apply(this, arguments);
}),
scrollParent: function() {
var scrollParent;
return scrollParent = $.ui.ie && /(static|relative)/.test(this.css("position")) || /absolute/.test(this.css("position")) ? this.parents().filter(function() {
return /(relative|absolute|fixed)/.test($.css(this, "position")) && /(auto|scroll)/.test($.css(this, "overflow") + $.css(this, "overflow-y") + $.css(this, "overflow-x"));
}).eq(0) : this.parents().filter(function() {
return /(auto|scroll)/.test($.css(this, "overflow") + $.css(this, "overflow-y") + $.css(this, "overflow-x"));
}).eq(0), /fixed/.test(this.css("position")) || !scrollParent.length ? $(this[0].ownerDocument || document1) : scrollParent;
},
uniqueId: function() {
return this.each(function() {
this.id || (this.id = "ui-id-" + ++uuid);
});
},
removeUniqueId: function() {
return this.each(function() {
runiqueId.test(this.id) && $(this).removeAttr("id");
});
}
}), $.extend($.expr[":"], {
data: $.expr.createPseudo ? $.expr.createPseudo(function(dataName) {
return function(elem) {
return !!$.data(elem, dataName);
};
}) : function(elem, i, match) {
return !!$.data(elem, match[3]);
},
focusable: function(element) {
return focusable(element, !isNaN($.attr(element, "tabindex")));
},
tabbable: function(element) {
var tabIndex = $.attr(element, "tabindex"), isTabIndexNaN = isNaN(tabIndex);
return (isTabIndexNaN || tabIndex >= 0) && focusable(element, !isTabIndexNaN);
}
}), $("<a>").outerWidth(1).jquery || $.each([
"Width",
"Height"
], function(i, name) {
var side = "Width" === name ? [
"Left",
"Right"
] : [
"Top",
"Bottom"
], type = name.toLowerCase(), orig = {
innerWidth: $.fn.innerWidth,
innerHeight: $.fn.innerHeight,
outerWidth: $.fn.outerWidth,
outerHeight: $.fn.outerHeight
};
function reduce(elem, size, border, margin) {
return $.each(side, function() {
size -= parseFloat($.css(elem, "padding" + this)) || 0, border && (size -= parseFloat($.css(elem, "border" + this + "Width")) || 0), margin && (size -= parseFloat($.css(elem, "margin" + this)) || 0);
}), size;
}
$.fn["inner" + name] = function(size) {
return undefined === size ? orig["inner" + name].call(this) : this.each(function() {
$(this).css(type, reduce(this, size) + "px");
});
}, $.fn["outer" + name] = function(size, margin) {
return "number" != typeof size ? orig["outer" + name].call(this, size) : this.each(function() {
$(this).css(type, reduce(this, size, !0, margin) + "px");
});
};
}), $.fn.addBack || ($.fn.addBack = function(selector) {
return this.add(null == selector ? this.prevObject : this.prevObject.filter(selector));
}), $("<a>").data("a-b", "a").removeData("a-b").data("a-b") && ($.fn.removeData = (removeData = $.fn.removeData, function(key) {
return arguments.length ? removeData.call(this, $.camelCase(key)) : removeData.call(this);
})), // deprecated
$.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase()), $.support.selectstart = "onselectstart" in document1.createElement("div"), $.fn.extend({
disableSelection: function() {
return this.bind(($.support.selectstart ? "selectstart" : "mousedown") + ".ui-disableSelection", function(event1) {
event1.preventDefault();
});
},
enableSelection: function() {
return this.unbind(".ui-disableSelection");
},
zIndex: function(zIndex) {
if (undefined !== zIndex) return this.css("zIndex", zIndex);
if (this.length) for(var position, value, elem = $(this[0]); elem.length && elem[0] !== document1;){
if (("absolute" === // Ignore z-index if position is set to a value where z-index is ignored by the browser
// This makes behavior of this function consistent across browsers
// WebKit always returns auto if the element is positioned
(position = elem.css("position")) || "relative" === position || "fixed" === position) && !isNaN(// IE returns 0 when zIndex is not specified
// other browsers return a string
// we ignore the case of nested elements with an explicit value of 0
// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
value = parseInt(elem.css("zIndex"), 10)) && 0 !== value) return value;
elem = elem.parent();
}
return 0;
}
}), // $.ui.plugin is deprecated. Use $.widget() extensions instead.
$.ui.plugin = {
add: function(module, option, set) {
var i, proto = $.ui[module].prototype;
for(i in set)proto.plugins[i] = proto.plugins[i] || [], proto.plugins[i].push([
option,
set[i]
]);
},
call: function(instance, name, args, allowDisconnected) {
var i, set = instance.plugins[name];
if (set && (allowDisconnected || instance.element[0].parentNode && 11 !== instance.element[0].parentNode.nodeType)) for(i = 0; i < set.length; i++)instance.options[set[i][0]] && set[i][1].apply(instance.element, args);
}
};
}(jQuery), window1 = this, compensateToolbars = function(page, desiredHeight) {
var pageParent = page.parent(), toolbarsAffectingHeight = [], externalHeaders = pageParent.children(":jqmData(role='header')"), internalHeaders = page.children(":jqmData(role='header')"), externalFooters = pageParent.children(":jqmData(role='footer')"), internalFooters = page.children(":jqmData(role='footer')");
// Height must be at least zero
return 0 === internalHeaders.length && externalHeaders.length > 0 && (toolbarsAffectingHeight = toolbarsAffectingHeight.concat(externalHeaders.toArray())), 0 === internalFooters.length && externalFooters.length > 0 && (toolbarsAffectingHeight = toolbarsAffectingHeight.concat(externalFooters.toArray())), jQuery.each(toolbarsAffectingHeight, function(index, value) {
desiredHeight -= jQuery(value).outerHeight();
}), Math.max(0, desiredHeight);
}, jQuery.extend(jQuery.mobile, {
// define the window and the document objects
window: jQuery(window1),
document: jQuery(document1),
// TODO: Remove and use $.ui.keyCode directly
keyCode: jQuery.ui.keyCode,
// Place to store various widget extensions
behaviors: {},
// Scroll page vertically: scroll to 0 to hide iOS address bar, or pass a Y value
silentScroll: function(ypos) {
"number" !== jQuery.type(ypos) && (ypos = jQuery.mobile.defaultHomeScroll), // prevent scrollstart and scrollstop events
jQuery.event.special.scrollstart.enabled = !1, setTimeout(function() {
window1.scrollTo(0, ypos), jQuery.mobile.document.trigger("silentscroll", {
x: 0,
y: ypos
});
}, 20), setTimeout(function() {
jQuery.event.special.scrollstart.enabled = !0;
}, 150);
},
getClosestBaseUrl: function(ele) {
// Find the closest page and extract out its url.
var url = jQuery(ele).closest(".ui-page").jqmData("url"), base = jQuery.mobile.path.documentBase.hrefNoHash;
return jQuery.mobile.dynamicBaseEnabled && url && jQuery.mobile.path.isPath(url) || (url = base), jQuery.mobile.path.makeUrlAbsolute(url, base);
},
removeActiveLinkClass: function(forceRemoval) {
jQuery.mobile.activeClickedLink && (!jQuery.mobile.activeClickedLink.closest("." + jQuery.mobile.activePageClass).length || forceRemoval) && jQuery.mobile.activeClickedLink.removeClass(jQuery.mobile.activeBtnClass), jQuery.mobile.activeClickedLink = null;
},
// DEPRECATED in 1.4
// Find the closest parent with a theme class on it. Note that
// we are not using $.fn.closest() on purpose here because this
// method gets called quite a bit and we need it to be as fast
// as possible.
getInheritedTheme: function(el, defaultTheme) {
for(var c, m, e = el[0], ltr = "", re = /ui-(bar|body|overlay)-([a-z])\b/; e && (!((c = e.className || "") && (m = re.exec(c))) || !(ltr = m[2]));)e = e.parentNode;
// Return the theme letter we found, if none, return the
// specified default.
return ltr || defaultTheme || "a";
},
enhanceable: function(elements) {
return this.haveParents(elements, "enhance");
},
hijackable: function(elements) {
return this.haveParents(elements, "ajax");
},
haveParents: function(elements, attr) {
if (!jQuery.mobile.ignoreContentEnabled) return elements;
var e, $element, excluded, i, count = elements.length, $newSet = jQuery();
for(i = 0; i < count; i++){
for($element = elements.eq(i), excluded = !1, e = elements[i]; e;){
if ("false" === (e.getAttribute ? e.getAttribute("data-" + jQuery.mobile.ns + attr) : "")) {
excluded = !0;
break;
}
e = e.parentNode;
}
excluded || ($newSet = $newSet.add($element));
}
return $newSet;
},
getScreenHeight: function() {
// Native innerHeight returns more accurate value for this across platforms,
// jQuery version is here as a normalized fallback for platforms like Symbian
return window1.innerHeight || jQuery.mobile.window.height();
},
//simply set the active page's minimum height to screen height, depending on orientation
resetActivePageHeight: function(height) {
var page = jQuery("." + jQuery.mobile.activePageClass), pageHeight = page.height(), pageOuterHeight = page.outerHeight(!0);
height = compensateToolbars(page, "number" == typeof height ? height : jQuery.mobile.getScreenHeight()), page.css("min-height", height - (pageOuterHeight - pageHeight));
},
loading: function() {
// If this is the first call to this function, instantiate a loader widget
var loader = this.loading._widget || jQuery(jQuery.mobile.loader.prototype.defaultHtml).loader(), // Call the appropriate method on the loader
returnValue = loader.loader.apply(loader, arguments);
return(// Make sure the loader is retained for future calls to this function.
this.loading._widget = loader, returnValue);
}
}), jQuery.addDependents = function(elem, newDependents) {
var $elem = jQuery(elem), dependents = $elem.jqmData("dependents") || jQuery();
$elem.jqmData("dependents", jQuery(dependents).add(newDependents));
}, // plugins
jQuery.fn.extend({
removeWithDependents: function() {
jQuery.removeWithDependents(this);
},
// Enhance child elements
enhanceWithin: function() {
var index, widgetElements = {}, keepNative = jQuery.mobile.page.prototype.keepNativeSelector(), that = this;
for(index in jQuery.mobile.nojs && jQuery.mobile.nojs(this), jQuery.mobile.links && jQuery.mobile.links(this), jQuery.mobile.degradeInputsWithin && jQuery.mobile.degradeInputsWithin(this), jQuery.fn.buttonMarkup && this.find(jQuery.fn.buttonMarkup.initSelector).not(keepNative).jqmEnhanceable().buttonMarkup(), jQuery.fn.fieldcontain && this.find(":jqmData(role='fieldcontain')").not(keepNative).jqmEnhanceable().fieldcontain(), // Enhance widgets
jQuery.each(jQuery.mobile.widgets, function(name, constructor) {
// If initSelector not false find elements
if (constructor.initSelector) {
// Filter elements that should not be enhanced based on parents
var elements = jQuery.mobile.enhanceable(that.find(constructor.initSelector));
elements.length > 0 && // $.mobile.page.prototype.keepNativeSelector is deprecated this is just for backcompat
// Switch to $.mobile.keepNative in 1.5 which is just a value not a function
(elements = elements.not(keepNative)), elements.length > 0 && (widgetElements[constructor.prototype.widgetName] = elements);
}
}), widgetElements)widgetElements[index][index]();
return this;
},
addDependents: function(newDependents) {
jQuery.addDependents(this, newDependents);
},
// note that this helper doesn't attempt to handle the callback
// or setting of an html element's text, its only purpose is
// to return the html encoded version of the text in all cases. (thus the name)
getEncodedText: function() {
return jQuery("<a>").text(this.text()).html();
},
// fluent helper function for the mobile namespaced equivalent
jqmEnhanceable: function() {
return jQuery.mobile.enhanceable(this);
},
jqmHijackable: function() {
return jQuery.mobile.hijackable(this);
}
}), jQuery.removeWithDependents = function(nativeElement) {
var element = jQuery(nativeElement);
(element.jqmData("dependents") || jQuery()).remove(), element.remove();
}, jQuery.addDependents = function(nativeElement, newDependents) {
var element = jQuery(nativeElement), dependents = element.jqmData("dependents") || jQuery();
element.jqmData("dependents", jQuery(dependents).add(newDependents));
}, jQuery.find.matches = function(expr, set) {
return jQuery.find(expr, null, null, set);
}, jQuery.find.matchesSelector = function(node, expr) {
return jQuery.find(expr, null, null, [
node
]).length > 0;
}, uuid = 0, slice = Array.prototype.slice, _cleanData = jQuery.cleanData, jQuery.cleanData = function(elems) {
for(var elem, i = 0; null != (elem = elems[i]); i++)try {
jQuery(elem).triggerHandler("remove");
// http://bugs.jquery.com/ticket/8235
} catch (e) {}
_cleanData(elems);
}, jQuery.widget = function(name, base, prototype) {
var fullName, existingConstructor, constructor, basePrototype, // proxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
proxiedPrototype = {}, namespace = name.split(".")[0];
return fullName = namespace + "-" + (name = name.split(".")[1]), prototype || (prototype = base, base = jQuery.Widget), // create selector for plugin
jQuery.expr[":"][fullName.toLowerCase()] = function(elem) {
return !!jQuery.data(elem, fullName);
}, jQuery[namespace] = jQuery[namespace] || {}, existingConstructor = jQuery[namespace][name], constructor = jQuery[namespace][name] = function(options, element) {
// allow instantiation without "new" keyword
if (!this._createWidget) return new constructor(options, element);
// allow instantiation without initializing for simple inheritance
// must use "new" keyword (the code above always passes args)
arguments.length && this._createWidget(options, element);
}, // extend with the existing constructor to carry over any static properties
jQuery.extend(constructor, existingConstructor, {
version: prototype.version,
// copy the object used to create the prototype in case we need to
// redefine the widget later
_proto: jQuery.extend({}, prototype),
// track widgets that inherit from this widget in case this widget is
// redefined after a widget inherits from it
_childConstructors: []
}), // we need to make the options hash a property directly on the new instance
// otherwise we'll modify the options hash on the prototype that we're
// inheriting from
(basePrototype = new base()).options = jQuery.widget.extend({}, basePrototype.options), jQuery.each(prototype, function(prop, value) {
var _super, _superApply;
if (!jQuery.isFunction(value)) {
proxiedPrototype[prop] = value;
return;
}
proxiedPrototype[prop] = (_super = function() {
return base.prototype[prop].apply(this, arguments);
}, _superApply = function(args) {
return base.prototype[prop].apply(this, args);
}, function() {
var returnValue, __super = this._super, __superApply = this._superApply;
return this._super = _super, this._superApply = _superApply, returnValue = value.apply(this, arguments), this._super = __super, this._superApply = __superApply, returnValue;
});
}), constructor.prototype = jQuery.widget.extend(basePrototype, {
// TODO: remove support for widgetEventPrefix
// always use the name + a colon as the prefix, e.g., draggable:start
// don't prefix for widgets that aren't DOM-based
widgetEventPrefix: existingConstructor && basePrototype.widgetEventPrefix || name
}, proxiedPrototype, {
constructor: constructor,
namespace: namespace,
widgetName: name,
widgetFullName: fullName
}), existingConstructor ? (jQuery.each(existingConstructor._childConstructors, function(i, child) {
var childPrototype = child.prototype;
// redefine the child widget using the same prototype that was
// originally used, but inherit from the new version of the base
jQuery.widget(childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto);
}), // remove the list of existing child constructors from the old constructor
// so the old child constructors can be garbage collected
delete existingConstructor._childConstructors) : base._childConstructors.push(constructor), jQuery.widget.bridge(name, constructor), constructor;
}, jQuery.widget.extend = function(target) {
for(var key, value, input = slice.call(arguments, 1), inputIndex = 0, inputLength = input.length; inputIndex < inputLength; inputIndex++)for(key in input[inputIndex])value = input[inputIndex][key], input[inputIndex].hasOwnProperty(key) && undefined2 !== value && (jQuery.isPlainObject(value) ? target[key] = jQuery.isPlainObject(target[key]) ? jQuery.widget.extend({}, target[key], value) : jQuery.widget.extend({}, value) : target[key] = value);
return target;
}, jQuery.widget.bridge = function(name, object) {
var fullName = object.prototype.widgetFullName || name;
jQuery.fn[name] = function(options) {
var isMethodCall = "string" == typeof options, args = slice.call(arguments, 1), returnValue = this;
return(// allow multiple hashes to be passed on init
options = !isMethodCall && args.length ? jQuery.widget.extend.apply(null, [
options
].concat(args)) : options, isMethodCall ? this.each(function() {
var methodValue, instance = jQuery.data(this, fullName);
return "instance" === options ? (returnValue = instance, !1) : instance ? jQuery.isFunction(instance[options]) && "_" !== options.charAt(0) ? (methodValue = instance[options].apply(instance, args)) !== instance && undefined2 !== methodValue ? (returnValue = methodValue && methodValue.jquery ? returnValue.pushStack(methodValue.get()) : methodValue, !1) : void 0 : jQuery.error("no such method '" + options + "' for " + name + " widget instance") : jQuery.error("cannot call methods on " + name + " prior to initialization; attempted to call method '" + options + "'");
}) : this.each(function() {
var instance = jQuery.data(this, fullName);
instance ? instance.option(options || {})._init() : jQuery.data(this, fullName, new object(options, this));
}), returnValue);
};
}, jQuery.Widget = function() {}, jQuery.Widget._childConstructors = [], jQuery.Widget.prototype = {
widgetName: "widget",
widgetEventPrefix: "",
defaultElement: "<div>",
options: {
disabled: !1,
// callbacks
create: null
},
_createWidget: function(options, element) {
element = jQuery(element || this.defaultElement || this)[0], this.element = jQuery(element), this.uuid = uuid++, this.eventNamespace = "." + this.widgetName + this.uuid, this.options = jQuery.widget.extend({}, this.options, this._getCreateOptions(), options), this.bindings = jQuery(), this.hoverable = jQuery(), this.focusable = jQuery(), element !== this && (jQuery.data(element, this.widgetFullName, this), this._on(!0, this.element, {
remove: function(event1) {
event1.target === element && this.destroy();
}
}), this.document = jQuery(element.style ? element.ownerDocument : element.document || element), this.window = jQuery(this.document[0].defaultView || this.document[0].parentWindow)), this._create(), this._trigger("create", null, this._getCreateEventData()), this._init();
},
_getCreateOptions: jQuery.noop,
_getCreateEventData: jQuery.noop,
_create: jQuery.noop,
_init: jQuery.noop,
destroy: function() {
this._destroy(), // we can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element.unbind(this.eventNamespace).removeData(this.widgetFullName)// support: jquery <1.6.3
// http://bugs.jquery.com/ticket/9413
.removeData(jQuery.camelCase(this.widgetFullName)), this.widget().unbind(this.eventNamespace).removeAttr("aria-disabled").removeClass(this.widgetFullName + "-disabled ui-state-disabled"), // clean up events and states
this.bindings.unbind(this.eventNamespace), this.hoverable.removeClass("ui-state-hover"), this.focusable.removeClass("ui-state-focus");
},
_destroy: jQuery.noop,
widget: function() {
return this.element;
},
option: function(key, value) {
var parts, curOption, i, options = key;
if (0 == arguments.length) // don't return a reference to the internal hash
return jQuery.widget.extend({}, this.options);
if ("string" == typeof key) {
if (// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {}, key = (parts = key.split(".")).shift(), parts.length) {
for(i = 0, curOption = options[key] = jQuery.widget.extend({}, this.options[key]); i < parts.length - 1; i++)curOption[parts[i]] = curOption[parts[i]] || {}, curOption = curOption[parts[i]];
if (key = parts.pop(), undefined2 === value) return curOption[key] === undefined2 ? null : curOption[key];
curOption[key] = value;
} else {
if (undefined2 === value) return this.options[key] === undefined2 ? null : this.options[key];
options[key] = value;
}
}
return this._setOptions(options), this;
},
_setOptions: function(options) {
var key;
for(key in options)this._setOption(key, options[key]);
return this;
},
_setOption: function(key, value) {
return this.options[key] = value, "disabled" === key && (this.widget().toggleClass(this.widgetFullName + "-disabled", !!value), this.hoverable.removeClass("ui-state-hover"), this.focusable.removeClass("ui-state-focus")), this;
},
enable: function() {
return this._setOptions({
disabled: !1
});
},
disable: function() {
return this._setOptions({
disabled: !0
});
},
_on: function(suppressDisabledCheck, element, handlers) {
var delegateElement, instance = this;
"boolean" != typeof suppressDisabledCheck && (handlers = element, element = suppressDisabledCheck, suppressDisabledCheck = !1), handlers ? (// accept selectors, DOM elements
element = delegateElement = jQuery(element), this.bindings = this.bindings.add(element)) : (handlers = element, element = this.element, delegateElement = this.widget()), jQuery.each(handlers, function(event1, handler) {
function handlerProxy() {
// allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if (!(!suppressDisabledCheck && (!0 === instance.options.disabled || jQuery(this).hasClass("ui-state-disabled")))) return ("string" == typeof handler ? instance[handler] : handler).apply(instance, arguments);
}
// copy the guid so direct unbinding works
"string" != typeof handler && (handlerProxy.guid = handler.guid = handler.guid || handlerProxy.guid || jQuery.guid++);
var match = event1.match(/^(\w+)\s*(.*)$/), eventName = match[1] + instance.eventNamespace, selector = match[2];
selector ? delegateElement.delegate(selector, eventName, handlerProxy) : element.bind(eventName, handlerProxy);
});
},
_off: function(element, eventName) {
eventName = (eventName || "").split(" ").join(this.eventNamespace + " ") + this.eventNamespace, element.unbind(eventName).undelegate(eventName);
},
_delay: function(handler, delay) {
var instance = this;
return setTimeout(function() {
return ("string" == typeof handler ? instance[handler] : handler).apply(instance, arguments);
}, delay || 0);
},
_hoverable: function(element) {
this.hoverable = this.hoverable.add(element), this._on(element, {
mouseenter: function(event1) {
jQuery(event1.currentTarget).addClass("ui-state-hover");
},
mouseleave: function(event1) {
jQuery(event1.currentTarget).removeClass("ui-state-hover");
}
});
},
_focusable: function(element) {
this.focusable = this.focusable.add(element), this._on(element, {
focusin: function(event1) {
jQuery(event1.currentTarget).addClass("ui-state-focus");
},
focusout: function(event1) {
jQuery(event1.currentTarget).removeClass("ui-state-focus");
}
});
},
_trigger: function(type, event1, data) {
var prop, orig, callback = this.options[type];
if (data = data || {}, (event1 = jQuery.Event(event1)).type = (type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type).toLowerCase(), // the original event may come from any element
// so we need to reset the target on the new event
event1.target = this.element[0], // copy original event properties over to the new event
orig = event1.originalEvent) for(prop in orig)prop in event1 || (event1[prop] = orig[prop]);
return this.element.trigger(event1, data), !(jQuery.isFunction(callback) && !1 === callback.apply(this.element[0], [
event1
].concat(data)) || event1.isDefaultPrevented());
}
}, jQuery.each({
show: "fadeIn",
hide: "fadeOut"
}, function(method, defaultEffect) {
jQuery.Widget.prototype["_" + method] = function(element, options, callback) {
"string" == typeof options && (options = {
effect: options
});
var hasOptions, effectName = options ? !0 === options || "number" == typeof options ? defaultEffect : options.effect || defaultEffect : method;
"number" == typeof (options = options || {}) && (options = {
duration: options
}), hasOptions = !jQuery.isEmptyObject(options), options.complete = callback, options.delay && element.delay(options.delay), hasOptions && jQuery.effects && jQuery.effects.effect[effectName] ? element[method](options) : effectName !== method && element[effectName] ? element[effectName](options.duration, options.easing, callback) : element.queue(function(next) {
jQuery(this)[method](), callback && callback.call(element[0]), next();
});
};
}), rcapitals = /[A-Z]/g, replaceFunction = function(c) {
return "-" + c.toLowerCase();
}, jQuery.extend(jQuery.Widget.prototype, {
_getCreateOptions: function() {
var option, value, elem = this.element[0], options = {};
//
if (!jQuery.mobile.getAttribute(elem, "defaults")) for(option in this.options)null != (value = jQuery.mobile.getAttribute(elem, option.replace(rcapitals, replaceFunction))) && (options[option] = value);
return options;
}
}), //TODO: Remove in 1.5 for backcompat only
jQuery.mobile.widget = jQuery.Widget, function($) {
// TODO move loader class down into the widget settings
var loaderClass = "ui-loader", $html = $("html");
$.widget("mobile.loader", {
// NOTE if the global config settings are defined they will override these
// options
options: {
// the theme for the loading message
theme: "a",
// whether the text in the loading message is shown
textVisible: !1,
// custom html for the inner content of the loading message
html: "",
// the text to be displayed when the popup is shown
text: "loading"
},
defaultHtml: "<div class='" + loaderClass + "'><span class='ui-icon-loading'></span><h1></h1></div>",
// For non-fixed supportin browsers. Position at y center (if scrollTop supported), above the activeBtn (if defined), or just 100px from top
fakeFixLoader: function() {
var activeBtn = $("." + $.mobile.activeBtnClass).first();
this.element.css({
top: $.support.scrollTop && this.window.scrollTop() + this.window.height() / 2 || activeBtn.length && activeBtn.offset().top || 100
});
},
// check position of loader to see if it appears to be "fixed" to center
// if not, use abs positioning
checkLoaderPosition: function() {
var offset = this.element.offset(), scrollTop = this.window.scrollTop(), screenHeight = $.mobile.getScreenHeight();
(offset.top < scrollTop || offset.top - scrollTop > screenHeight) && (this.element.addClass("ui-loader-fakefix"), this.fakeFixLoader(), this.window.unbind("scroll", this.checkLoaderPosition).bind("scroll", $.proxy(this.fakeFixLoader, this)));
},
resetHtml: function() {
this.element.html($(this.defaultHtml).html());
},
// Turn on/off page loading message. Theme doubles as an object argument
// with the following shape: { theme: '', text: '', html: '', textVisible: '' }
// NOTE that the $.mobile.loading* settings and params past the first are deprecated
// TODO sweet jesus we need to break some of this out
show: function(theme, msgText, textonly) {
var textVisible, message, loadSettings;
this.resetHtml(), "object" === $.type(theme) ? theme = (loadSettings = $.extend({}, this.options, theme)).theme : (loadSettings = this.options, // here we prefer the theme value passed as a string argument, then
// we prefer the global option because we can't use undefined default
// prototype options, then the prototype option
theme = theme || loadSettings.theme), // set the message text, prefer the param, then the settings object
// then loading message
message = msgText || (!1 === loadSettings.text ? "" : loadSettings.text), // prepare the dom
$html.addClass("ui-loading"), textVisible = loadSettings.textVisible, // add the proper css given the options (theme, text, etc)
// Force text visibility if the second argument was supplied, or
// if the text was explicitly set in the object args
this.element.attr("class", loaderClass + " ui-corner-all ui-body-" + theme + " ui-loader-" + (textVisible || msgText || theme.text ? "verbose" : "default") + (loadSettings.textonly || textonly ? " ui-loader-textonly" : "")), loadSettings.html ? this.element.html(loadSettings.html) : this.element.find("h1").text(message), // attach the loader to the DOM
this.element.appendTo($.mobile.pageContainer), // check that the loader is visible
this.checkLoaderPosition(), // on scroll check the loader position
this.window.bind("scroll", $.proxy(this.checkLoaderPosition, this));
},
hide: function() {
$html.removeClass("ui-loading"), this.options.text && this.element.removeClass("ui-loader-fakefix"), $.mobile.window.unbind("scroll", this.fakeFixLoader), $.mobile.window.unbind("scroll", this.checkLoaderPosition);
}
});
}(jQuery, this), /*!
* jQuery hashchange event - v1.3 - 7/21/2010
* http://benalman.com/projects/jquery-hashchange-plugin/
*
* Copyright (c) 2010 "Cowboy" Ben Alman
* Dual licensed under the MIT and GPL licenses.
* http://benalman.com/about/license/
*/ // Script: jQuery hashchange event
//
// *Version: 1.3, Last updated: 7/21/2010*
//
// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
// GitHub - http://github.com/cowboy/jquery-hashchange/
// Source - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
// (Minified) - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (0.8kb gzipped)
//
// About: License
//
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
//
// About: Examples
//
// These working examples, complete with fully commented code, illustrate a few
// ways in which this plugin can be used.
//
// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
// document.domain - http://benalman.com/code/projects/jquery-hashchange/examples/document_domain/
//
// About: Support and Testing
//
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
//
// jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-4, Chrome 5-6, Safari 3.2-5,
// Opera 9.6-10.60, iPhone 3.1, Android 1.6-2.2, BlackBerry 4.6-5.
// Unit Tests - http://benalman.com/code/projects/jquery-hashchange/unit/
//
// About: Known issues
//
// While this jQuery hashchange event implementation is quite stable and
// robust, there are a few unfortunate browser bugs surrounding expected
// hashchange event-based behaviors, independent of any JavaScript
// window.onhashchange abstraction. See the following examples for more
// information:
//
// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
//
// Also note that should a browser natively support the window.onhashchange
// event, but not report that it does, the fallback polling loop will be used.
//
// About: Release History
//
// 1.3 - (7/21/2010) Reorganized IE6/7 Iframe code to make it more
// "removable" for mobile-only development. Added IE6/7 document.title
// support. Attempted to make Iframe as hidden as possible by using
// techniques from http://www.paciellogroup.com/blog/?p=604. Added
// support for the "shortcut" format $(window).hashchange( fn ) and
// $(window).hashchange() like jQuery provides for built-in events.
// Renamed jQuery.hashchangeDelay to <jQuery.fn.hashchange.delay> and
// lowered its default value to 50. Added <jQuery.fn.hashchange.domain>
// and <jQuery.fn.hashchange.src> properties plus document-domain.html
// file to address access denied issues when setting document.domain in
// IE6/7.
// 1.2 - (2/11/2010) Fixed a bug where coming back to a page using this plugin
// from a page on another domain would cause an error in Safari 4. Also,
// IE6/7 Iframe is now inserted after the body (this actually works),
// which prevents the page from scrolling when the event is first bound.
// Event can also now be bound before DOM ready, but it won't be usable
// before then in IE6/7.
// 1.1 - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
// where browser version is incorrectly reported as 8.0, despite
// inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
// 1.0 - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
// window.onhashchange functionality into a separate plugin for users
// who want just the basic event & back button support, without all the
// extra awesomeness that BBQ provides. This plugin will be included as
// part of jQuery BBQ, but also be available separately.
function($, window, undefined) {
// Reused string.
var fake_onhashchange, str_hashchange = "hashchange", special = $.event.special, // Does the browser support window.onhashchange? Note that IE8 running in
// IE7 compatibility mode reports true for 'onhashchange' in window, even
// though the event isn't supported, so also test document.documentMode.
doc_mode = document1.documentMode, supports_onhashchange = "on" + str_hashchange in window && (void 0 === doc_mode || doc_mode > 7);
// Get location.hash (or what you'd expect location.hash to be) sans any
// leading #. Thanks for making this necessary, Firefox!
function get_fragment(url) {
return "#" + (url = url || location.href).replace(/^[^#]*#?(.*)$/, "$1");
}
// Method: jQuery.fn.hashchange
//
// Bind a handler to the window.onhashchange event or trigger all bound
// window.onhashchange event handlers. This behavior is consistent with
// jQuery's built-in event handlers.
//
// Usage:
//
// > jQuery(window).hashchange( [ handler ] );
//
// Arguments:
//
// handler - (Function) Optional handler to be bound to the hashchange
// event. This is a "shortcut" for the more verbose form:
// jQuery(window).bind( 'hashchange', handler ). If handler is omitted,
// all bound window.onhashchange event handlers will be triggered. This
// is a shortcut for the more verbose
// jQuery(window).trigger( 'hashchange' ). These forms are described in
// the <hashchange event> section.
//
// Returns:
//
// (jQuery) The initial jQuery collection of elements.
// Allow the "shortcut" format $(elem).hashchange( fn ) for binding and
// $(elem).hashchange() for triggering, like jQuery does for built-in events.
$.fn[str_hashchange] = function(fn) {
return fn ? this.bind(str_hashchange, fn) : this.trigger(str_hashchange);
}, // Property: jQuery.fn.hashchange.delay
//
// The numeric interval (in milliseconds) at which the <hashchange event>
// polling loop executes. Defaults to 50.
// Property: jQuery.fn.hashchange.domain
//
// If you're setting document.domain in your JavaScript, and you want hash
// history to work in IE6/7, not only must this property be set, but you must
// also set document.domain BEFORE jQuery is loaded into the page. This
// property is only applicable if you are supporting IE6/7 (or IE8 operating
// in "IE7 compatibility" mode).
//
// In addition, the <jQuery.fn.hashchange.src> property must be set to the
// path of the included "document-domain.html" file, which can be renamed or
// modified if necessary (note that the document.domain specified must be the
// same in both your main JavaScript as well as in this file).
//
// Usage:
//
// jQuery.fn.hashchange.domain = document.domain;
// Property: jQuery.fn.hashchange.src
//
// If, for some reason, you need to specify an Iframe src file (for example,
// when setting document.domain as in <jQuery.fn.hashchange.domain>), you can
// do so using this property. Note that when using this property, history
// won't be recorded in IE6/7 until the Iframe src file loads. This property
// is only applicable if you are supporting IE6/7 (or IE8 operating in "IE7
// compatibility" mode).
//
// Usage:
//
// jQuery.fn.hashchange.src = 'path/to/file.html';
$.fn[str_hashchange].delay = 50, /*
$.fn[ str_hashchange ].domain = null;
$.fn[ str_hashchange ].src = null;
*/ // Event: hashchange event
//
// Fired when location.hash changes. In browsers that support it, the native
// HTML5 window.onhashchange event is used, otherwise a polling loop is
// initialized, running every <jQuery.fn.hashchange.delay> milliseconds to
// see if the hash has changed. In IE6/7 (and IE8 operating in "IE7
// compatibility" mode), a hidden Iframe is created to allow the back button
// and hash-based history to work.
//
// Usage as described in <jQuery.fn.hashchange>:
//
// > // Bind an event handler.
// > jQuery(window).hashchange( function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).hashchange();
//
// A more verbose usage that allows for event namespacing:
//
// > // Bind an event handler.
// > jQuery(window).bind( 'hashchange', function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).trigger( 'hashchange' );
//
// Additional Notes:
//
// * The polling loop and Iframe are not created until at least one handler
// is actually bound to the 'hashchange' event.
// * If you need the bound handler(s) to execute immediately, in cases where
// a location.hash exists on page load, via bookmark or page refresh for
// example, use jQuery(window).hashchange() or the more verbose
// jQuery(window).trigger( 'hashchange' ).
// * The event can be bound before DOM ready, but since it won't be usable
// before then in IE6/7 (due to the necessary Iframe), recommended usage is
// to bind it inside a DOM ready handler.
// Override existing $.event.special.hashchange methods (allowing this plugin
// to be defined after jQuery BBQ in BBQ's source code).
special[str_hashchange] = $.extend(special[str_hashchange], {
// Called only when the first 'hashchange' event is bound to window.
setup: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if (supports_onhashchange) return !1;
// Otherwise, we need to create our own. And we don't want to call this
// until the user binds to the event, just in case they never do, since it
// will create a polling loop and possibly even a hidden Iframe.
$(fake_onhashchange.start);
},
// Called only when the last 'hashchange' event is unbound from window.
teardown: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if (supports_onhashchange) return !1;
// Otherwise, we need to stop ours (if possible).
$(fake_onhashchange.stop);
}
}), // fake_onhashchange does all the work of triggering the window.onhashchange
// event for browsers that don't natively support it, including creating a
// polling loop to watch for hash changes and in IE 6/7 creating a hidden
// Iframe to enable back and forward.
fake_onhashchange = function() {
var iframe, iframe_src, timeout_id, self = {}, // Remember the initial hash so it doesn't get triggered immediately.
last_hash = get_fragment(), fn_retval = function(val) {
return val;
}, history_set = fn_retval, history_get = fn_retval;
// This polling loop checks every $.fn.hashchange.delay milliseconds to see
// if location.hash has changed, and triggers the 'hashchange' event on
// window when necessary.
function poll() {
var hash = get_fragment(), history_hash = history_get(last_hash);
hash !== last_hash ? (history_set(last_hash = hash, history_hash), $(window).trigger(str_hashchange)) : history_hash !== last_hash && (location.href = location.href.replace(/#.*/, "") + history_hash), timeout_id = setTimeout(poll, $.fn[str_hashchange].delay);
}
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^ REMOVE IF NOT SUPPORTING IE6/7/8 ^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return(// Start the polling loop.
self.start = function() {
timeout_id || poll();
}, // Stop the polling loop.
self.stop = function() {
timeout_id && clearTimeout(timeout_id), timeout_id = void 0;
}, // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvv REMOVE IF NOT SUPPORTING IE6/7/8 vvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
!window.attachEvent || window.addEventListener || supports_onhashchange || (// When the event is bound and polling starts in IE 6/7, create a hidden
// Iframe for history handling.
self.start = function() {
iframe || (iframe_src = (iframe_src = $.fn[str_hashchange].src) && iframe_src + get_fragment(), // Create hidden Iframe. Attempt to make Iframe as hidden as possible
// by using techniques from http://www.paciellogroup.com/blog/?p=604.
iframe = $('<iframe tabindex="-1" title="empty"/>').hide()// When Iframe has completely loaded, initialize the history and
// start polling.
.one("load", function() {
iframe_src || history_set(get_fragment()), poll();
})// Load Iframe src if specified, otherwise nothing.
.attr("src", iframe_src || "javascript:0")// Append Iframe after the end of the body to prevent unnecessary
// initial page scrolling (yes, this works).
.insertAfter("body")[0].contentWindow, // Whenever `document.title` changes, update the Iframe's title to
// prettify the back/next history menu entries. Since IE sometimes
// errors with "Unspecified error" the very first time this is set
// (yes, very useful) wrap this with a try/catch block.
document1.onpropertychange = function() {
try {
"title" === event.propertyName && (iframe.document.title = document1.title);
} catch (e) {}
});
}, // Override the "stop" method since an IE6/7 Iframe was created. Even
// if there are no longer any bound event handlers, the polling loop
// is still necessary for back/next to work at all!
self.stop = fn_retval, // Get history by looking at the hidden Iframe's location.hash.
history_get = function() {
return get_fragment(iframe.location.href);
}, // Set a new history item by opening and then closing the Iframe
// document, *then* setting its location.hash. If document.domain has
// been set, update that as well.
history_set = function(hash, history_hash) {
var iframe_doc = iframe.document, domain = $.fn[str_hashchange].domain;
hash !== history_hash && (// Update Iframe with any initial `document.title` that might be set.
iframe_doc.title = document1.title, // Opening the Iframe's document after it has been closed is what
// actually adds a history entry.
iframe_doc.open(), // Set document.domain for the Iframe document as well, if necessary.
domain && iframe_doc.write('<script>document.domain="' + domain + '"</script>'), iframe_doc.close(), // Update the Iframe's hash, for great justice.
iframe.location.hash = hash);
}), self);
}();
}(jQuery, this), /*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */ window.matchMedia = window.matchMedia || (refNode = (docElem = document1.documentElement).firstElementChild || docElem.firstChild, fakeBody = document1.createElement("body"), (div = document1.createElement("div")).id = "mq-test-1", div.style.cssText = "position:absolute;top:-100em", fakeBody.style.background = "none", fakeBody.appendChild(div), function(q) {
return div.innerHTML = '­<style media="' + q + '"> #mq-test-1 { width: 42px; }</style>', docElem.insertBefore(fakeBody, refNode), bool = 42 === div.offsetWidth, docElem.removeChild(fakeBody), {
matches: bool,
media: q
};
}), // $.mobile.media uses matchMedia to return a boolean.
jQuery.mobile.media = function(q) {
return window.matchMedia(q).matches;
}, support = {
touch: "ontouchend" in document1
}, jQuery.mobile.support = jQuery.mobile.support || {}, jQuery.extend(jQuery.support, support), jQuery.extend(jQuery.mobile.support, support), function($, undefined) {
$.extend($.support, {
orientation: "orientation" in window && "onorientationchange" in window
});
}(jQuery), function($, undefined) {
// thx Modernizr
function propExists(prop) {
var v, uc_prop = prop.charAt(0).toUpperCase() + prop.substr(1), props = (prop + " " + vendors.join(uc_prop + " ") + uc_prop).split(" ");
for(v in props)if (void 0 !== fbCSS[props[v]]) return !0;
}
var ua, platform, // Rendering engine is Webkit, and capture major version
wkmatch, wkversion, ffmatch, ffversion, operammobilematch, omversion, rebase, fauxBase, base, fauxEle, href, supports, element, documentElement, getComputedStyle, ua1, nokiaLTE7_3, fakeBody = $("<body>").prependTo("html"), fbCSS = fakeBody[0].style, vendors = [
"Webkit",
"Moz",
"O"
], webos = "palmGetResource" in window, operamini = window.operamini && "[object OperaMini]" === ({}).toString.call(window.operamini), bb = window.blackberry && !propExists("-webkit-transform");
// non-UA-based IE version check by James Padolsey, modified by jdalton - from http://gist.github.com/527683
// allows for inclusion of IE 6+, including Windows Mobile 7
$.extend($.mobile, {
browser: {}
}), $.mobile.browser.oldIE = function() {
var v = 3, div = document1.createElement("div"), a = div.all || [];
do div.innerHTML = "<!--[if gt IE " + ++v + "]><br><![endif]-->";
while (a[0])
return v > 4 ? v : !v;
}(), $.extend($.support, {
// Note, Chrome for iOS has an extremely quirky implementation of popstate.
// We've chosen to take the shortest path to a bug fix here for issue #5426
// See the following link for information about the regex chosen
// https://developers.google.com/chrome/mobile/docs/user-agent#chrome_for_ios_user-agent
pushState: "pushState" in history && "replaceState" in history && // When running inside a FF iframe, calling replaceState causes an error
!(window.navigator.userAgent.indexOf("Firefox") >= 0 && window.top !== window) && -1 === window.navigator.userAgent.search(/CriOS/),
mediaquery: $.mobile.media("only all"),
cssPseudoElement: !!propExists("content"),
touchOverflow: !!propExists("overflowScrolling"),
cssTransform3d: function() {
var el, transforms, t, mqProp = "transform-3d", // Because the `translate3d` test below throws false positives in Android:
ret = $.mobile.media("(-" + vendors.join("-" + mqProp + "),(-") + "-" + mqProp + "),(" + mqProp + ")");
if (ret) return !!ret;
for(t in el = document1.createElement("div"), transforms = {
// We’re omitting Opera for the time being; MS uses unprefixed.
MozTransform: "-moz-transform",
transform: "transform"
}, fakeBody.append(el), transforms)void 0 !== el.style[t] && (el.style[t] = "translate3d( 100px, 1px, 1px )", ret = window.getComputedStyle(el).getPropertyValue(transforms[t]));
return !!ret && "none" !== ret;
}(),
boxShadow: !!propExists("boxShadow") && !bb,
fixedPosition: (ua = navigator.userAgent, platform = navigator.platform, wkversion = !!(wkmatch = ua.match(/AppleWebKit\/([0-9]+)/)) && wkmatch[1], ffversion = !!(ffmatch = ua.match(/Fennec\/([0-9]+)/)) && ffmatch[1], omversion = !!(operammobilematch = ua.match(/Opera Mobi\/([0-9]+)/)) && operammobilematch[1], !((platform.indexOf("iPhone") > -1 || platform.indexOf("iPad") > -1 || platform.indexOf("iPod") > -1) && wkversion && wkversion < 534 || // Opera Mini
window.operamini && "[object OperaMini]" === ({}).toString.call(window.operamini) || operammobilematch && omversion < 7458 || //Android lte 2.1: Platform is Android and Webkit version is less than 533 (Android 2.2)
ua.indexOf("Android") > -1 && wkversion && wkversion < 533 || // Firefox Mobile before 6.0 -
ffversion && ffversion < 6 || // WebOS less than 3
"palmGetResource" in window && wkversion && wkversion < 534 || // MeeGo
ua.indexOf("MeeGo") > -1 && ua.indexOf("NokiaBrowser/8.5.0") > -1)),
scrollTop: ("pageXOffset" in window || "scrollTop" in document1.documentElement || "scrollTop" in fakeBody[0]) && !webos && !operamini,
dynamicBaseTag: (fauxBase = location.protocol + "//" + location.host + location.pathname + "ui-dir/", base = $("head base"), fauxEle = null, href = "", base.length ? href = base.attr("href") : base = fauxEle = $("<base>", {
href: fauxBase
}).appendTo("head"), rebase = $("<a href='testurl' />").prependTo(fakeBody)[0].href, base[0].href = href || location.pathname, fauxEle && fauxEle.remove(), 0 === rebase.indexOf(fauxBase)),
cssPointerEvents: (element = document1.createElement("x"), documentElement = document1.documentElement, getComputedStyle = window.getComputedStyle, "pointerEvents" in element.style && (element.style.pointerEvents = "auto", element.style.pointerEvents = "x", documentElement.appendChild(element), supports = getComputedStyle && "auto" === getComputedStyle(element, "").pointerEvents, documentElement.removeChild(element), !!supports)),
boundingRect: void 0 !== document1.createElement("div").getBoundingClientRect,
inlineSVG: // inline SVG support test
function() {
// Thanks Modernizr & Erik Dahlstrom
var svg = !!window.document.createElementNS && !!window.document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect && !(window.opera && -1 === navigator.userAgent.indexOf("Chrome")), support = function(data) {
data && svg || $("html").addClass("ui-nosvg");
}, img = new window.Image();
img.onerror = function() {
support(!1);
}, img.onload = function() {
support(1 === img.width && 1 === img.height);
}, img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
}
}), fakeBody.remove(), // $.mobile.ajaxBlacklist is used to override ajaxEnabled on platforms that have known conflicts with hash history updates (BB5, Symbian)
// or that generally work better browsing in regular http for full page refreshes (Opera Mini)
// Note: This detection below is used as a last resort.
// We recommend only using these detection methods when all other more reliable/forward-looking approaches are not possible
nokiaLTE7_3 = (ua1 = window.navigator.userAgent).indexOf("Nokia") > -1 && (ua1.indexOf("Symbian/3") > -1 || ua1.indexOf("Series60/5") > -1) && ua1.indexOf("AppleWebKit") > -1 && ua1.match(/(BrowserNG|NokiaBrowser)\/7\.[0-3]/), // Support conditions that must be met in order to proceed
// default enhanced qualifications are media query support OR IE 7+
$.mobile.gradeA = function() {
return ($.support.mediaquery && $.support.cssPseudoElement || $.mobile.browser.oldIE && $.mobile.browser.oldIE >= 8) && ($.support.boundingRect || null !== $.fn.jquery.match(/1\.[0-7+]\.[0-9+]?/));
}, $.mobile.ajaxBlacklist = // BlackBerry browsers, pre-webkit
window.blackberry && !window.WebKitPoint || // Opera Mini
operamini || // Symbian webkits pre 7.3
nokiaLTE7_3, nokiaLTE7_3 && $(function() {
$("head link[rel='stylesheet']").attr("rel", "alternate stylesheet").attr("rel", "stylesheet");
}), $.support.boxShadow || $("html").addClass("ui-noboxshadow");
}(jQuery), $win = jQuery.mobile.window, dummyFnToInitNavigate = function() {}, jQuery.event.special.beforenavigate = {
setup: function() {
$win.on("navigate", dummyFnToInitNavigate);
},
teardown: function() {
$win.off("navigate", dummyFnToInitNavigate);
}
}, jQuery.event.special.navigate = self = {
bound: !1,
pushStateEnabled: !0,
originalEventName: void 0,
// If pushstate support is present and push state support is defined to
// be true on the mobile namespace.
isPushStateEnabled: function() {
return jQuery.support.pushState && !0 === jQuery.mobile.pushStateEnabled && this.isHashChangeEnabled();
},
// !! assumes mobile namespace is present
isHashChangeEnabled: function() {
return !0 === jQuery.mobile.hashListeningEnabled;
},
// TODO a lot of duplication between popstate and hashchange
popstate: function(event1) {
var newEvent = new jQuery.Event("navigate"), beforeNavigate = new jQuery.Event("beforenavigate"), state = event1.originalEvent.state || {};
beforeNavigate.originalEvent = event1, $win.trigger(beforeNavigate), !beforeNavigate.isDefaultPrevented() && (event1.historyState && jQuery.extend(state, event1.historyState), // Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event1, // NOTE we let the current stack unwind because any assignment to
// location.hash will stop the world and run this event handler. By
// doing this we create a similar behavior to hashchange on hash
// assignment
setTimeout(function() {
$win.trigger(newEvent, {
state: state
});
}, 0));
},
hashchange: function(event1 /*, data */ ) {
var newEvent = new jQuery.Event("navigate"), beforeNavigate = new jQuery.Event("beforenavigate");
beforeNavigate.originalEvent = event1, $win.trigger(beforeNavigate), !beforeNavigate.isDefaultPrevented() && (// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event1, // Trigger the hashchange with state provided by the user
// that altered the hash
$win.trigger(newEvent, {
// Users that want to fully normalize the two events
// will need to do history management down the stack and
// add the state to the event before this binding is fired
// TODO consider allowing for the explicit addition of callbacks
// to be fired before this value is set to avoid event timing issues
state: event1.hashchangeState || {}
}));
},
// TODO We really only want to set this up once
// but I'm not clear if there's a beter way to achieve
// this with the jQuery special event structure
setup: function() {
!self.bound && (self.bound = !0, self.isPushStateEnabled() ? (self.originalEventName = "popstate", $win.bind("popstate.navigate", self.popstate)) : self.isHashChangeEnabled() && (self.originalEventName = "hashchange", $win.bind("hashchange.navigate", self.hashchange)));
}
}, dialogHashKey = "&ui-state=dialog", jQuery.mobile.path = path = {
uiStateKey: "&ui-state",
// This scary looking regular expression parses an absolute URL or its relative
// variants (protocol, site, document, query, and hash), into the various
// components (protocol, host, path, query, fragment, etc that make up the
// URL as well as some other commonly used sub-parts. When used with RegExp.exec()
// or String.match, it parses the URL into a results array that looks like this:
//
// [0]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread#msg-content
// [1]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread
// [2]: http://jblas:password@mycompany.com:8080/mail/inbox
// [3]: http://jblas:password@mycompany.com:8080
// [4]: http:
// [5]: //
// [6]: jblas:password@mycompany.com:8080
// [7]: jblas:password
// [8]: jblas
// [9]: password
// [10]: mycompany.com:8080
// [11]: mycompany.com
// [12]: 8080
// [13]: /mail/inbox
// [14]: /mail/
// [15]: inbox
// [16]: ?msg=1234&type=unread
// [17]: #msg-content
//
urlParseRE: /^\s*(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
// Abstraction to address xss (Issue #4787) by removing the authority in
// browsers that auto decode it. All references to location.href should be
// replaced with a call to this method so that it can be dealt with properly here
getLocation: function(url) {
var uri = url ? this.parseUrl(url) : location, hash = this.parseUrl(url || location.href).hash;
// Make sure to parse the url or the location object for the hash because using location.hash
// is autodecoded in firefox, the rest of the url should be from the object (location unless
// we're testing) to avoid the inclusion of the authority
return(// mimic the browser with an empty string when the hash is empty
hash = "#" === hash ? "" : hash, uri.protocol + "//" + uri.host + uri.pathname + uri.search + hash);
},
//return the original document url
getDocumentUrl: function(asParsedObject) {
return asParsedObject ? jQuery.extend({}, path.documentUrl) : path.documentUrl.href;
},
parseLocation: function() {
return this.parseUrl(this.getLocation());
},
//Parse a URL into a structure that allows easy access to
//all of the URL components by name.
parseUrl: function(url) {
// If we're passed an object, we'll assume that it is
// a parsed url object and just return it back to the caller.
if ("object" === jQuery.type(url)) return url;
var matches = path.urlParseRE.exec(url || "") || [];
// Create an object that allows the caller to access the sub-matches
// by name. Note that IE returns an empty string instead of undefined,
// like all other browsers do, so we normalize everything so its consistent
// no matter what browser we're running on.
return {
href: matches[0] || "",
hrefNoHash: matches[1] || "",
hrefNoSearch: matches[2] || "",
domain: matches[3] || "",
protocol: matches[4] || "",
doubleSlash: matches[5] || "",
authority: matches[6] || "",
username: matches[8] || "",
password: matches[9] || "",
host: matches[10] || "",
hostname: matches[11] || "",
port: matches[12] || "",
pathname: matches[13] || "",
directory: matches[14] || "",
filename: matches[15] || "",
search: matches[16] || "",
hash: matches[17] || ""
};
},
//Turn relPath into an asbolute path. absPath is
//an optional absolute path which describes what
//relPath is relative to.
makePathAbsolute: function(relPath, absPath) {
var absStack, relStack, i, d;
if (relPath && "/" === relPath.charAt(0)) return relPath;
for(i = 0, relPath = relPath || "", absStack = (absPath = absPath ? absPath.replace(/^\/|(\/[^\/]*|[^\/]+)$/g, "") : "") ? absPath.split("/") : [], relStack = relPath.split("/"); i < relStack.length; i++)switch(d = relStack[i]){
case ".":
break;
case "..":
absStack.length && absStack.pop();
break;
default:
absStack.push(d);
}
return "/" + absStack.join("/");
},
//Returns true if both urls have the same domain.
isSameDomain: function(absUrl1, absUrl2) {
return path.parseUrl(absUrl1).domain === path.parseUrl(absUrl2).domain;
},
//Returns true for any relative variant.
isRelativeUrl: function(url) {
// All relative Url variants have one thing in common, no protocol.
return "" === path.parseUrl(url).protocol;
},
//Returns true for an absolute url.
isAbsoluteUrl: function(url) {
return "" !== path.parseUrl(url).protocol;
},
//Turn the specified realtive URL into an absolute one. This function
//can handle all relative variants (protocol, site, document, query, fragment).
makeUrlAbsolute: function(relUrl, absUrl) {
if (!path.isRelativeUrl(relUrl)) return relUrl;
void 0 === absUrl && (absUrl = this.documentBase);
var relObj = path.parseUrl(relUrl), absObj = path.parseUrl(absUrl), protocol = relObj.protocol || absObj.protocol, doubleSlash = relObj.protocol ? relObj.doubleSlash : relObj.doubleSlash || absObj.doubleSlash, authority = relObj.authority || absObj.authority, hasPath = "" !== relObj.pathname;
return protocol + doubleSlash + authority + path.makePathAbsolute(relObj.pathname || absObj.filename, absObj.pathname) + (relObj.search || !hasPath && absObj.search || "") + relObj.hash;
},
//Add search (aka query) params to the specified url.
addSearchParams: function(url, params) {
var u = path.parseUrl(url), p = "object" == typeof params ? jQuery.param(params) : params, s = u.search || "?";
return u.hrefNoSearch + s + ("?" !== s.charAt(s.length - 1) ? "&" : "") + p + (u.hash || "");
},
convertUrlToDataUrl: function(absUrl) {
var u = path.parseUrl(absUrl);
return path.isEmbeddedPage(u) ? u.hash.split(dialogHashKey)[0].replace(/^#/, "").replace(/\?.*$/, "") : path.isSameDomain(u, this.documentBase) ? u.hrefNoHash.replace(this.documentBase.domain, "").split(dialogHashKey)[0] : window.decodeURIComponent(absUrl);
},
//get path from current hash, or from a file path
get: function(newPath) {
return undefined3 === newPath && (newPath = path.parseLocation().hash), path.stripHash(newPath).replace(/[^\/]*\.[^\/*]+$/, "");
},
//set location hash to path
set: function(path) {
location.hash = path;
},
//test if a given url (string) is a path
//NOTE might be exceptionally naive
isPath: function(url) {
return /\//.test(url);
},
//return a url path with the window's location protocol/hostname/pathname removed
clean: function(url) {
return url.replace(this.documentBase.domain, "");
},
//just return the url without an initial #
stripHash: function(url) {
return url.replace(/^#/, "");
},
stripQueryParams: function(url) {
return url.replace(/\?.*$/, "");
},
//remove the preceding hash, any query params, and dialog notations
cleanHash: function(hash) {
return path.stripHash(hash.replace(/\?.*$/, "").replace(dialogHashKey, ""));
},
isHashValid: function(hash) {
return /^#[^#]+$/.test(hash);
},
//check whether a url is referencing the same domain, or an external domain or different protocol
//could be mailto, etc
isExternal: function(url) {
var u = path.parseUrl(url);
return !!u.protocol && u.domain !== this.documentUrl.domain;
},
hasProtocol: function(url) {
return /^(:?\w+:)/.test(url);
},
isEmbeddedPage: function(url) {
var u = path.parseUrl(url);
return(//if the path is absolute, then we need to compare the url against
//both the this.documentUrl and the documentBase. The main reason for this
//is that links embedded within external documents will refer to the
//application document, whereas links embedded within the application
//document will be resolved against the document base.
"" !== u.protocol ? !this.isPath(u.hash) && u.hash && (u.hrefNoHash === this.documentUrl.hrefNoHash || this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash) : /^#/.test(u.href));
},
squash: function(url, resolutionUrl) {
var href, cleanedUrl, search, stateIndex, isPath = this.isPath(url), uri = this.parseUrl(url), preservedHash = uri.hash, uiState = "";
return(// produce a url against which we can resole the provided path
resolutionUrl = resolutionUrl || (path.isPath(url) ? path.getLocation() : path.getDocumentUrl()), // If the url is anything but a simple string, remove any preceding hash
// eg #foo/bar -> foo/bar
// #foo -> #foo
cleanedUrl = isPath ? path.stripHash(url) : url, // Split the UI State keys off the href
(stateIndex = // If the url is a full url with a hash check if the parsed hash is a path
// if it is, strip the #, and use it otherwise continue without change
(cleanedUrl = path.isPath(uri.hash) ? path.stripHash(uri.hash) : cleanedUrl).indexOf(this.uiStateKey)) > -1 && (uiState = cleanedUrl.slice(stateIndex), cleanedUrl = cleanedUrl.slice(0, stateIndex)), // make the cleanedUrl absolute relative to the resolution url
href = path.makeUrlAbsolute(cleanedUrl, resolutionUrl), // grab the search from the resolved url since parsing from
// the passed url may not yield the correct result
search = this.parseUrl(href).search, isPath ? ((path.isPath(preservedHash) || 0 === preservedHash.replace("#", "").indexOf(this.uiStateKey)) && (preservedHash = ""), uiState && -1 === preservedHash.indexOf(this.uiStateKey) && (preservedHash += uiState), -1 === preservedHash.indexOf("#") && "" !== preservedHash && (preservedHash = "#" + preservedHash), href = // reconstruct each of the pieces with the new search string and hash
(href = path.parseUrl(href)).protocol + "//" + href.host + href.pathname + search + preservedHash) : href += href.indexOf("#") > -1 ? uiState : "#" + uiState, href);
},
isPreservableHash: function(hash) {
return 0 === hash.replace("#", "").indexOf(this.uiStateKey);
},
// Escape weird characters in the hash if it is to be used as a selector
hashToSelector: function(hash) {
var hasHash = "#" === hash.substring(0, 1);
return hasHash && (hash = hash.substring(1)), (hasHash ? "#" : "") + hash.replace(/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$1");
},
// return the substring of a filepath before the sub-page key, for making
// a server request
getFilePath: function(path) {
var splitkey = "&" + jQuery.mobile.subPageUrlKey;
return path && path.split(splitkey)[0].split(dialogHashKey)[0];
},
// check if the specified url refers to the first page in the main
// application document.
isFirstPageUrl: function(url) {
// We only deal with absolute paths.
var u = path.parseUrl(path.makeUrlAbsolute(url, this.documentBase)), // Does the url have the same path as the document?
samePath = u.hrefNoHash === this.documentUrl.hrefNoHash || this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash, // Get the first page element.
fp = jQuery.mobile.firstPage, // Get the id of the first page element if it has one.
fpId = fp && fp[0] ? fp[0].id : undefined3;
// The url refers to the first page if the path matches the document and
// it either has no hash value, or the hash is exactly equal to the id
// of the first page element.
return samePath && (!u.hash || "#" === u.hash || fpId && u.hash.replace(/^#/, "") === fpId);
},
// Some embedded browsers, like the web view in Phone Gap, allow
// cross-domain XHR requests if the document doing the request was loaded
// via the file:// protocol. This is usually to allow the application to
// "phone home" and fetch app specific data. We normally let the browser
// handle external/cross-domain urls, but if the allowCrossDomainPages
// option is true, we will allow cross-domain http/https requests to go
// through our page loading logic.
isPermittedCrossDomainRequest: function(docUrl, reqUrl) {
return jQuery.mobile.allowCrossDomainPages && ("file:" === docUrl.protocol || "content:" === docUrl.protocol) && -1 !== reqUrl.search(/^https?:/);
}
}, path.documentUrl = path.parseLocation(), $base = jQuery("head").find("base"), path.documentBase = $base.length ? path.parseUrl(path.makeUrlAbsolute($base.attr("href"), path.documentUrl.href)) : path.documentUrl, path.documentBaseDiffers = path.documentUrl.hrefNoHash !== path.documentBase.hrefNoHash, //return the original document base url
path.getDocumentBase = function(asParsedObject) {
return asParsedObject ? jQuery.extend({}, path.documentBase) : path.documentBase.href;
}, // DEPRECATED as of 1.4.0 - remove in 1.5.0
jQuery.extend(jQuery.mobile, {
//return the original document url
getDocumentUrl: path.getDocumentUrl,
//return the original document base url
getDocumentBase: path.getDocumentBase
}), jQuery.mobile.History = function(stack, index) {
this.stack = stack || [], this.activeIndex = index || 0;
}, jQuery.extend(jQuery.mobile.History.prototype, {
getActive: function() {
return this.stack[this.activeIndex];
},
getLast: function() {
return this.stack[this.previousIndex];
},
getNext: function() {
return this.stack[this.activeIndex + 1];
},
getPrev: function() {
return this.stack[this.activeIndex - 1];
},
// addNew is used whenever a new page is added
add: function(url, data) {
data = data || {}, this.getNext() && this.clearForward(), data.hash && -1 === data.hash.indexOf("#") && (data.hash = "#" + data.hash), data.url = url, this.stack.push(data), this.activeIndex = this.stack.length - 1;
},
//wipe urls ahead of active index
clearForward: function() {
this.stack = this.stack.slice(0, this.activeIndex + 1);
},
find: function(url, stack, earlyReturn) {
var entry, i, index, length = (stack = stack || this.stack).length;
for(i = 0; i < length && (entry = stack[i], decodeURIComponent(url) !== decodeURIComponent(entry.url) && decodeURIComponent(url) !== decodeURIComponent(entry.hash) || (index = i, !earlyReturn)); i++);
return index;
},
closest: function(url) {
var closest, a = this.activeIndex;
return void 0 === // First, take the slice of the history stack before the current index and search
// for a url match. If one is found, we'll avoid avoid looking through forward history
// NOTE the preference for backward history movement is driven by the fact that
// most mobile browsers only have a dedicated back button, and users rarely use
// the forward button in desktop browser anyhow
(closest = this.find(url, this.stack.slice(0, a))) && (closest = undefined4 === (closest = this.find(url, this.stack.slice(a), !0)) ? closest : closest + a), closest;
},
direct: function(opts) {
var newActiveIndex = this.closest(opts.url), a = this.activeIndex;
undefined4 !== newActiveIndex && (this.activeIndex = newActiveIndex, this.previousIndex = a), newActiveIndex < a ? (opts.present || opts.back || jQuery.noop)(this.getActive(), "back") : newActiveIndex > a ? (opts.present || opts.forward || jQuery.noop)(this.getActive(), "forward") : undefined4 === newActiveIndex && opts.missing && opts.missing(this.getActive());
}
}), path1 = jQuery.mobile.path, initialHref = location.href, jQuery.mobile.Navigator = function(history1) {
this.history = history1, this.ignoreInitialHashChange = !0, jQuery.mobile.window.bind({
"popstate.history": jQuery.proxy(this.popstate, this),
"hashchange.history": jQuery.proxy(this.hashchange, this)
});
}, jQuery.extend(jQuery.mobile.Navigator.prototype, {
squash: function(url, data) {
var state, href, hash = path1.isPath(url) ? path1.stripHash(url) : url;
return href = path1.squash(url), // make sure to provide this information when it isn't explicitly set in the
// data object that was passed to the squash method
state = jQuery.extend({
hash: hash,
url: href
}, data), // replace the current url with the new href and store the state
// Note that in some cases we might be replacing an url with the
// same url. We do this anyways because we need to make sure that
// all of our history entries have a state object associated with
// them. This allows us to work around the case where $.mobile.back()
// is called to transition from an external page to an embedded page.
// In that particular case, a hashchange event is *NOT* generated by the browser.
// Ensuring each history entry has a state object means that onPopState()
// will always trigger our hashchange callback even when a hashchange event
// is not fired.
window.history.replaceState(state, state.title || document1.title, href), state;
},
hash: function(url, href) {
var parsed, loc, hash, resolved;
return(// Grab the hash for recording. If the passed url is a path
// we used the parsed version of the squashed url to reconstruct,
// otherwise we assume it's a hash and store it directly
parsed = path1.parseUrl(url), (loc = path1.parseLocation()).pathname + loc.search === parsed.pathname + parsed.search ? parsed.hash ? parsed.hash : parsed.pathname + parsed.search : path1.isPath(url) ? (resolved = path1.parseUrl(href)).pathname + resolved.search + (path1.isPreservableHash(resolved.hash) ? resolved.hash.replace("#", "") : "") : url);
},
// TODO reconsider name
go: function(url, data, noEvents) {
var state, href, hash, popstateEvent, isPopStateEvent = jQuery.event.special.navigate.isPushStateEnabled();
// Get the url as it would look squashed on to the current resolution url
href = path1.squash(url), // sort out what the hash sould be from the url
hash = this.hash(url, href), noEvents && hash !== path1.stripHash(path1.parseLocation().hash) && (this.preventNextHashChange = noEvents), // IMPORTANT in the case where popstate is supported the event will be triggered
// directly, stopping further execution - ie, interupting the flow of this
// method call to fire bindings at this expression. Below the navigate method
// there is a binding to catch this event and stop its propagation.
//
// We then trigger a new popstate event on the window with a null state
// so that the navigate events can conclude their work properly
//
// if the url is a path we want to preserve the query params that are available on
// the current url.
this.preventHashAssignPopState = !0, window.location.hash = hash, // If popstate is enabled and the browser triggers `popstate` events when the hash
// is set (this often happens immediately in browsers like Chrome), then the
// this flag will be set to false already. If it's a browser that does not trigger
// a `popstate` on hash assignement or `replaceState` then we need avoid the branch
// that swallows the event created by the popstate generated by the hash assignment
// At the time of this writing this happens with Opera 12 and some version of IE
this.preventHashAssignPopState = !1, state = jQuery.extend({
url: href,
hash: hash,
title: document1.title
}, data), isPopStateEvent && ((popstateEvent = new jQuery.Event("popstate")).originalEvent = {
type: "popstate",
state: null
}, this.squash(url, state), noEvents || (this.ignorePopState = !0, jQuery.mobile.window.trigger(popstateEvent))), // record the history entry so that the information can be included
// in hashchange event driven navigate events in a similar fashion to
// the state that's provided by popstate
this.history.add(state.url, state);
},
// This binding is intended to catch the popstate events that are fired
// when execution of the `$.navigate` method stops at window.location.hash = url;
// and completely prevent them from propagating. The popstate event will then be
// retriggered after execution resumes
//
// TODO grab the original event here and use it for the synthetic event in the
// second half of the navigate execution that will follow this binding
popstate: function(event1) {
var hash, state;
// Partly to support our test suite which manually alters the support
// value to test hashchange. Partly to prevent all around weirdness
if (jQuery.event.special.navigate.isPushStateEnabled()) {
// If this is the popstate triggered by the actual alteration of the hash
// prevent it completely. History is tracked manually
if (this.preventHashAssignPopState) {
this.preventHashAssignPopState = !1, event1.stopImmediatePropagation();
return;
}
// if this is the popstate triggered after the `replaceState` call in the go
// method, then simply ignore it. The history entry has already been captured
if (this.ignorePopState) {
this.ignorePopState = !1;
return;
}
// If there is no state, and the history stack length is one were
// probably getting the page load popstate fired by browsers like chrome
// avoid it and set the one time flag to false.
// TODO: Do we really need all these conditions? Comparing location hrefs
// should be sufficient.
if (!event1.originalEvent.state && 1 === this.history.stack.length && this.ignoreInitialHashChange && (this.ignoreInitialHashChange = !1, location.href === initialHref)) {
event1.preventDefault();
return;
}
if (// account for direct manipulation of the hash. That is, we will receive a popstate
// when the hash is changed by assignment, and it won't have a state associated. We
// then need to squash the hash. See below for handling of hash assignment that
// matches an existing history entry
// TODO it might be better to only add to the history stack
// when the hash is adjacent to the active history entry
hash = path1.parseLocation().hash, !event1.originalEvent.state && hash) {
// squash the hash that's been assigned on the URL with replaceState
// also grab the resulting state object for storage
state = this.squash(hash), // record the new hash as an additional history entry
// to match the browser's treatment of hash assignment
this.history.add(state.url, state), // pass the newly created state information
// along with the event
event1.historyState = state;
// do not alter history, we've added a new history entry
// so we know where we are
return;
}
// If all else fails this is a popstate that comes from the back or forward buttons
// make sure to set the state of our history stack properly, and record the directionality
this.history.direct({
url: (event1.originalEvent.state || {}).url || hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function(historyEntry, direction) {
// make sure to create a new object to pass down as the navigate event data
event1.historyState = jQuery.extend({}, historyEntry), event1.historyState.direction = direction;
}
});
}
},
// NOTE must bind before `navigate` special event hashchange binding otherwise the
// navigation data won't be attached to the hashchange event in time for those
// bindings to attach it to the `navigate` special event
// TODO add a check here that `hashchange.navigate` is bound already otherwise it's
// broken (exception?)
hashchange: function(event1) {
var history1, hash;
// If hashchange listening is explicitly disabled or pushstate is supported
// avoid making use of the hashchange handler.
if (!(!jQuery.event.special.navigate.isHashChangeEnabled() || jQuery.event.special.navigate.isPushStateEnabled())) {
// On occasion explicitly want to prevent the next hash from propogating because we only
// with to alter the url to represent the new state do so here
if (this.preventNextHashChange) {
this.preventNextHashChange = !1, event1.stopImmediatePropagation();
return;
}
history1 = this.history, hash = path1.parseLocation().hash, // If this is a hashchange caused by the back or forward button
// make sure to set the state of our history stack properly
this.history.direct({
url: hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function(historyEntry, direction) {
// make sure to create a new object to pass down as the navigate event data
event1.hashchangeState = jQuery.extend({}, historyEntry), event1.hashchangeState.direction = direction;
},
// When we don't find a hash in our history clearly we're aiming to go there
// record the entry as new for future traversal
//
// NOTE it's not entirely clear that this is the right thing to do given that we
// can't know the users intention. It might be better to explicitly _not_
// support location.hash assignment in preference to $.navigate calls
// TODO first arg to add should be the href, but it causes issues in identifying
// embeded pages
missing: function() {
history1.add(hash, {
hash: hash,
title: document1.title
});
}
});
}
}
}), function($, undefined) {
// TODO consider queueing navigation activity until previous activities have completed
// so that end users don't have to think about it. Punting for now
// TODO !! move the event bindings into callbacks on the navigate event
$.mobile.navigate = function(url, data, noEvents) {
$.mobile.navigate.navigator.go(url, data, noEvents);
}, // expose the history on the navigate method in anticipation of full integration with
// existing navigation functionalty that is tightly coupled to the history information
$.mobile.navigate.history = new $.mobile.History(), // instantiate an instance of the navigator for use within the $.navigate method
$.mobile.navigate.navigator = new $.mobile.Navigator($.mobile.navigate.history);
var loc = $.mobile.path.parseLocation();
$.mobile.navigate.history.add(loc.href, {
hash: loc.hash
});
}(jQuery), props = {
animation: {},
transition: {}
}, testElement = document1.createElement("a"), vendorPrefixes = [
"",
"webkit-",
"moz-",
"o-"
], jQuery.each([
"animation",
"transition"
], function(i, test) {
// Get correct name for test
var testName = 0 === i ? test + "-name" : test;
jQuery.each(vendorPrefixes, function(j, prefix) {
if (testElement.style[jQuery.camelCase(prefix + testName)] !== undefined5) return props[test].prefix = prefix, !1;
}), // Set event and duration names for later use
props[test].duration = jQuery.camelCase(props[test].prefix + test + "-duration"), props[test].event = jQuery.camelCase(props[test].prefix + test + "-end"), "" === props[test].prefix && (props[test].event = props[test].event.toLowerCase());
}), // If a valid prefix was found then the it is supported by the browser
jQuery.support.cssTransitions = props.transition.prefix !== undefined5, jQuery.support.cssAnimations = props.animation.prefix !== undefined5, // Remove the testElement
jQuery(testElement).remove(), // Animation complete callback
jQuery.fn.animationComplete = function(callback, type, fallbackTime) {
var timer, duration, that = this, animationType = type && "animation" !== type ? "transition" : "animation";
return(// Make sure selected type is supported by browser
jQuery.support.cssTransitions && "transition" === animationType || jQuery.support.cssAnimations && "animation" === animationType ? (undefined5 === fallbackTime && (jQuery(this).context !== document1 && // Parse the durration since its in second multiple by 1000 for milliseconds
// Multiply by 3 to make sure we give the animation plenty of time.
(duration = 3000 * parseFloat(jQuery(this).css(props[animationType].duration))), (0 === duration || undefined5 === duration || isNaN(duration)) && (duration = jQuery.fn.animationComplete.defaultDuration)), // Sets up the fallback if event never comes
timer = setTimeout(function() {
jQuery(that).off(props[animationType].event), callback.apply(that);
}, duration), jQuery(this).one(props[animationType].event, function() {
// Clear the timer so we dont call callback twice
clearTimeout(timer), callback.call(this, arguments);
})) : (// CSS animation / transitions not supported
// Defer execution for consistency between webkit/non webkit
setTimeout(jQuery.proxy(callback, this), 0), jQuery(this)));
}, // Allow default callback to be configured on mobileInit
jQuery.fn.animationComplete.defaultDuration = 1000, // This plugin is an experiment for abstracting away the touch and mouse
// events so that developers don't have to worry about which method of input
// the device their document is loaded on supports.
//
// The idea here is to allow the developer to register listeners for the
// basic mouse events, such as mousedown, mousemove, mouseup, and click,
// and the plugin will take care of registering the correct listeners
// behind the scenes to invoke the listener at the fastest possible time
// for that device, while still retaining the order of event firing in
// the traditional mouse environment, should multiple handlers be registered
// on the same element for different events.
//
// The current version exposes the following virtual events to jQuery bind methods:
// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
function($, window, document1, undefined) {
var threshold, i, dataPropertyName = "virtualMouseBindings", touchTargetPropertyName = "virtualTouchID", virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split(" "), touchEventProps = "clientX clientY pageX pageY screenX screenY".split(" "), mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [], mouseEventProps = $.event.props.concat(mouseHookProps), activeDocHandlers = {}, resetTimerID = 0, startX = 0, startY = 0, didScroll = !1, clickBlockList = [], blockMouseTriggers = !1, blockTouchTriggers = !1, eventCaptureSupported = "addEventListener" in document1, $document = $(document1), nextTouchID = 1, lastTouchID = 0;
function getNativeEvent(event1) {
for(; event1 && void 0 !== event1.originalEvent;)event1 = event1.originalEvent;
return event1;
}
function getVirtualBindingFlags(element) {
for(var b, k, flags = {}; element;){
for(k in b = $.data(element, dataPropertyName))b[k] && (flags[k] = flags.hasVirtualBinding = !0);
element = element.parentNode;
}
return flags;
}
$.vmouse = {
moveDistanceThreshold: 10,
clickDistanceThreshold: 10,
resetTimerDuration: 1500
};
function startResetTimer() {
clearResetTimer(), resetTimerID = setTimeout(function() {
resetTimerID = 0, lastTouchID = 0, clickBlockList.length = 0, blockMouseTriggers = !1, blockTouchTriggers = !0;
}, $.vmouse.resetTimerDuration);
}
function clearResetTimer() {
resetTimerID && (clearTimeout(resetTimerID), resetTimerID = 0);
}
function triggerVirtualEvent(eventType, event1, flags) {
var ve;
return (flags && flags[eventType] || !flags && function(element, eventType) {
for(var b; element;){
if ((b = $.data(element, dataPropertyName)) && (!eventType || b[eventType])) return element;
element = element.parentNode;
}
return null;
}(event1.target, eventType)) && (ve = function(event1, eventType) {
var oe, props, ne, prop, ct, touch, i, j, len, t = event1.type;
// copy original event properties over to the new event
// this would happen if we could call $.event.fix instead of $.Event
// but we don't have a way to force an event to be fixed multiple times
if ((event1 = $.Event(event1)).type = eventType, oe = event1.originalEvent, props = $.event.props, t.search(/^(mouse|click)/) > -1 && (props = mouseEventProps), oe) for(i = props.length; i;)event1[prop = props[--i]] = oe[prop];
if (t.search(/mouse(down|up)|click/) > -1 && !event1.which && (event1.which = 1), -1 !== t.search(/^touch/) && (t = (ne = getNativeEvent(oe)).touches, ct = ne.changedTouches, touch = t && t.length ? t[0] : ct && ct.length ? ct[0] : void 0)) for(j = 0, len = touchEventProps.length; j < len; j++)event1[prop = touchEventProps[j]] = touch[prop];
return event1;
}(event1, eventType), $(event1.target).trigger(ve)), ve;
}
function mouseEventCallback(event1) {
var ve, touchID = $.data(event1.target, touchTargetPropertyName);
!blockMouseTriggers && (!lastTouchID || lastTouchID !== touchID) && (ve = triggerVirtualEvent("v" + event1.type, event1)) && (ve.isDefaultPrevented() && event1.preventDefault(), ve.isPropagationStopped() && event1.stopPropagation(), ve.isImmediatePropagationStopped() && event1.stopImmediatePropagation());
}
function handleTouchStart(event1) {
var target, flags, t, touches = getNativeEvent(event1).touches;
touches && 1 === touches.length && (flags = getVirtualBindingFlags(target = event1.target)).hasVirtualBinding && (lastTouchID = nextTouchID++, $.data(target, touchTargetPropertyName, lastTouchID), clearResetTimer(), blockTouchTriggers = !1, didScroll = !1, startX = (t = getNativeEvent(event1).touches[0]).pageX, startY = t.pageY, triggerVirtualEvent("vmouseover", event1, flags), triggerVirtualEvent("vmousedown", event1, flags));
}
function handleScroll(event1) {
!blockTouchTriggers && (didScroll || triggerVirtualEvent("vmousecancel", event1, getVirtualBindingFlags(event1.target)), didScroll = !0, startResetTimer());
}
function handleTouchMove(event1) {
if (!blockTouchTriggers) {
var t = getNativeEvent(event1).touches[0], didCancel = didScroll, moveThreshold = $.vmouse.moveDistanceThreshold, flags = getVirtualBindingFlags(event1.target);
(didScroll = didScroll || Math.abs(t.pageX - startX) > moveThreshold || Math.abs(t.pageY - startY) > moveThreshold) && !didCancel && triggerVirtualEvent("vmousecancel", event1, flags), triggerVirtualEvent("vmousemove", event1, flags), startResetTimer();
}
}
function handleTouchEnd(event1) {
if (!blockTouchTriggers) {
blockTouchTriggers = !0;
var ve, t, flags = getVirtualBindingFlags(event1.target);
triggerVirtualEvent("vmouseup", event1, flags), !didScroll && (ve = triggerVirtualEvent("vclick", event1, flags)) && ve.isDefaultPrevented() && (// The target of the mouse events that follow the touchend
// event don't necessarily match the target used during the
// touch. This means we need to rely on coordinates for blocking
// any click that is generated.
t = getNativeEvent(event1).changedTouches[0], clickBlockList.push({
touchID: lastTouchID,
x: t.clientX,
y: t.clientY
}), // Prevent any mouse events that follow from triggering
// virtual event notifications.
blockMouseTriggers = !0), triggerVirtualEvent("vmouseout", event1, flags), didScroll = !1, startResetTimer();
}
}
function hasVirtualBindings(ele) {
var k, bindings = $.data(ele, dataPropertyName);
if (bindings) {
for(k in bindings)if (bindings[k]) return !0;
}
return !1;
}
function dummyMouseHandler() {}
// Expose our custom events to the jQuery bind/unbind mechanism.
for(i = 0; i < virtualEventNames.length; i++)$.event.special[virtualEventNames[i]] = function(eventType) {
var realType = eventType.substr(1);
return {
setup: function() {
hasVirtualBindings(this) || $.data(this, dataPropertyName, {}), $.data(this, dataPropertyName)[eventType] = !0, // If this is the first virtual mouse event for this type,
// register a global handler on the document.
activeDocHandlers[eventType] = (activeDocHandlers[eventType] || 0) + 1, 1 === activeDocHandlers[eventType] && $document.bind(realType, mouseEventCallback), // Some browsers, like Opera Mini, won't dispatch mouse/click events
// for elements unless they actually have handlers registered on them.
// To get around this, we register dummy handlers on the elements.
$(this).bind(realType, dummyMouseHandler), eventCaptureSupported && (// If this is the first virtual mouse binding for the document,
// register our touchstart handler on the document.
activeDocHandlers.touchstart = (activeDocHandlers.touchstart || 0) + 1, 1 === activeDocHandlers.touchstart && $document.bind("touchstart", handleTouchStart).bind("touchend", handleTouchEnd)// On touch platforms, touching the screen and then dragging your finger
// causes the window content to scroll after some distance threshold is
// exceeded. On these platforms, a scroll prevents a click event from being
// dispatched, and on some platforms, even the touchend is suppressed. To
// mimic the suppression of the click event, we need to watch for a scroll
// event. Unfortunately, some platforms like iOS don't dispatch scroll
// events until *AFTER* the user lifts their finger (touchend). This means
// we need to watch both scroll and touchmove events to figure out whether
// or not a scroll happenens before the touchend event is fired.
.bind("touchmove", handleTouchMove).bind("scroll", handleScroll));
},
teardown: function() {
// If this is the last virtual binding for this eventType,
// remove its global handler from the document.
--activeDocHandlers[eventType], activeDocHandlers[eventType] || $document.unbind(realType, mouseEventCallback), eventCaptureSupported && (// If this is the last virtual mouse binding in existence,
// remove our document touchstart listener.
--activeDocHandlers.touchstart, activeDocHandlers.touchstart || $document.unbind("touchstart", handleTouchStart).unbind("touchmove", handleTouchMove).unbind("touchend", handleTouchEnd).unbind("scroll", handleScroll));
var $this = $(this), bindings = $.data(this, dataPropertyName);
bindings && (bindings[eventType] = !1), // Unregister the dummy event handler.
$this.unbind(realType, dummyMouseHandler), hasVirtualBindings(this) || $this.removeData(dataPropertyName);
}
};
}(virtualEventNames[i]);
eventCaptureSupported && document1.addEventListener("click", function(e) {
var x, y, ele, i, o, cnt = clickBlockList.length, target = e.target;
if (cnt) for(x = e.clientX, y = e.clientY, threshold = $.vmouse.clickDistanceThreshold, // The idea here is to run through the clickBlockList to see if
// the current click event is in the proximity of one of our
// vclick events that had preventDefault() called on it. If we find
// one, then we block the click.
//
// Why do we have to rely on proximity?
//
// Because the target of the touch event that triggered the vclick
// can be different from the target of the click event synthesized
// by the browser. The target of a mouse/click event that is synthesized
// from a touch event seems to be implementation specific. For example,
// some browsers will fire mouse/click events for a link that is near
// a touch event, even though the target of the touchstart/touchend event
// says the user touched outside the link. Also, it seems that with most
// browsers, the target of the mouse/click event is not calculated until the
// time it is dispatched, so if you replace an element that you touched
// with another element, the target of the mouse/click will be the new
// element underneath that point.
//
// Aside from proximity, we also check to see if the target and any
// of its ancestors were the ones that blocked a click. This is necessary
// because of the strange mouse/click target calculation done in the
// Android 2.1 browser, where if you click on an element, and there is a
// mouse/click handler on one of its ancestors, the target will be the
// innermost child of the touched element, even if that child is no where
// near the point of touch.
ele = target; ele;){
for(i = 0; i < cnt; i++)if (o = clickBlockList[i], ele === target && Math.abs(o.x - x) < threshold && Math.abs(o.y - y) < threshold || $.data(ele, touchTargetPropertyName) === o.touchID) {
// XXX: We may want to consider removing matches from the block list
// instead of waiting for the reset timer to fire.
e.preventDefault(), e.stopPropagation();
return;
}
ele = ele.parentNode;
}
}, !0);
}(jQuery, 0, document1), function($, window, undefined) {
var $document = $(document1), supportTouch = $.mobile.support.touch, scrollEvent = "touchmove scroll", touchStartEvent = supportTouch ? "touchstart" : "mousedown", touchStopEvent = supportTouch ? "touchend" : "mouseup", touchMoveEvent = supportTouch ? "touchmove" : "mousemove";
function triggerCustomEvent(obj, eventType, event1, bubble) {
var originalType = event1.type;
event1.type = eventType, bubble ? $.event.trigger(event1, void 0, obj) : $.event.dispatch.call(obj, event1), event1.type = originalType;
}
// setup new event shortcuts
$.each("touchstart touchmove touchend tap taphold swipe swipeleft swiperight scrollstart scrollstop".split(" "), function(i, name) {
$.fn[name] = function(fn) {
return fn ? this.bind(name, fn) : this.trigger(name);
}, $.attrFn && ($.attrFn[name] = !0);
}), // also handles scrollstop
$.event.special.scrollstart = {
enabled: !0,
setup: function() {
var scrolling, timer, thisObject = this;
function trigger(event1, state) {
triggerCustomEvent(thisObject, (scrolling = state) ? "scrollstart" : "scrollstop", event1);
}
// iPhone triggers scroll after a small delay; use touchmove instead
$(thisObject).bind(scrollEvent, function(event1) {
$.event.special.scrollstart.enabled && (scrolling || trigger(event1, !0), clearTimeout(timer), timer = setTimeout(function() {
trigger(event1, !1);
}, 50));
});
},
teardown: function() {
$(this).unbind(scrollEvent);
}
}, // also handles taphold
$.event.special.tap = {
tapholdThreshold: 750,
emitTapOnTaphold: !0,
setup: function() {
var thisObject = this, $this = $(thisObject), isTaphold = !1;
$this.bind("vmousedown", function(event1) {
if (isTaphold = !1, event1.which && 1 !== event1.which) return !1;
var timer, origTarget = event1.target;
function clearTapTimer() {
clearTimeout(timer);
}
function clearTapHandlers() {
clearTapTimer(), $this.unbind("vclick", clickHandler).unbind("vmouseup", clearTapTimer), $document.unbind("vmousecancel", clearTapHandlers);
}
function clickHandler(event1) {
clearTapHandlers(), isTaphold || origTarget !== event1.target ? isTaphold && event1.stopPropagation() : triggerCustomEvent(thisObject, "tap", event1);
}
$this.bind("vmouseup", clearTapTimer).bind("vclick", clickHandler), $document.bind("vmousecancel", clearTapHandlers), timer = setTimeout(function() {
$.event.special.tap.emitTapOnTaphold || (isTaphold = !0), triggerCustomEvent(thisObject, "taphold", $.Event("taphold", {
target: origTarget
}));
}, $.event.special.tap.tapholdThreshold);
});
},
teardown: function() {
$(this).unbind("vmousedown").unbind("vclick").unbind("vmouseup"), $document.unbind("vmousecancel");
}
}, // Also handles swipeleft, swiperight
$.event.special.swipe = {
// More than this horizontal displacement, and we will suppress scrolling.
scrollSupressionThreshold: 30,
// More time than this, and it isn't a swipe.
durationThreshold: 1000,
// Swipe horizontal displacement must be more than this.
horizontalDistanceThreshold: 30,
// Swipe vertical displacement must be less than this.
verticalDistanceThreshold: 30,
getLocation: function(event1) {
var winPageX = window.pageXOffset, winPageY = window.pageYOffset, x = event1.clientX, y = event1.clientY;
return 0 === event1.pageY && Math.floor(y) > Math.floor(event1.pageY) || 0 === event1.pageX && Math.floor(x) > Math.floor(event1.pageX) ? (// iOS4 clientX/clientY have the value that should have been
// in pageX/pageY. While pageX/page/ have the value 0
x -= winPageX, y -= winPageY) : (y < event1.pageY - winPageY || x < event1.pageX - winPageX) && (// Some Android browsers have totally bogus values for clientX/Y
// when scrolling/zooming a page. Detectable since clientX/clientY
// should never be smaller than pageX/pageY minus page scroll
x = event1.pageX - winPageX, y = event1.pageY - winPageY), {
x: x,
y: y
};
},
start: function(event1) {
var data = event1.originalEvent.touches ? event1.originalEvent.touches[0] : event1, location1 = $.event.special.swipe.getLocation(data);
return {
time: new Date().getTime(),
coords: [
location1.x,
location1.y
],
origin: $(event1.target)
};
},
stop: function(event1) {
var data = event1.originalEvent.touches ? event1.originalEvent.touches[0] : event1, location1 = $.event.special.swipe.getLocation(data);
return {
time: new Date().getTime(),
coords: [
location1.x,
location1.y
]
};
},
handleSwipe: function(start, stop, thisObject, origTarget) {
if (stop.time - start.time < $.event.special.swipe.durationThreshold && Math.abs(start.coords[0] - stop.coords[0]) > $.event.special.swipe.horizontalDistanceThreshold && Math.abs(start.coords[1] - stop.coords[1]) < $.event.special.swipe.verticalDistanceThreshold) {
var direction = start.coords[0] > stop.coords[0] ? "swipeleft" : "swiperight";
return triggerCustomEvent(thisObject, "swipe", $.Event("swipe", {
target: origTarget,
swipestart: start,
swipestop: stop
}), !0), triggerCustomEvent(thisObject, direction, $.Event(direction, {
target: origTarget,
swipestart: start,
swipestop: stop
}), !0), !0;
}
return !1;
},
// This serves as a flag to ensure that at most one swipe event event is
// in work at any given time
eventInProgress: !1,
setup: function() {
var events, thisObject = this, $this = $(thisObject), context = {};
// Retrieve the events data for this element and add the swipe context
(events = $.data(this, "mobile-events")) || (events = {
length: 0
}, $.data(this, "mobile-events", events)), events.length++, events.swipe = context, context.start = function(event1) {
// Bail if we're already working on a swipe event
if (!$.event.special.swipe.eventInProgress) {
$.event.special.swipe.eventInProgress = !0;
var stop, start = $.event.special.swipe.start(event1), origTarget = event1.target, emitted = !1;
context.move = function(event1) {
start && (stop = $.event.special.swipe.stop(event1), !emitted && (emitted = $.event.special.swipe.handleSwipe(start, stop, thisObject, origTarget)) && // Reset the context to make way for the next swipe event
($.event.special.swipe.eventInProgress = !1), Math.abs(start.coords[0] - stop.coords[0]) > $.event.special.swipe.scrollSupressionThreshold && event1.preventDefault());
}, context.stop = function() {
emitted = !0, // Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = !1, $document.off(touchMoveEvent, context.move), context.move = null;
}, $document.on(touchMoveEvent, context.move).one(touchStopEvent, context.stop);
}
}, $this.on(touchStartEvent, context.start);
},
teardown: function() {
var events, context;
(events = $.data(this, "mobile-events")) && (context = events.swipe, delete events.swipe, events.length--, 0 === events.length && $.removeData(this, "mobile-events")), context && (context.start && $(this).off(touchStartEvent, context.start), context.move && $document.off(touchMoveEvent, context.move), context.stop && $document.off(touchStopEvent, context.stop));
}
}, $.each({
scrollstop: "scrollstart",
taphold: "tap",
swipeleft: "swipe",
swiperight: "swipe"
}, function(event1, sourceEvent) {
$.event.special[event1] = {
setup: function() {
$(this).bind(sourceEvent, $.noop);
},
teardown: function() {
$(this).unbind(sourceEvent);
}
};
});
}(jQuery, this), jQuery.event.special.throttledresize = {
setup: function() {
jQuery(this).bind("resize", handler);
},
teardown: function() {
jQuery(this).unbind("resize", handler);
}
}, handler = function() {
(diff = (curr = new Date().getTime()) - lastCall) >= 250 ? (lastCall = curr, jQuery(this).trigger("throttledresize")) : (heldCall && clearTimeout(heldCall), // Promise a held call will still execute
heldCall = setTimeout(handler, 250 - diff));
}, lastCall = 0, function($, window) {
var get_orientation, last_orientation, initial_orientation_is_landscape, initial_orientation_is_default, ww, wh, win = $(window), event_name = "orientationchange", portrait_map = {
0: !0,
180: !0
};
// If the event is not supported natively, this handler will be bound to
// the window resize event to simulate the orientationchange event.
function handler() {
// Get the current orientation.
var orientation = get_orientation();
orientation !== last_orientation && (// The orientation has changed, so trigger the orientationchange event.
last_orientation = orientation, win.trigger(event_name));
}
$.support.orientation && (// Check the window width and height to figure out what the current orientation
// of the device is at this moment. Note that we've initialized the portrait map
// values to 0 and 180, *AND* we purposely check for landscape so that if we guess
// wrong, , we default to the assumption that portrait is the default orientation.
// We use a threshold check below because on some platforms like iOS, the iPhone
// form-factor can report a larger width than height if the user turns on the
// developer console. The actual threshold value is somewhat arbitrary, we just
// need to make sure it is large enough to exclude the developer console case.
ww = window.innerWidth || win.width(), initial_orientation_is_landscape = ww > (wh = window.innerHeight || win.height()) && ww - wh > 50, // Now check to see if the current window.orientation is 0 or 180.
initial_orientation_is_default = portrait_map[window.orientation], (initial_orientation_is_landscape && initial_orientation_is_default || !initial_orientation_is_landscape && !initial_orientation_is_default) && (portrait_map = {
"-90": !0,
90: !0
})), $.event.special.orientationchange = $.extend({}, $.event.special.orientationchange, {
setup: function() {
// If the event is supported natively, return false so that jQuery
// will bind to the event using DOM methods.
if ($.support.orientation && !$.event.special.orientationchange.disabled) return !1;
// Get the current orientation to avoid initial double-triggering.
last_orientation = get_orientation(), // Because the orientationchange event doesn't exist, simulate the
// event by testing window dimensions on resize.
win.bind("throttledresize", handler);
},
teardown: function() {
// If the event is not supported natively, return false so that
// jQuery will unbind the event using DOM methods.
if ($.support.orientation && !$.event.special.orientationchange.disabled) return !1;
// Because the orientationchange event doesn't exist, unbind the
// resize event handler.
win.unbind("throttledresize", handler);
},
add: function(handleObj) {
// Save a reference to the bound event handler.
var old_handler = handleObj.handler;
handleObj.handler = function(event1) {
// Call the originally-bound event handler and return its result.
return(// Modify event object, adding the .orientation property.
event1.orientation = get_orientation(), old_handler.apply(this, arguments));
};
}
}), // Get the current page orientation. This method is exposed publicly, should it
// be needed, as jQuery.event.special.orientationchange.orientation()
$.event.special.orientationchange.orientation = get_orientation = function() {
var isPortrait = !0, elem = document1.documentElement;
return ($.support.orientation ? portrait_map[window.orientation] : elem && elem.clientWidth / elem.clientHeight < 1.1) ? "portrait" : "landscape";
}, $.fn[event_name] = function(fn) {
return fn ? this.bind(event_name, fn) : this.trigger(event_name);
}, $.attrFn && ($.attrFn[event_name] = !0);
}(jQuery, this), base = {
// define base element, for use in routing asset urls that are referenced
// in Ajax-requested markup
element: (baseElement = jQuery("head").children("base")).length ? baseElement : jQuery("<base>", {
href: jQuery.mobile.path.documentBase.hrefNoHash
}).prependTo(jQuery("head")),
linkSelector: "[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]",
// set the generated BASE element's href to a new page's base path
set: function(href) {
// we should do nothing if the user wants to manage their url base
// manually
jQuery.mobile.dynamicBaseEnabled && jQuery.support.dynamicBaseTag && base.element.attr("href", jQuery.mobile.path.makeUrlAbsolute(href, jQuery.mobile.path.documentBase));
},
rewrite: function(href, page) {
var newPath = jQuery.mobile.path.get(href);
page.find(base.linkSelector).each(function(i, link) {
var thisAttr = jQuery(link).is("[href]") ? "href" : jQuery(link).is("[src]") ? "src" : "action", thisUrl = jQuery(link).attr(thisAttr);
// XXX_jblas: We need to fix this so that it removes the document
// base URL, and then prepends with the new page URL.
// if full path exists and is same, chop it - helps IE out
thisUrl = thisUrl.replace(location.protocol + "//" + location.host + location.pathname, ""), /^(\w+:|#|\/)/.test(thisUrl) || jQuery(link).attr(thisAttr, newPath + thisUrl);
});
},
// set the generated BASE element's href to a new page's base path
reset: function() {
base.element.attr("href", jQuery.mobile.path.documentBase.hrefNoSearch);
}
}, jQuery.mobile.base = base, jQuery.mobile.widgets = {}, originalWidget = jQuery.widget, keepNativeFactoryDefault = jQuery.mobile.keepNative, orig = jQuery.widget, jQuery.widget = function() {
var constructor = orig.apply(this, arguments), name = constructor.prototype.widgetName;
return constructor.initSelector = constructor.prototype.initSelector !== undefined6 ? constructor.prototype.initSelector : ":jqmData(role='" + name + "')", jQuery.mobile.widgets[name] = constructor, constructor;
}, // Make sure $.widget still has bridge and extend methods
jQuery.extend(jQuery.widget, originalWidget), // For backcompat remove in 1.5
jQuery.mobile.document.on("create", function(event1) {
jQuery(event1.target).enhanceWithin();
}), jQuery.widget("mobile.page", {
options: {
theme: "a",
domCache: !1,
// Deprecated in 1.4 remove in 1.5
keepNativeDefault: jQuery.mobile.keepNative,
// Deprecated in 1.4 remove in 1.5
contentTheme: null,
enhanced: !1
},
// DEPRECATED for > 1.4
// TODO remove at 1.5
_createWidget: function() {
jQuery.Widget.prototype._createWidget.apply(this, arguments), this._trigger("init");
},
_create: function() {
// If false is returned by the callbacks do not create the page
if (!1 === this._trigger("beforecreate")) return !1;
this.options.enhanced || this._enhance(), this._on(this.element, {
pagebeforehide: "removeContainerBackground",
pagebeforeshow: "_handlePageBeforeShow"
}), this.element.enhanceWithin(), "dialog" === jQuery.mobile.getAttribute(this.element[0], "role") && jQuery.mobile.dialog && this.element.dialog();
},
_enhance: function() {
var attrPrefix = "data-" + jQuery.mobile.ns, self = this;
this.options.role && this.element.attr("data-" + jQuery.mobile.ns + "role", this.options.role), this.element.attr("tabindex", "0").addClass("ui-page ui-page-theme-" + this.options.theme), // Manipulation of content os Deprecated as of 1.4 remove in 1.5
this.element.find("[" + attrPrefix + "role='content']").each(function() {
var $this = jQuery(this), theme = this.getAttribute(attrPrefix + "theme") || undefined6;
self.options.contentTheme = theme || self.options.contentTheme || self.options.dialog && self.options.theme || "dialog" === self.element.jqmData("role") && self.options.theme, $this.addClass("ui-content"), self.options.contentTheme && $this.addClass("ui-body-" + self.options.contentTheme), // Add ARIA role
$this.attr("role", "main").addClass("ui-content");
});
},
bindRemove: function(callback) {
var page = this.element;
// when dom caching is not enabled or the page is embedded bind to remove the page on hide
!page.data("mobile-page").options.domCache && page.is(":jqmData(external-page='true')") && // TODO use _on - that is, sort out why it doesn't work in this case
page.bind("pagehide.remove", callback || function(e, data) {
//check if this is a same page transition and if so don't remove the page
if (!data.samePage) {
var $this = jQuery(this), prEvent = new jQuery.Event("pageremove");
$this.trigger(prEvent), prEvent.isDefaultPrevented() || $this.removeWithDependents();
}
});
},
_setOptions: function(o) {
o.theme !== undefined6 && this.element.removeClass("ui-page-theme-" + this.options.theme).addClass("ui-page-theme-" + o.theme), o.contentTheme !== undefined6 && this.element.find("[data-" + jQuery.mobile.ns + "='content']").removeClass("ui-body-" + this.options.contentTheme).addClass("ui-body-" + o.contentTheme);
},
_handlePageBeforeShow: function() {
this.setContainerBackground();
},
// Deprecated in 1.4 remove in 1.5
removeContainerBackground: function() {
this.element.closest(":mobile-pagecontainer").pagecontainer({
theme: "none"
});
},
// Deprecated in 1.4 remove in 1.5
// set the page container background to the page theme
setContainerBackground: function(theme) {
this.element.parent().pagecontainer({
theme: theme || this.options.theme
});
},
// Deprecated in 1.4 remove in 1.5
keepNativeSelector: function() {
var options = this.options, keepNative = jQuery.trim(options.keepNative || ""), globalValue = jQuery.trim(jQuery.mobile.keepNative), optionValue = jQuery.trim(options.keepNativeDefault), // Check if $.mobile.keepNative has changed from the factory default
newDefault = keepNativeFactoryDefault === globalValue ? "" : globalValue, // If $.mobile.keepNative has not changed, use options.keepNativeDefault
oldDefault = "" === newDefault ? optionValue : "";
// Concatenate keepNative selectors from all sources where the value has
// changed or, if nothing has changed, return the default
return (keepNative ? [
keepNative
] : []).concat(newDefault ? [
newDefault
] : []).concat(oldDefault ? [
oldDefault
] : []).join(", ");
}
}), jQuery.widget("mobile.pagecontainer", {
options: {
theme: "a"
},
initSelector: !1,
_create: function() {
this.setLastScrollEnabled = !0, this._on(this.window, {
// disable an scroll setting when a hashchange has been fired,
// this only works because the recording of the scroll position
// is delayed for 100ms after the browser might have changed the
// position because of the hashchange
navigate: "_disableRecordScroll",
// bind to scrollstop for the first page, "pagechange" won't be
// fired in that case
scrollstop: "_delayedRecordScroll"
}), // TODO consider moving the navigation handler OUT of widget into
// some other object as glue between the navigate event and the
// content widget load and change methods
this._on(this.window, {
navigate: "_filterNavigateEvents"
}), // TODO move from page* events to content* events
this._on({
pagechange: "_afterContentChange"
}), // handle initial hashchange from chrome :(
this.window.one("navigate", jQuery.proxy(function() {
this.setLastScrollEnabled = !0;
}, this));
},
_setOptions: function(options) {
options.theme !== undefined7 && "none" !== options.theme ? this.element.removeClass("ui-overlay-" + this.options.theme).addClass("ui-overlay-" + options.theme) : options.theme !== undefined7 && this.element.removeClass("ui-overlay-" + this.options.theme), this._super(options);
},
_disableRecordScroll: function() {
this.setLastScrollEnabled = !1;
},
_enableRecordScroll: function() {
this.setLastScrollEnabled = !0;
},
// TODO consider the name here, since it's purpose specific
_afterContentChange: function() {
// once the page has changed, re-enable the scroll recording
this.setLastScrollEnabled = !0, // remove any binding that previously existed on the get scroll
// which may or may not be different than the scroll element
// determined for this page previously
this._off(this.window, "scrollstop"), // determine and bind to the current scoll element which may be the
// window or in the case of touch overflow the element touch overflow
this._on(this.window, {
scrollstop: "_delayedRecordScroll"
});
},
_recordScroll: function() {
// this barrier prevents setting the scroll value based on
// the browser scrolling the window based on a hashchange
if (this.setLastScrollEnabled) {
var currentScroll, minScroll, defaultScroll, active = this._getActiveHistory();
active && (currentScroll = this._getScroll(), minScroll = this._getMinScroll(), defaultScroll = this._getDefaultScroll(), // Set active page's lastScroll prop. If the location we're
// scrolling to is less than minScrollBack, let it go.
active.lastScroll = currentScroll < minScroll ? defaultScroll : currentScroll);
}
},
_delayedRecordScroll: function() {
setTimeout(jQuery.proxy(this, "_recordScroll"), 100);
},
_getScroll: function() {
return this.window.scrollTop();
},
_getMinScroll: function() {
return jQuery.mobile.minScrollBack;
},
_getDefaultScroll: function() {
return jQuery.mobile.defaultHomeScroll;
},
_filterNavigateEvents: function(e, data) {
var url;
!(e.originalEvent && e.originalEvent.isDefaultPrevented()) && ((url = e.originalEvent.type.indexOf("hashchange") > -1 ? data.state.hash : data.state.url) || (url = this._getHash()), url && "#" !== url && 0 !== url.indexOf("#" + jQuery.mobile.path.uiStateKey) || (url = location.href), this._handleNavigate(url, data.state));
},
_getHash: function() {
return jQuery.mobile.path.parseLocation().hash;
},
// TODO active page should be managed by the container (ie, it should be a property)
getActivePage: function() {
return this.activePage;
},
// TODO the first page should be a property set during _create using the logic
// that currently resides in init
_getInitialContent: function() {
return jQuery.mobile.firstPage;
},
// TODO each content container should have a history object
_getHistory: function() {
return jQuery.mobile.navigate.history;
},
// TODO use _getHistory
_getActiveHistory: function() {
return jQuery.mobile.navigate.history.getActive();
},
// TODO the document base should be determined at creation
_getDocumentBase: function() {
return jQuery.mobile.path.documentBase;
},
back: function() {
this.go(-1);
},
forward: function() {
this.go(1);
},
go: function(steps) {
//if hashlistening is enabled use native history method
if (jQuery.mobile.hashListeningEnabled) window.history.go(steps);
else {
//we are not listening to the hash so handle history internally
var activeIndex = jQuery.mobile.navigate.history.activeIndex, index = activeIndex + parseInt(steps, 10), url = jQuery.mobile.navigate.history.stack[index].url;
//update the history object
jQuery.mobile.navigate.history.activeIndex = index, jQuery.mobile.navigate.history.previousIndex = activeIndex, //change to the new page
this.change(url, {
direction: steps >= 1 ? "forward" : "back",
changeHash: !1,
fromHashChange: !0
});
}
},
// TODO rename _handleDestination
_handleDestination: function(to) {
var history1;
return "string" === jQuery.type(to) && (to = jQuery.mobile.path.stripHash(to)), to && (history1 = this._getHistory(), // At this point, 'to' can be one of 3 things, a cached page
// element from a history stack entry, an id, or site-relative /
// absolute URL. If 'to' is an id, we need to resolve it against
// the documentBase, not the location.href, since the hashchange
// could've been the result of a forward/backward navigation
// that crosses from an external page/dialog to an internal
// page/dialog.
//
// TODO move check to history object or path object?
(to = jQuery.mobile.path.isPath(to) ? to : jQuery.mobile.path.makeUrlAbsolute("#" + to, this._getDocumentBase())) === jQuery.mobile.path.makeUrlAbsolute("#" + history1.initialDst, this._getDocumentBase()) && history1.stack.length && history1.stack[0].url !== history1.initialDst.replace(jQuery.mobile.dialogHashKey, "") && (to = this._getInitialContent())), to || this._getInitialContent();
},
_handleDialog: function(changePageOptions, data) {
var to, active, activeContent = this.getActivePage();
return(// If current active page is not a dialog skip the dialog and continue
// in the same direction
activeContent && !activeContent.hasClass("ui-dialog") ? ("back" === data.direction ? this.back() : this.forward(), !1) : (// if the current active page is a dialog and we're navigating
// to a dialog use the dialog objected saved in the stack
to = data.pageUrl, active = this._getActiveHistory(), // make sure to set the role, transition and reversal
// as most of this is lost by the domCache cleaning
jQuery.extend(changePageOptions, {
role: active.role,
transition: active.transition,
reverse: "back" === data.direction
}), to));
},
_handleNavigate: function(url, data) {
//find first page via hash
// TODO stripping the hash twice with handleUrl
var to = jQuery.mobile.path.stripHash(url), history1 = this._getHistory(), // transition is false if it's the first page, undefined
// otherwise (and may be overridden by default)
transition = 0 === history1.stack.length ? "none" : undefined7, // default options for the changPage calls made after examining
// the current state of the page and the hash, NOTE that the
// transition is derived from the previous history entry
changePageOptions = {
changeHash: !1,
fromHashChange: !0,
reverse: "back" === data.direction
};
// TODO move to _handleDestination ?
// If this isn't the first page, if the current url is a dialog hash
// key, and the initial destination isn't equal to the current target
// page, use the special dialog handling
jQuery.extend(changePageOptions, data, {
transition: (history1.getLast() || {}).transition || transition
}), (!(history1.activeIndex > 0 && to.indexOf(jQuery.mobile.dialogHashKey) > -1) || history1.initialDst === to || !1 !== (to = this._handleDialog(changePageOptions, data))) && this._changeContent(this._handleDestination(to), changePageOptions);
},
_changeContent: function(to, opts) {
jQuery.mobile.changePage(to, opts);
},
_getBase: function() {
return jQuery.mobile.base;
},
_getNs: function() {
return jQuery.mobile.ns;
},
_enhance: function(content, role) {
// TODO consider supporting a custom callback, and passing in
// the settings which includes the role
return content.page({
role: role
});
},
_include: function(page, settings) {
// append to page and enhance
page.appendTo(this.element), // use the page widget to enhance
this._enhance(page, settings.role), // remove page on hide
page.page("bindRemove");
},
_find: function(absUrl) {
// TODO consider supporting a custom callback
var page, fileUrl = this._createFileUrl(absUrl), dataUrl = this._createDataUrl(absUrl), initialContent = this._getInitialContent();
return 0 === // Check to see if the page already exists in the DOM.
// NOTE do _not_ use the :jqmData pseudo selector because parenthesis
// are a valid url char and it breaks on the first occurence
(page = this.element.children("[data-" + this._getNs() + "url='" + dataUrl + "']")).length && dataUrl && !jQuery.mobile.path.isPath(dataUrl) && (page = this.element.children(jQuery.mobile.path.hashToSelector("#" + dataUrl)).attr("data-" + this._getNs() + "url", dataUrl).jqmData("url", dataUrl)), 0 === page.length && jQuery.mobile.path.isFirstPageUrl(fileUrl) && initialContent && initialContent.parent().length && (page = jQuery(initialContent)), page;
},
_getLoader: function() {
return jQuery.mobile.loading();
},
_showLoading: function(delay, theme, msg, textonly) {
// This configurable timeout allows cached pages a brief
// delay to load without showing a message
!this._loadMsg && (this._loadMsg = setTimeout(jQuery.proxy(function() {
this._getLoader().loader("show", theme, msg, textonly), this._loadMsg = 0;
}, this), delay));
},
_hideLoading: function() {
// Stop message show timer
clearTimeout(this._loadMsg), this._loadMsg = 0, // Hide loading message
this._getLoader().loader("hide");
},
_showError: function() {
// make sure to remove the current loading message
this._hideLoading(), // show the error message
this._showLoading(0, jQuery.mobile.pageLoadErrorMessageTheme, jQuery.mobile.pageLoadErrorMessage, !0), // hide the error message after a delay
// TODO configuration
setTimeout(jQuery.proxy(this, "_hideLoading"), 1500);
},
_parse: function(html, fileUrl) {
// TODO consider allowing customization of this method. It's very JQM specific
var page, all = jQuery("<div></div>");
return(//workaround to allow scripts to execute when included in page divs
all.get(0).innerHTML = html, (page = all.find(":jqmData(role='page'), :jqmData(role='dialog')").first()).length || (page = jQuery("<div data-" + this._getNs() + "role='page'>" + (html.split(/<\/?body[^>]*>/gim)[1] || "") + "</div>")), // TODO tagging a page with external to make sure that embedded pages aren't
// removed by the various page handling code is bad. Having page handling code
// in many places is bad. Solutions post 1.0
page.attr("data-" + this._getNs() + "url", jQuery.mobile.path.convertUrlToDataUrl(fileUrl)).attr("data-" + this._getNs() + "external-page", !0), page);
},
_setLoadedTitle: function(page, html) {
//page title regexp
var newPageTitle = html.match(/<title[^>]*>([^<]*)/) && RegExp.$1;
newPageTitle && !page.jqmData("title") && (newPageTitle = jQuery("<div>" + newPageTitle + "</div>").text(), page.jqmData("title", newPageTitle));
},
_isRewritableBaseTag: function() {
return jQuery.mobile.dynamicBaseEnabled && !jQuery.support.dynamicBaseTag;
},
_createDataUrl: function(absoluteUrl) {
return jQuery.mobile.path.convertUrlToDataUrl(absoluteUrl);
},
_createFileUrl: function(absoluteUrl) {
return jQuery.mobile.path.getFilePath(absoluteUrl);
},
_triggerWithDeprecated: function(name, data, page) {
var deprecatedEvent = jQuery.Event("page" + name), newEvent = jQuery.Event(this.widgetName + name);
return(// DEPRECATED
// trigger the old deprecated event on the page if it's provided
(page || this.element).trigger(deprecatedEvent, data), // use the widget trigger method for the new content* event
this.element.trigger(newEvent, data), {
deprecatedEvent: deprecatedEvent,
event: newEvent
});
},
// TODO it would be nice to split this up more but everything appears to be "one off"
// or require ordering such that other bits are sprinkled in between parts that
// could be abstracted out as a group
_loadSuccess: function(absUrl, triggerData, settings, deferred) {
var fileUrl = this._createFileUrl(absUrl), dataUrl = this._createDataUrl(absUrl);
return jQuery.proxy(function(html, textStatus, xhr) {
//pre-parse html to check for a data-url,
//use it as the new fileUrl, base path, etc
var content, // TODO handle dialogs again
pageElemRegex = RegExp("(<[^>]+\\bdata-" + this._getNs() + "role=[\"']?page[\"']?[^>]*>)"), dataUrlRegex = RegExp("\\bdata-" + this._getNs() + "url=[\"']?([^\"'>]*)[\"']?");
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
pageElemRegex.test(html) && RegExp.$1 && dataUrlRegex.test(RegExp.$1) && RegExp.$1 && (fileUrl = jQuery.mobile.path.getFilePath(jQuery("<div>" + RegExp.$1 + "</div>").text())), settings.prefetch === undefined7 && this._getBase().set(fileUrl), content = this._parse(html, fileUrl), this._setLoadedTitle(content, html), // Add the content reference and xhr to our triggerData.
triggerData.xhr = xhr, triggerData.textStatus = textStatus, // DEPRECATED
triggerData.page = content, triggerData.content = content, this._trigger("load", undefined7, triggerData) && (this._isRewritableBaseTag() && content && this._getBase().rewrite(fileUrl, content), this._include(content, settings), absUrl.indexOf("&" + jQuery.mobile.subPageUrlKey) > -1 && (content = this.element.children("[data-" + this._getNs() + "url='" + dataUrl + "']")), settings.showLoadMsg && this._hideLoading(), // BEGIN DEPRECATED ---------------------------------------------------
// Let listeners know the content loaded successfully.
this.element.trigger("pageload"), // END DEPRECATED -----------------------------------------------------
deferred.resolve(absUrl, settings, content));
}, this);
},
_loadDefaults: {
type: "get",
data: undefined7,
// DEPRECATED
reloadPage: !1,
reload: !1,
// By default we rely on the role defined by the @data-role attribute.
role: undefined7,
showLoadMsg: !1,
// This delay allows loads that pull from browser cache to
// occur without showing the loading message.
loadMsgDelay: 50
},
load: function(url, options) {
// This function uses deferred notifications to let callers
// know when the content is done loading, or if an error has occurred.
var fileUrl, dataUrl, pblEvent, triggerData, deferred = options && options.deferred || jQuery.Deferred(), // The default load options with overrides specified by the caller.
settings = jQuery.extend({}, this._loadDefaults, options), // The DOM element for the content after it has been loaded.
content = null, // The absolute version of the URL passed into the function. This
// version of the URL may contain dialog/subcontent params in it.
absUrl = jQuery.mobile.path.makeUrlAbsolute(url, this._findBaseWithDefault());
// If it isn't a reference to the first content and refers to missing
// embedded content reject the deferred and return
if (// DEPRECATED reloadPage
settings.reload = settings.reloadPage, settings.data && "get" === settings.type && (absUrl = jQuery.mobile.path.addSearchParams(absUrl, settings.data), settings.data = undefined7), settings.data && "post" === settings.type && (settings.reload = !0), // The absolute version of the URL minus any dialog/subcontent params.
// In otherwords the real URL of the content to be loaded.
fileUrl = this._createFileUrl(absUrl), // The version of the Url actually stored in the data-url attribute of
// the content. For embedded content, it is just the id of the page. For
// content within the same domain as the document base, it is the site
// relative path. For cross-domain content (Phone Gap only) the entire
// absolute Url is used to load the content.
dataUrl = this._createDataUrl(absUrl), 0 === (content = this._find(absUrl)).length && jQuery.mobile.path.isEmbeddedPage(fileUrl) && !jQuery.mobile.path.isFirstPageUrl(fileUrl)) {
deferred.reject(absUrl, settings);
return;
}
// If the content we are interested in is already in the DOM,
// and the caller did not indicate that we should force a
// reload of the file, we are done. Resolve the deferrred so that
// users can bind to .done on the promise
if (// Reset base to the default document base
// TODO figure out why we doe this
this._getBase().reset(), content.length && !settings.reload) {
this._enhance(content, settings.role), deferred.resolve(absUrl, settings, content), settings.prefetch || this._getBase().set(url);
return;
}
// If the default behavior is prevented, stop here!
if (triggerData = {
url: url,
absUrl: absUrl,
dataUrl: dataUrl,
deferred: deferred,
options: settings
}, !(// Let listeners know we're about to load content.
(pblEvent = this._triggerWithDeprecated("beforeload", triggerData)).deprecatedEvent.isDefaultPrevented() || pblEvent.event.isDefaultPrevented())) {
if (settings.showLoadMsg && this._showLoading(settings.loadMsgDelay), settings.prefetch === undefined7 && this._getBase().reset(), !(jQuery.mobile.allowCrossDomainPages || jQuery.mobile.path.isSameDomain(jQuery.mobile.path.documentUrl, absUrl))) {
deferred.reject(absUrl, settings);
return;
}
// Load the new content.
jQuery.ajax({
url: fileUrl,
type: settings.type,
data: settings.data,
contentType: settings.contentType,
dataType: "html",
success: this._loadSuccess(absUrl, triggerData, settings, deferred),
error: this._loadError(absUrl, triggerData, settings, deferred)
});
}
},
_loadError: function(absUrl, triggerData, settings, deferred) {
return jQuery.proxy(function(xhr, textStatus, errorThrown) {
//set base back to current path
this._getBase().set(jQuery.mobile.path.get()), // Add error info to our triggerData.
triggerData.xhr = xhr, triggerData.textStatus = textStatus, triggerData.errorThrown = errorThrown;
// Let listeners know the page load failed.
var plfEvent = this._triggerWithDeprecated("loadfailed", triggerData);
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
!(plfEvent.deprecatedEvent.isDefaultPrevented() || plfEvent.event.isDefaultPrevented()) && (settings.showLoadMsg && this._showError(), deferred.reject(absUrl, settings));
}, this);
},
_getTransitionHandler: function(transition) {
//find the transition handler for the specified transition. If there
//isn't one in our transitionHandlers dictionary, use the default one.
//call the handler immediately to kick-off the transition.
return transition = jQuery.mobile._maybeDegradeTransition(transition), jQuery.mobile.transitionHandlers[transition] || jQuery.mobile.defaultTransitionHandler;
},
// TODO move into transition handlers?
_triggerCssTransitionEvents: function(to, from, prefix) {
var samePage = !1;
prefix = prefix || "", from && (to[0] === from[0] && (samePage = !0), //trigger before show/hide events
// TODO deprecate nextPage in favor of next
this._triggerWithDeprecated(prefix + "hide", {
nextPage: to,
samePage: samePage
}, from)), // TODO deprecate prevPage in favor of previous
this._triggerWithDeprecated(prefix + "show", {
prevPage: from || jQuery("")
}, to);
},
// TODO make private once change has been defined in the widget
_cssTransition: function(to, from, options) {
var promise, transition = options.transition, reverse = options.reverse, deferred = options.deferred;
this._triggerCssTransitionEvents(to, from, "before"), // TODO put this in a binding to events *outside* the widget
this._hideLoading(), // TODO temporary accomodation of argument deferred
(promise = new (this._getTransitionHandler(transition))(transition, reverse, to, from).transition()).done(function() {
deferred.resolve.apply(deferred, arguments);
}), promise.done(jQuery.proxy(function() {
this._triggerCssTransitionEvents(to, from);
}, this));
},
_releaseTransitionLock: function() {
//release transition lock so navigation is free again
isPageTransitioning = !1, pageTransitionQueue.length > 0 && jQuery.mobile.changePage.apply(null, pageTransitionQueue.pop());
},
_removeActiveLinkClass: function(force) {
//clear out the active button state
jQuery.mobile.removeActiveLinkClass(force);
},
_loadUrl: function(to, triggerData, settings) {
// preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params
// from the hash this is so that users who want to use query
// params have access to them in the event bindings for the page
// life cycle See issue #5085
settings.target = to, settings.deferred = jQuery.Deferred(), this.load(to, settings), settings.deferred.done(jQuery.proxy(function(url, options, content) {
isPageTransitioning = !1, // store the original absolute url so that it can be provided
// to events in the triggerData of the subsequent changePage call
options.absUrl = triggerData.absUrl, this.transition(content, triggerData, options);
}, this)), settings.deferred.fail(jQuery.proxy(function() {
this._removeActiveLinkClass(!0), this._releaseTransitionLock(), this._triggerWithDeprecated("changefailed", triggerData);
}, this));
},
_triggerPageBeforeChange: function(to, triggerData, settings) {
var pbcEvent = new jQuery.Event("pagebeforechange");
return(// If the default behavior is prevented, stop here!
jQuery.extend(triggerData, {
toPage: to,
options: settings
}), "string" === jQuery.type(to) ? // if the toPage is a string simply convert it
triggerData.absUrl = jQuery.mobile.path.makeUrlAbsolute(to, this._findBaseWithDefault()) : // if the toPage is a jQuery object grab the absolute url stored
// in the loadPage callback where it exists
triggerData.absUrl = settings.absUrl, // Let listeners know we're about to change the current page.
this.element.trigger(pbcEvent, triggerData), !pbcEvent.isDefaultPrevented());
},
change: function(to, options) {
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if (isPageTransitioning) {
pageTransitionQueue.unshift(arguments);
return;
}
var settings = jQuery.extend({}, jQuery.mobile.changePage.defaults, options), triggerData = {};
// if the page beforechange default is prevented return early
// Make sure we have a fromPage.
settings.fromPage = settings.fromPage || this.activePage, this._triggerPageBeforeChange(to, triggerData, settings) && (// We allow "pagebeforechange" observers to modify the to in
// the trigger data to allow for redirects. Make sure our to is
// updated. We also need to re-evaluate whether it is a string,
// because an object can also be replaced by a string
to = triggerData.toPage, "string" === jQuery.type(to) ? (// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = !0, this._loadUrl(to, triggerData, settings)) : this.transition(to, triggerData, settings));
},
transition: function(toPage, triggerData, settings) {
var fromPage, url, pageUrl, active, activeIsInitialPage, historyDir, pageTitle, isDialog, alreadyThere, newPageTitle, params, cssTransitionDeferred, beforeTransition;
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if (isPageTransitioning) {
// make sure to only queue the to and settings values so the arguments
// work with a call to the change method
pageTransitionQueue.unshift([
toPage,
settings
]);
return;
}
// DEPRECATED - this call only, in favor of the before transition
// if the page beforechange default is prevented return early
if (!(!this._triggerPageBeforeChange(toPage, triggerData, settings) || // if the (content|page)beforetransition default is prevented return early
// Note, we have to check for both the deprecated and new events
(beforeTransition = this._triggerWithDeprecated("beforetransition", triggerData)).deprecatedEvent.isDefaultPrevented() || beforeTransition.event.isDefaultPrevented())) {
// By default, we prevent changePage requests when the fromPage and toPage
// are the same element, but folks that generate content
// manually/dynamically and reuse pages want to be able to transition to
// the same page. To allow this, they will need to change the default
// value of allowSamePageTransition to true, *OR*, pass it in as an
// option when they manually call changePage(). It should be noted that
// our default transition animations assume that the formPage and toPage
// are different elements, so they may behave unexpectedly. It is up to
// the developer that turns on the allowSamePageTransitiona option to
// either turn off transition animations, or make sure that an appropriate
// animation transition is used.
if (// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = !0, toPage[0] !== jQuery.mobile.firstPage[0] || settings.dataUrl || (settings.dataUrl = jQuery.mobile.path.documentUrl.hrefNoHash), // The caller passed us a real page DOM element. Update our
// internal state and then trigger a transition to the page.
fromPage = settings.fromPage, // The pageUrl var is usually the same as url, except when url is obscured
// as a dialog url. pageUrl always contains the file path
pageUrl = url = settings.dataUrl && jQuery.mobile.path.convertUrlToDataUrl(settings.dataUrl) || toPage.jqmData("url"), jQuery.mobile.path.getFilePath(url), active = jQuery.mobile.navigate.history.getActive(), activeIsInitialPage = 0 === jQuery.mobile.navigate.history.activeIndex, historyDir = 0, pageTitle = document1.title, isDialog = ("dialog" === settings.role || "dialog" === toPage.jqmData("role")) && !0 !== toPage.jqmData("dialog"), fromPage && fromPage[0] === toPage[0] && !settings.allowSamePageTransition) {
isPageTransitioning = !1, this._triggerWithDeprecated("transition", triggerData), this.element.trigger("pagechange", triggerData), settings.fromHashChange && jQuery.mobile.navigate.history.direct({
url: url
});
return;
}
// We need to make sure the page we are given has already been enhanced.
toPage.page({
role: settings.role
}), settings.fromHashChange && (historyDir = "back" === settings.direction ? -1 : 1);
// Kill the keyboard.
// XXX_jblas: We need to stop crawling the entire document to kill focus.
// Instead, we should be tracking focus with a delegate()
// handler so we already have the element in hand at this
// point.
// Wrap this in a try/catch block since IE9 throw "Unspecified error" if
// document.activeElement is undefined when we are in an IFrame.
try {
document1.activeElement && "body" !== document1.activeElement.nodeName.toLowerCase() ? jQuery(document1.activeElement).blur() : jQuery("input:focus, textarea:focus, select:focus").blur();
} catch (e) {}
// Record whether we are at a place in history where a dialog used to be -
// if so, do not add a new history entry and do not change the hash either
alreadyThere = !1, isDialog && active && (active.url && active.url.indexOf(jQuery.mobile.dialogHashKey) > -1 && this.activePage && !this.activePage.hasClass("ui-dialog") && jQuery.mobile.navigate.history.activeIndex > 0 && (settings.changeHash = !1, alreadyThere = !0), // Normally, we tack on a dialog hash key, but if this is the location
// of a stale dialog, we reuse the URL from the entry
url = active.url || "", !alreadyThere && url.indexOf("#") > -1 ? url += jQuery.mobile.dialogHashKey : url += "#" + jQuery.mobile.dialogHashKey, 0 === jQuery.mobile.navigate.history.activeIndex && url === jQuery.mobile.navigate.history.initialDst && (url += jQuery.mobile.dialogHashKey)), // if title element wasn't found, try the page div data attr too
// If this is a deep-link or a reload ( active === undefined ) then just
// use pageTitle
(newPageTitle = active ? toPage.jqmData("title") || toPage.children(":jqmData(role='header')").find(".ui-title").text() : pageTitle) && pageTitle === document1.title && (pageTitle = newPageTitle), toPage.jqmData("title") || toPage.jqmData("title", pageTitle), // Make sure we have a transition defined.
settings.transition = settings.transition || (historyDir && !activeIsInitialPage ? active.transition : undefined7) || (isDialog ? jQuery.mobile.defaultDialogTransition : jQuery.mobile.defaultPageTransition), !historyDir && alreadyThere && (jQuery.mobile.navigate.history.getActive().pageUrl = pageUrl), url && !settings.fromHashChange && (!jQuery.mobile.path.isPath(url) && 0 > url.indexOf("#") && (url = "#" + url), // TODO the property names here are just silly
params = {
transition: settings.transition,
title: pageTitle,
pageUrl: pageUrl,
role: settings.role
}, !1 !== settings.changeHash && jQuery.mobile.hashListeningEnabled ? jQuery.mobile.navigate(url, params, !0) : toPage[0] !== jQuery.mobile.firstPage[0] && jQuery.mobile.navigate.history.add(url, params)), //set page title
document1.title = pageTitle, //set "toPage" as activePage deprecated in 1.4 remove in 1.5
jQuery.mobile.activePage = toPage, //new way to handle activePage
this.activePage = toPage, // If we're navigating back in the URL history, set reverse accordingly.
settings.reverse = settings.reverse || historyDir < 0, cssTransitionDeferred = jQuery.Deferred(), this._cssTransition(toPage, fromPage, {
transition: settings.transition,
reverse: settings.reverse,
deferred: cssTransitionDeferred
}), cssTransitionDeferred.done(jQuery.proxy(function(name, reverse, $to, $from, alreadyFocused) {
jQuery.mobile.removeActiveLinkClass(), settings.duplicateCachedPage && settings.duplicateCachedPage.remove(), alreadyFocused || jQuery.mobile.focusPage(toPage), this._releaseTransitionLock(), this.element.trigger("pagechange", triggerData), this._triggerWithDeprecated("transition", triggerData);
}, this));
}
},
// determine the current base url
_findBaseWithDefault: function() {
return this.activePage && jQuery.mobile.getClosestBaseUrl(this.activePage) || jQuery.mobile.path.documentBase.hrefNoHash;
}
}), // The following handlers should be bound after mobileinit has been triggered
// the following deferred is resolved in the init file
jQuery.mobile.navreadyDeferred = jQuery.Deferred(), pageTransitionQueue = [], isPageTransitioning = !1, function($, undefined) {
// resolved on domready
var domreadyDeferred = $.Deferred(), // resolved and nulled on window.load()
loadDeferred = $.Deferred(), documentUrl = $.mobile.path.documentUrl, // used to track last vclicked element to make sure its value is added to form data
$lastVClicked = null;
/* Event Bindings - hashchange, submit, and click */ function findClosestLink(ele) {
for(; // Look for the closest element with a nodeName of "a".
// Note that we are checking if we have a valid nodeName
// before attempting to access it. This is because the
// node we get called with could have originated from within
// an embedded SVG document where some symbol instance elements
// don't have nodeName defined on them, or strings are of type
// SVGAnimatedString.
ele && ("string" != typeof ele.nodeName || "a" !== ele.nodeName.toLowerCase());)ele = ele.parentNode;
return ele;
}
$.mobile.loadPage = function(url, opts) {
var container;
// provide the deferred
return container = (opts = opts || {}).pageContainer || $.mobile.pageContainer, // create the deferred that will be supplied to loadPage callers
// and resolved by the content widget's load method
opts.deferred = $.Deferred(), // Preferring to allow exceptions for uninitialized opts.pageContainer
// widgets so we know if we need to force init here for users
container.pagecontainer("load", url, opts), opts.deferred.promise();
}, //define vars for interal use
/* internal utility functions */ // NOTE Issue #4950 Android phonegap doesn't navigate back properly
// when a full page refresh has taken place. It appears that hashchange
// and replacestate history alterations work fine but we need to support
// both forms of history traversal in our code that uses backward history
// movement
$.mobile.back = function() {
var nav = window.navigator;
// if the setting is on and the navigator object is
// available use the phonegap navigation capability
this.phonegapNavigationEnabled && nav && nav.app && nav.app.backHistory ? nav.app.backHistory() : $.mobile.pageContainer.pagecontainer("back");
}, // Direct focus to the page title, or otherwise first focusable element
$.mobile.focusPage = function(page) {
var autofocus = page.find("[autofocus]"), pageTitle = page.find(".ui-title:eq(0)");
if (autofocus.length) {
autofocus.focus();
return;
}
pageTitle.length ? pageTitle.focus() : page.focus();
}, // No-op implementation of transition degradation
$.mobile._maybeDegradeTransition = $.mobile._maybeDegradeTransition || function(transition) {
return transition;
}, // Exposed $.mobile methods
$.mobile.changePage = function(to, options) {
$.mobile.pageContainer.pagecontainer("change", to, options);
}, $.mobile.changePage.defaults = {
transition: void 0,
reverse: !1,
changeHash: !0,
fromHashChange: !1,
role: void 0,
duplicateCachedPage: undefined,
pageContainer: undefined,
showLoadMsg: !0,
dataUrl: undefined,
fromPage: undefined,
allowSamePageTransition: !1
}, $.mobile._registerInternalEvents = function() {
var getAjaxFormData = function($form, calculateOnly) {
var url, formData, vclickedName, method, ret = !0;
return !(!$.mobile.ajaxEnabled || // test that the form is, itself, ajax false
$form.is(":jqmData(ajax='false')") || // test that $.mobile.ignoreContentEnabled is set and
// the form or one of it's parents is ajax=false
!$form.jqmHijackable().length || $form.attr("target")) && (url = $lastVClicked && $lastVClicked.attr("formaction") || $form.attr("action"), method = ($form.attr("method") || "get").toLowerCase(), url || (// Get the @data-url for the page containing the form.
url = $.mobile.getClosestBaseUrl($form), "get" === method && (url = $.mobile.path.parseUrl(url).hrefNoSearch), url !== $.mobile.path.documentBase.hrefNoHash || // The url we got back matches the document base,
// which means the page must be an internal/embedded page,
// so default to using the actual document url as a browser
// would.
(url = documentUrl.hrefNoSearch)), url = $.mobile.path.makeUrlAbsolute(url, $.mobile.getClosestBaseUrl($form)), (!$.mobile.path.isExternal(url) || !!$.mobile.path.isPermittedCrossDomainRequest(documentUrl, url)) && (calculateOnly || (formData = $form.serializeArray(), $lastVClicked && $lastVClicked[0].form === $form[0] && (vclickedName = $lastVClicked.attr("name")) && (// Make sure the last clicked element is included in the form
$.each(formData, function(key, value) {
if (value.name === vclickedName) return(// Unset vclickedName - we've found it in the serialized data already
vclickedName = "", !1);
}), vclickedName && formData.push({
name: vclickedName,
value: $lastVClicked.attr("value")
})), ret = {
url: url,
options: {
type: method,
data: $.param(formData),
transition: $form.jqmData("transition"),
reverse: "reverse" === $form.jqmData("direction"),
reloadPage: !0
}
}), ret));
};
//bind to form submit events, handle with Ajax
$.mobile.document.delegate("form", "submit", function(event1) {
var formData;
!event1.isDefaultPrevented() && (formData = getAjaxFormData($(this))) && ($.mobile.changePage(formData.url, formData.options), event1.preventDefault());
}), //add active state on vclick
$.mobile.document.bind("vclick", function(event1) {
var $btn, btnEls, target = event1.target, needClosest = !1;
// if this isn't a left click we don't care. Its important to note
// that when the virtual event is generated it will create the which attr
if (!(event1.which > 1) && $.mobile.linkBindingEnabled) {
// Try to find a target element to which the active class will be applied
if (// Record that this element was clicked, in case we need it for correct
// form submission during the "submit" handler above
$lastVClicked = $(target), $.data(target, "mobile-button")) {
// If the form will not be submitted via AJAX, do not add active class
if (!getAjaxFormData($(target).closest("form"), !0)) return;
// We will apply the active state to this button widget - the parent
// of the input that was clicked will have the associated data
target.parentNode && (target = target.parentNode);
} else if (!((target = findClosestLink(target)) && "#" !== $.mobile.path.parseUrl(target.getAttribute("href") || "#").hash) || !$(target).jqmHijackable().length) return;
~target.className.indexOf("ui-link-inherit") ? target.parentNode && (btnEls = $.data(target.parentNode, "buttonElements")) : btnEls = $.data(target, "buttonElements"), btnEls ? target = btnEls.outer : needClosest = !0, $btn = $(target), needClosest && ($btn = $btn.closest(".ui-btn")), $btn.length > 0 && !$btn.hasClass("ui-state-disabled") && ($.mobile.removeActiveLinkClass(!0), $.mobile.activeClickedLink = $btn, $.mobile.activeClickedLink.addClass($.mobile.activeBtnClass));
}
}), // click routing - direct to HTTP or Ajax, accordingly
$.mobile.document.bind("click", function(event1) {
if (!(!$.mobile.linkBindingEnabled || event1.isDefaultPrevented())) {
var baseUrl, href, transition, reverse, role, link = findClosestLink(event1.target), $link = $(link), //remove active link class if external (then it won't be there if you come back)
httpCleanup = function() {
window.setTimeout(function() {
$.mobile.removeActiveLinkClass(!0);
}, 200);
};
// If there is no link associated with the click or its not a left
// click we want to ignore the click
// TODO teach $.mobile.hijackable to operate on raw dom elements so the link wrapping
// can be avoided
if ($.mobile.activeClickedLink && $.mobile.activeClickedLink[0] === event1.target.parentNode && httpCleanup(), link && !(event1.which > 1) && $link.jqmHijackable().length) {
//if there's a data-rel=back attr, go back in history
if ($link.is(":jqmData(rel='back')")) return $.mobile.back(), !1;
//if ajax is disabled, exit early
if (baseUrl = $.mobile.getClosestBaseUrl($link), //get href, if defined, otherwise default to empty hash
href = $.mobile.path.makeUrlAbsolute($link.attr("href") || "#", baseUrl), !$.mobile.ajaxEnabled && !$.mobile.path.isEmbeddedPage(href)) {
httpCleanup();
//use default click handling
return;
}
// XXX_jblas: Ideally links to application pages should be specified as
// an url to the application document with a hash that is either
// the site relative path or id to the page. But some of the
// internal code that dynamically generates sub-pages for nested
// lists and select dialogs, just write a hash in the link they
// create. This means the actual URL path is based on whatever
// the current value of the base tag is at the time this code
// is called. For now we are just assuming that any url with a
// hash in it is an application page reference.
if (-1 !== href.search("#")) {
if (href = href.replace(/[^#]*#/, "")) //we have apath so make it the href we want to load.
href = $.mobile.path.isPath(href) ? $.mobile.path.makeUrlAbsolute(href, baseUrl) : $.mobile.path.makeUrlAbsolute("#" + href, documentUrl.hrefNoHash);
else {
//link was an empty hash meant purely
//for interaction, so we ignore it.
event1.preventDefault();
return;
}
}
if ($link.is("[rel='external']") || $link.is(":jqmData(ajax='false')") || $link.is("[target]") || $.mobile.path.isExternal(href) && !$.mobile.path.isPermittedCrossDomainRequest(documentUrl, href)) {
httpCleanup();
//use default click handling
return;
}
//use ajax
transition = $link.jqmData("transition"), reverse = "reverse" === $link.jqmData("direction") || // deprecated - remove by 1.0
$link.jqmData("back"), //this may need to be more specific as we use data-rel more
role = $link.attr("data-" + $.mobile.ns + "rel") || undefined, $.mobile.changePage(href, {
transition: transition,
reverse: reverse,
role: role,
link: $link
}), event1.preventDefault();
}
}
}), //prefetch pages when anchors with data-prefetch are encountered
$.mobile.document.delegate(".ui-page", "pageshow.prefetch", function() {
var urls = [];
$(this).find("a:jqmData(prefetch)").each(function() {
var $link = $(this), url = $link.attr("href");
url && -1 === $.inArray(url, urls) && (urls.push(url), $.mobile.loadPage(url, {
role: $link.attr("data-" + $.mobile.ns + "rel"),
prefetch: !0
}));
});
}), // TODO ensure that the navigate binding in the content widget happens at the right time
$.mobile.pageContainer.pagecontainer(), //set page min-heights to be device specific
$.mobile.document.bind("pageshow", function() {
// We need to wait for window.load to make sure that styles have already been rendered,
// otherwise heights of external toolbars will have the wrong value
loadDeferred ? loadDeferred.done($.mobile.resetActivePageHeight) : $.mobile.resetActivePageHeight();
}), $.mobile.window.bind("throttledresize", $.mobile.resetActivePageHeight);
}, $(function() {
domreadyDeferred.resolve();
}), $.mobile.window.load(function() {
// Resolve and null the deferred
loadDeferred.resolve(), loadDeferred = null;
}), $.when(domreadyDeferred, $.mobile.navreadyDeferred).done(function() {
$.mobile._registerInternalEvents();
});
}(jQuery), window2 = this, // TODO remove direct references to $.mobile and properties, we should
// favor injection with params to the constructor
jQuery.mobile.Transition = function() {
this.init.apply(this, arguments);
}, jQuery.extend(jQuery.mobile.Transition.prototype, {
toPreClass: " ui-page-pre-in",
init: function(name, reverse, $to, $from) {
jQuery.extend(this, {
name: name,
reverse: reverse,
$to: $to,
$from: $from,
deferred: new jQuery.Deferred()
});
},
cleanFrom: function() {
this.$from.removeClass(jQuery.mobile.activePageClass + " out in reverse " + this.name).height("");
},
// NOTE overridden by child object prototypes, noop'd here as defaults
beforeDoneIn: function() {},
beforeDoneOut: function() {},
beforeStartOut: function() {},
doneIn: function() {
this.beforeDoneIn(), this.$to.removeClass("out in reverse " + this.name).height(""), this.toggleViewportClass(), jQuery.mobile.window.scrollTop() !== this.toScroll && this.scrollPage(), this.sequential || this.$to.addClass(jQuery.mobile.activePageClass), this.deferred.resolve(this.name, this.reverse, this.$to, this.$from, !0);
},
doneOut: function(screenHeight, reverseClass, none, preventFocus) {
this.beforeDoneOut(), this.startIn(screenHeight, reverseClass, none, preventFocus);
},
hideIn: function(callback) {
// Prevent flickering in phonegap container: see comments at #4024 regarding iOS
this.$to.css("z-index", -10), callback.call(this), this.$to.css("z-index", "");
},
scrollPage: function() {
// By using scrollTo instead of silentScroll, we can keep things better in order
// Just to be precautios, disable scrollstart listening like silentScroll would
jQuery.event.special.scrollstart.enabled = !1, (jQuery.mobile.hideUrlBar || this.toScroll !== jQuery.mobile.defaultHomeScroll) && window2.scrollTo(0, this.toScroll), // reenable scrollstart listening like silentScroll would
setTimeout(function() {
jQuery.event.special.scrollstart.enabled = !0;
}, 150);
},
startIn: function(screenHeight, reverseClass, none, preventFocus) {
this.hideIn(function() {
this.$to.addClass(jQuery.mobile.activePageClass + this.toPreClass), preventFocus || jQuery.mobile.focusPage(this.$to), // Set to page height
this.$to.height(screenHeight + this.toScroll), none || this.scrollPage();
}), this.$to.removeClass(this.toPreClass).addClass(this.name + " in " + reverseClass), none ? this.doneIn() : this.$to.animationComplete(jQuery.proxy(function() {
this.doneIn();
}, this));
},
startOut: function(screenHeight, reverseClass, none) {
this.beforeStartOut(screenHeight, reverseClass, none), // Set the from page's height and start it transitioning out
// Note: setting an explicit height helps eliminate tiling in the transitions
this.$from.height(screenHeight + jQuery.mobile.window.scrollTop()).addClass(this.name + " out" + reverseClass);
},
toggleViewportClass: function() {
jQuery.mobile.pageContainer.toggleClass("ui-mobile-viewport-transitioning viewport-" + this.name);
},
transition: function() {
// NOTE many of these could be calculated/recorded in the constructor, it's my
// opinion that binding them as late as possible has value with regards to
// better transitions with fewer bugs. Ie, it's not guaranteed that the
// object will be created and transition will be run immediately after as
// it is today. So we wait until transition is invoked to gather the following
var none, reverseClass = this.reverse ? " reverse" : "", screenHeight = jQuery.mobile.getScreenHeight(), maxTransitionOverride = !1 !== jQuery.mobile.maxTransitionWidth && jQuery.mobile.window.width() > jQuery.mobile.maxTransitionWidth;
return this.toScroll = jQuery.mobile.navigate.history.getActive().lastScroll || jQuery.mobile.defaultHomeScroll, none = !jQuery.support.cssTransitions || !jQuery.support.cssAnimations || maxTransitionOverride || !this.name || "none" === this.name || Math.max(jQuery.mobile.window.scrollTop(), this.toScroll) > jQuery.mobile.getMaxScrollForTransition(), this.toggleViewportClass(), this.$from && !none ? this.startOut(screenHeight, reverseClass, none) : this.doneOut(screenHeight, reverseClass, none, !0), this.deferred.promise();
}
}), jQuery.mobile.SerialTransition = function() {
this.init.apply(this, arguments);
}, jQuery.extend(jQuery.mobile.SerialTransition.prototype, jQuery.mobile.Transition.prototype, {
sequential: !0,
beforeDoneOut: function() {
this.$from && this.cleanFrom();
},
beforeStartOut: function(screenHeight, reverseClass, none) {
this.$from.animationComplete(jQuery.proxy(function() {
this.doneOut(screenHeight, reverseClass, none);
}, this));
}
}), jQuery.mobile.ConcurrentTransition = function() {
this.init.apply(this, arguments);
}, jQuery.extend(jQuery.mobile.ConcurrentTransition.prototype, jQuery.mobile.Transition.prototype, {
sequential: !1,
beforeDoneIn: function() {
this.$from && this.cleanFrom();
},
beforeStartOut: function(screenHeight, reverseClass, none) {
this.doneOut(screenHeight, reverseClass, none);
}
}), //transition handler dictionary for 3rd party transitions
jQuery.mobile.transitionHandlers = {
sequential: jQuery.mobile.SerialTransition,
simultaneous: jQuery.mobile.ConcurrentTransition
}, // Make our transition handler the public default.
jQuery.mobile.defaultTransitionHandler = jQuery.mobile.transitionHandlers.sequential, jQuery.mobile.transitionFallbacks = {}, // If transition is defined, check if css 3D transforms are supported, and if not, if a fallback is specified
jQuery.mobile._maybeDegradeTransition = function(transition) {
return transition && !jQuery.support.cssTransform3d && jQuery.mobile.transitionFallbacks[transition] && (transition = jQuery.mobile.transitionFallbacks[transition]), transition;
}, // Set the getMaxScrollForTransition to default if no implementation was set by user
jQuery.mobile.getMaxScrollForTransition = jQuery.mobile.getMaxScrollForTransition || function() {
return 3 * jQuery.mobile.getScreenHeight();
}, jQuery.mobile.transitionFallbacks.flip = "fade", jQuery.mobile.transitionFallbacks.flow = "fade", jQuery.mobile.transitionFallbacks.pop = "fade", // Use the simultaneous transitions handler for slide transitions
jQuery.mobile.transitionHandlers.slide = jQuery.mobile.transitionHandlers.simultaneous, // Set the slide transitions's fallback to "fade"
jQuery.mobile.transitionFallbacks.slide = "fade", jQuery.mobile.transitionFallbacks.slidedown = "fade", // Set the slide transitions's fallback to "fade"
jQuery.mobile.transitionFallbacks.slidefade = "fade", jQuery.mobile.transitionFallbacks.slideup = "fade", jQuery.mobile.transitionFallbacks.turn = "fade", jQuery.mobile.degradeInputs = {
color: !1,
date: !1,
datetime: !1,
"datetime-local": !1,
email: !1,
month: !1,
number: !1,
range: "number",
search: "text",
tel: !1,
time: !1,
url: !1,
week: !1
}, // Backcompat remove in 1.5
jQuery.mobile.page.prototype.options.degradeInputs = jQuery.mobile.degradeInputs, // Auto self-init widgets
jQuery.mobile.degradeInputsWithin = function(target) {
// Degrade inputs to avoid poorly implemented native functionality
(target = jQuery(target)).find("input").not(jQuery.mobile.page.prototype.keepNativeSelector()).each(function() {
var html, hasType, repstr, element = jQuery(this), type = this.getAttribute("type"), optType = jQuery.mobile.degradeInputs[type] || "text";
jQuery.mobile.degradeInputs[type] && (// In IE browsers, the type sometimes doesn't exist in the cloned markup, so we replace the closing tag instead
hasType = (html = jQuery("<div>").html(element.clone()).html()).indexOf(" type=") > -1, repstr = ' type="' + optType + '" data-' + jQuery.mobile.ns + 'type="' + type + '"' + (hasType ? "" : ">"), element.replaceWith(html.replace(hasType ? /\s+type=["']?\w+['"]?/ : /\/?>/, repstr)));
});
}, function($, window, undefined) {
$.widget("mobile.page", $.mobile.page, {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: !0,
dialog: !1
},
_create: function() {
this._super(), this.options.dialog && ($.extend(this, {
_inner: this.element.children(),
_headerCloseButton: null
}), this.options.enhanced || this._setCloseBtn(this.options.closeBtn));
},
_enhance: function() {
this._super(), this.options.dialog && this.element.addClass("ui-dialog").wrapInner($("<div/>", {
// ARIA role
role: "dialog",
class: "ui-dialog-contain ui-overlay-shadow" + (this.options.corners ? " ui-corner-all" : "")
}));
},
_setOptions: function(options) {
var closeButtonLocation, closeButtonText, currentOpts = this.options;
void 0 !== options.corners && this._inner.toggleClass("ui-corner-all", !!options.corners), void 0 !== options.overlayTheme && $.mobile.activePage[0] === this.element[0] && (currentOpts.overlayTheme = options.overlayTheme, this._handlePageBeforeShow()), options.closeBtnText !== undefined && (closeButtonLocation = currentOpts.closeBtn, closeButtonText = options.closeBtnText), options.closeBtn !== undefined && (closeButtonLocation = options.closeBtn), closeButtonLocation && this._setCloseBtn(closeButtonLocation, closeButtonText), this._super(options);
},
_handlePageBeforeShow: function() {
this.options.overlayTheme && this.options.dialog ? (this.removeContainerBackground(), this.setContainerBackground(this.options.overlayTheme)) : this._super();
},
_setCloseBtn: function(location1, text) {
var dst, btn = this._headerCloseButton;
"none" == // Sanitize value
(location1 = "left" === location1 ? "left" : "right" === location1 ? "right" : "none") ? btn && (btn.remove(), btn = null) : btn ? (btn.removeClass("ui-btn-left ui-btn-right").addClass("ui-btn-" + location1), text && btn.text(text)) : (dst = this._inner.find(":jqmData(role='header')").first(), btn = $("<a></a>", {
href: "#",
class: "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location1
}).attr("data-" + $.mobile.ns + "rel", "back").text(text || this.options.closeBtnText || "").prependTo(dst)), this._headerCloseButton = btn;
}
});
}(jQuery, 0), function($, window, undefined) {
$.widget("mobile.dialog", {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: !0
},
// Override the theme set by the page plugin on pageshow
_handlePageBeforeShow: function() {
this._isCloseable = !0, this.options.overlayTheme && this.element.page("removeContainerBackground").page("setContainerBackground", this.options.overlayTheme);
},
_handlePageBeforeHide: function() {
this._isCloseable = !1;
},
// click and submit events:
// - clicks and submits should use the closing transition that the dialog
// opened with unless a data-transition is specified on the link/form
// - if the click was on the close button, or the link has a data-rel="back"
// it'll go back in history naturally
_handleVClickSubmit: function(event1) {
var attrs, $target = $(event1.target).closest("vclick" === event1.type ? "a" : "form");
$target.length && !$target.jqmData("transition") && ((attrs = {})["data-" + $.mobile.ns + "transition"] = ($.mobile.navigate.history.getActive() || {}).transition || $.mobile.defaultDialogTransition, attrs["data-" + $.mobile.ns + "direction"] = "reverse", $target.attr(attrs));
},
_create: function() {
var elem = this.element, opts = this.options;
// Class the markup for dialog styling and wrap interior
elem.addClass("ui-dialog").wrapInner($("<div/>", {
// ARIA role
role: "dialog",
class: "ui-dialog-contain ui-overlay-shadow" + (opts.corners ? " ui-corner-all" : "")
})), $.extend(this, {
_isCloseable: !1,
_inner: elem.children(),
_headerCloseButton: null
}), this._on(elem, {
vclick: "_handleVClickSubmit",
submit: "_handleVClickSubmit",
pagebeforeshow: "_handlePageBeforeShow",
pagebeforehide: "_handlePageBeforeHide"
}), this._setCloseBtn(opts.closeBtn);
},
_setOptions: function(options) {
var closeButtonLocation, closeButtonText, currentOpts = this.options;
void 0 !== options.corners && this._inner.toggleClass("ui-corner-all", !!options.corners), void 0 !== options.overlayTheme && $.mobile.activePage[0] === this.element[0] && (currentOpts.overlayTheme = options.overlayTheme, this._handlePageBeforeShow()), options.closeBtnText !== undefined && (closeButtonLocation = currentOpts.closeBtn, closeButtonText = options.closeBtnText), options.closeBtn !== undefined && (closeButtonLocation = options.closeBtn), closeButtonLocation && this._setCloseBtn(closeButtonLocation, closeButtonText), this._super(options);
},
_setCloseBtn: function(location1, text) {
var dst, btn = this._headerCloseButton;
"none" == // Sanitize value
(location1 = "left" === location1 ? "left" : "right" === location1 ? "right" : "none") ? btn && (btn.remove(), btn = null) : btn ? (btn.removeClass("ui-btn-left ui-btn-right").addClass("ui-btn-" + location1), text && btn.text(text)) : (dst = this._inner.find(":jqmData(role='header')").first(), btn = $("<a></a>", {
role: "button",
href: "#",
class: "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location1
}).text(text || this.options.closeBtnText || "").prependTo(dst), this._on(btn, {
click: "close"
})), this._headerCloseButton = btn;
},
// Close method goes back in history
close: function() {
var hist = $.mobile.navigate.history;
this._isCloseable && (this._isCloseable = !1, $.mobile.hashListeningEnabled && hist.activeIndex > 0 ? $.mobile.back() : $.mobile.pageContainer.pagecontainer("back"));
}
});
}(jQuery, 0), rInitialLetter = /([A-Z])/g, iconposClass = function(iconpos) {
return "ui-btn-icon-" + (null === iconpos ? "left" : iconpos);
}, jQuery.widget("mobile.collapsible", {
options: {
enhanced: !1,
expandCueText: null,
collapseCueText: null,
collapsed: !0,
heading: "h1,h2,h3,h4,h5,h6,legend",
collapsedIcon: null,
expandedIcon: null,
iconpos: null,
theme: null,
contentTheme: null,
inset: null,
corners: null,
mini: null
},
_create: function() {
var elem = this.element, ui = {
accordion: elem.closest(":jqmData(role='collapsible-set'),:jqmData(role='collapsibleset')" + (jQuery.mobile.collapsibleset ? ", :mobile-collapsibleset" : "")).addClass("ui-collapsible-set")
};
this._ui = ui, this._renderedOptions = this._getOptions(this.options), this.options.enhanced ? (ui.heading = jQuery(".ui-collapsible-heading", this.element[0]), ui.content = ui.heading.next(), ui.anchor = jQuery("a", ui.heading[0]).first(), ui.status = ui.anchor.children(".ui-collapsible-heading-status")) : this._enhance(elem, ui), this._on(ui.heading, {
tap: function() {
ui.heading.find("a").first().addClass(jQuery.mobile.activeBtnClass);
},
click: function(event1) {
this._handleExpandCollapse(!ui.heading.hasClass("ui-collapsible-heading-collapsed")), event1.preventDefault(), event1.stopPropagation();
}
});
},
// Adjust the keys inside options for inherited values
_getOptions: function(options) {
var key, accordion = this._ui.accordion, accordionWidget = this._ui.accordionWidget;
for(key in // Copy options
options = jQuery.extend({}, options), accordion.length && !accordionWidget && (this._ui.accordionWidget = accordionWidget = accordion.data("mobile-collapsibleset")), options)// Retrieve the option value first from the options object passed in and, if
// null, from the parent accordion or, if that's null too, or if there's no
// parent accordion, then from the defaults.
options[key] = null != options[key] ? options[key] : accordionWidget ? accordionWidget.options[key] : accordion.length ? jQuery.mobile.getAttribute(accordion[0], key.replace(rInitialLetter, "-$1").toLowerCase()) : null, null == options[key] && (options[key] = jQuery.mobile.collapsible.defaults[key]);
return options;
},
_themeClassFromOption: function(prefix, value) {
return value ? "none" === value ? "" : prefix + value : "";
},
_enhance: function(elem, ui) {
var iconclass, opts = this._renderedOptions, contentThemeClass = this._themeClassFromOption("ui-body-", opts.contentTheme);
return elem.addClass("ui-collapsible " + (opts.inset ? "ui-collapsible-inset " : "") + (opts.inset && opts.corners ? "ui-corner-all " : "") + (contentThemeClass ? "ui-collapsible-themed-content " : "")), ui.originalHeading = elem.children(this.options.heading).first(), ui.content = elem.wrapInner("<div class='ui-collapsible-content " + contentThemeClass + "'></div>").children(".ui-collapsible-content"), ui.heading = ui.originalHeading, ui.heading.is("legend") && (ui.heading = jQuery("<div role='heading'>" + ui.heading.html() + "</div>"), ui.placeholder = jQuery("<div><!-- placeholder for legend --></div>").insertBefore(ui.originalHeading), ui.originalHeading.remove()), iconclass = opts.collapsed ? opts.collapsedIcon ? "ui-icon-" + opts.collapsedIcon : "" : opts.expandedIcon ? "ui-icon-" + opts.expandedIcon : "", ui.status = jQuery("<span class='ui-collapsible-heading-status'></span>"), ui.anchor = ui.heading.detach()//modify markup & attributes
.addClass("ui-collapsible-heading").append(ui.status).wrapInner("<a href='#' class='ui-collapsible-heading-toggle'></a>").find("a").first().addClass("ui-btn " + (iconclass ? iconclass + " " : "") + (iconclass ? iconposClass(opts.iconpos) + " " : "") + this._themeClassFromOption("ui-btn-", opts.theme) + " " + (opts.mini ? "ui-mini " : "")), //drop heading in before content
ui.heading.insertBefore(ui.content), this._handleExpandCollapse(this.options.collapsed), ui;
},
refresh: function() {
this._applyOptions(this.options), this._renderedOptions = this._getOptions(this.options);
},
_applyOptions: function(options) {
var isCollapsed, newTheme, oldTheme, hasCorners, hasIcon, elem = this.element, currentOpts = this._renderedOptions, ui = this._ui, anchor = ui.anchor, status = ui.status, opts = this._getOptions(options);
void 0 !== options.collapsed && this._handleExpandCollapse(options.collapsed), (isCollapsed = elem.hasClass("ui-collapsible-collapsed")) ? opts.expandCueText !== undefined8 && status.text(opts.expandCueText) : opts.collapseCueText !== undefined8 && status.text(opts.collapseCueText), // Update icon
// Is it supposed to have an icon?
hasIcon = // If the collapsedIcon is being set, consult that
opts.collapsedIcon !== undefined8 ? !1 !== opts.collapsedIcon : !1 !== currentOpts.collapsedIcon, (opts.iconpos !== undefined8 || opts.collapsedIcon !== undefined8 || opts.expandedIcon !== undefined8) && (// Remove all current icon-related classes
anchor.removeClass([
iconposClass(currentOpts.iconpos)
].concat(currentOpts.expandedIcon ? [
"ui-icon-" + currentOpts.expandedIcon
] : []).concat(currentOpts.collapsedIcon ? [
"ui-icon-" + currentOpts.collapsedIcon
] : []).join(" ")), hasIcon && anchor.addClass([
iconposClass(opts.iconpos !== undefined8 ? opts.iconpos : currentOpts.iconpos)
].concat(isCollapsed ? [
"ui-icon-" + (opts.collapsedIcon !== undefined8 ? opts.collapsedIcon : currentOpts.collapsedIcon)
] : [
"ui-icon-" + (opts.expandedIcon !== undefined8 ? opts.expandedIcon : currentOpts.expandedIcon)
]).join(" "))), opts.theme !== undefined8 && (oldTheme = this._themeClassFromOption("ui-btn-", currentOpts.theme), newTheme = this._themeClassFromOption("ui-btn-", opts.theme), anchor.removeClass(oldTheme).addClass(newTheme)), opts.contentTheme !== undefined8 && (oldTheme = this._themeClassFromOption("ui-body-", currentOpts.contentTheme), newTheme = this._themeClassFromOption("ui-body-", opts.contentTheme), ui.content.removeClass(oldTheme).addClass(newTheme)), opts.inset !== undefined8 && (elem.toggleClass("ui-collapsible-inset", opts.inset), hasCorners = !!(opts.inset && (opts.corners || currentOpts.corners))), opts.corners !== undefined8 && (hasCorners = !!(opts.corners && (opts.inset || currentOpts.inset))), undefined8 !== hasCorners && elem.toggleClass("ui-corner-all", hasCorners), opts.mini !== undefined8 && anchor.toggleClass("ui-mini", opts.mini);
},
_setOptions: function(options) {
this._applyOptions(options), this._super(options), this._renderedOptions = this._getOptions(this.options);
},
_handleExpandCollapse: function(isCollapse) {
var opts = this._renderedOptions, ui = this._ui;
ui.status.text(isCollapse ? opts.expandCueText : opts.collapseCueText), ui.heading.toggleClass("ui-collapsible-heading-collapsed", isCollapse).find("a").first().toggleClass("ui-icon-" + opts.expandedIcon, !isCollapse)// logic or cause same icon for expanded/collapsed state would remove the ui-icon-class
.toggleClass("ui-icon-" + opts.collapsedIcon, isCollapse || opts.expandedIcon === opts.collapsedIcon).removeClass(jQuery.mobile.activeBtnClass), this.element.toggleClass("ui-collapsible-collapsed", isCollapse), ui.content.toggleClass("ui-collapsible-content-collapsed", isCollapse).attr("aria-hidden", isCollapse).trigger("updatelayout"), this.options.collapsed = isCollapse, this._trigger(isCollapse ? "collapse" : "expand");
},
expand: function() {
this._handleExpandCollapse(!1);
},
collapse: function() {
this._handleExpandCollapse(!0);
},
_destroy: function() {
var ui = this._ui;
!this.options.enhanced && (ui.placeholder ? (ui.originalHeading.insertBefore(ui.placeholder), ui.placeholder.remove(), ui.heading.remove()) : (ui.status.remove(), ui.heading.removeClass("ui-collapsible-heading ui-collapsible-heading-collapsed").children().contents().unwrap()), ui.anchor.contents().unwrap(), ui.content.contents().unwrap(), this.element.removeClass("ui-collapsible ui-collapsible-collapsed ui-collapsible-themed-content ui-collapsible-inset ui-corner-all"));
}
}), // Defaults to be used by all instances of collapsible if per-instance values
// are unset or if nothing is specified by way of inheritance from an accordion.
// Note that this hash does not contain options "collapsed" or "heading",
// because those are not inheritable.
jQuery.mobile.collapsible.defaults = {
expandCueText: " click to expand contents",
collapseCueText: " click to collapse contents",
collapsedIcon: "plus",
contentTheme: "inherit",
expandedIcon: "minus",
iconpos: "left",
inset: !0,
corners: !0,
theme: "inherit",
mini: !1
}, jQuery.mobile.behaviors.addFirstLastClasses = {
_getVisibles: function($els, create) {
var visibles;
return create ? visibles = $els.not(".ui-screen-hidden") : 0 === (visibles = $els.filter(":visible")).length && (visibles = $els.not(".ui-screen-hidden")), visibles;
},
_addFirstLastClasses: function($els, $visibles, create) {
$els.removeClass("ui-first-child ui-last-child"), $visibles.eq(0).addClass("ui-first-child").end().last().addClass("ui-last-child"), create || this.element.trigger("updatelayout");
},
_removeFirstLastClasses: function($els) {
$els.removeClass("ui-first-child ui-last-child");
}
}, function($, undefined) {
var childCollapsiblesSelector = ":mobile-collapsible, " + $.mobile.collapsible.initSelector;
$.widget("mobile.collapsibleset", $.extend({
// The initSelector is deprecated as of 1.4.0. In 1.5.0 we will use
// :jqmData(role='collapsibleset') which will allow us to get rid of the line
// below altogether, because the autoinit will generate such an initSelector
initSelector: ":jqmData(role='collapsible-set'),:jqmData(role='collapsibleset')",
options: $.extend({
enhanced: !1
}, $.mobile.collapsible.defaults),
_handleCollapsibleExpand: function(event1) {
var closestCollapsible = $(event1.target).closest(".ui-collapsible");
closestCollapsible.parent().is(":mobile-collapsibleset, :jqmData(role='collapsible-set')") && closestCollapsible.siblings(".ui-collapsible:not(.ui-collapsible-collapsed)").collapsible("collapse");
},
_create: function() {
var elem = this.element, opts = this.options;
$.extend(this, {
_classes: ""
}), opts.enhanced || (elem.addClass("ui-collapsible-set " + this._themeClassFromOption("ui-group-theme-", opts.theme) + " " + (opts.corners && opts.inset ? "ui-corner-all " : "")), this.element.find($.mobile.collapsible.initSelector).collapsible()), this._on(elem, {
collapsibleexpand: "_handleCollapsibleExpand"
});
},
_themeClassFromOption: function(prefix, value) {
return value ? "none" === value ? "" : prefix + value : "";
},
_init: function() {
this._refresh(!0), // Because the corners are handled by the collapsible itself and the default state is collapsed
// That was causing https://github.com/jquery/jquery-mobile/issues/4116
this.element.children(childCollapsiblesSelector).filter(":jqmData(collapsed='false')").collapsible("expand");
},
_setOptions: function(options) {
var ret, hasCorners, elem = this.element, themeClass = this._themeClassFromOption("ui-group-theme-", options.theme);
return themeClass && elem.removeClass(this._themeClassFromOption("ui-group-theme-", this.options.theme)).addClass(themeClass), void 0 !== options.inset && (hasCorners = !!(options.inset && (options.corners || this.options.corners))), void 0 !== options.corners && (hasCorners = !!(options.corners && (options.inset || this.options.inset))), undefined !== hasCorners && elem.toggleClass("ui-corner-all", hasCorners), ret = this._super(options), this.element.children(":mobile-collapsible").collapsible("refresh"), ret;
},
_destroy: function() {
var el = this.element;
this._removeFirstLastClasses(el.children(childCollapsiblesSelector)), el.removeClass("ui-collapsible-set ui-corner-all " + this._themeClassFromOption("ui-group-theme-", this.options.theme)).children(":mobile-collapsible").collapsible("destroy");
},
_refresh: function(create) {
var collapsiblesInSet = this.element.children(childCollapsiblesSelector);
this.element.find($.mobile.collapsible.initSelector).not(".ui-collapsible").collapsible(), this._addFirstLastClasses(collapsiblesInSet, this._getVisibles(collapsiblesInSet, create), create);
},
refresh: function() {
this._refresh(!1);
}
}, $.mobile.behaviors.addFirstLastClasses));
}(jQuery), // Deprecated in 1.4
jQuery.fn.fieldcontain = function() {
return this.addClass("ui-field-contain");
}, jQuery.fn.grid = function(options) {
return this.each(function() {
var iterator, letter, $this = jQuery(this), o = jQuery.extend({
grid: null
}, options), $kids = $this.children(), gridCols = {
solo: 1,
a: 2,
b: 3,
c: 4,
d: 5
}, grid = o.grid;
if (!grid) {
if ($kids.length <= 5) for(letter in gridCols)gridCols[letter] === $kids.length && (grid = letter);
else grid = "a", $this.addClass("ui-grid-duo");
}
iterator = gridCols[grid], $this.addClass("ui-grid-" + grid), $kids.filter(":nth-child(" + iterator + "n+1)").addClass("ui-block-a"), iterator > 1 && $kids.filter(":nth-child(" + iterator + "n+2)").addClass("ui-block-b"), iterator > 2 && $kids.filter(":nth-child(" + iterator + "n+3)").addClass("ui-block-c"), iterator > 3 && $kids.filter(":nth-child(" + iterator + "n+4)").addClass("ui-block-d"), iterator > 4 && $kids.filter(":nth-child(" + iterator + "n+5)").addClass("ui-block-e");
});
}, function($, undefined) {
$.widget("mobile.navbar", {
options: {
iconpos: "top",
grid: null
},
_create: function() {
var $navbar = this.element, $navbtns = $navbar.find("a"), iconpos = $navbtns.filter(":jqmData(icon)").length ? this.options.iconpos : void 0;
$navbar.addClass("ui-navbar").attr("role", "navigation").find("ul").jqmEnhanceable().grid({
grid: this.options.grid
}), $navbtns.each(function() {
var icon = $.mobile.getAttribute(this, "icon"), theme = $.mobile.getAttribute(this, "theme"), classes = "ui-btn";
theme && (classes += " ui-btn-" + theme), icon && (classes += " ui-icon-" + icon + " ui-btn-icon-" + iconpos), $(this).addClass(classes);
}), $navbar.delegate("a", "vclick", function() {
var activeBtn = $(this);
activeBtn.hasClass("ui-state-disabled") || // DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
activeBtn.hasClass("ui-disabled") || activeBtn.hasClass($.mobile.activeBtnClass) || ($navbtns.removeClass($.mobile.activeBtnClass), activeBtn.addClass($.mobile.activeBtnClass), // The code below is a workaround to fix #1181
$(document1).one("pagehide", function() {
activeBtn.removeClass($.mobile.activeBtnClass);
}));
}), // Buttons in the navbar with ui-state-persist class should regain their active state before page show
$navbar.closest(".ui-page").bind("pagebeforeshow", function() {
$navbtns.filter(".ui-state-persist").addClass($.mobile.activeBtnClass);
});
}
});
}(jQuery), function($, undefined) {
var getAttr = $.mobile.getAttribute;
$.widget("mobile.listview", $.extend({
options: {
theme: null,
countTheme: null,
dividerTheme: null,
icon: "carat-r",
splitIcon: "carat-r",
splitTheme: null,
corners: !0,
shadow: !0,
inset: !1
},
_create: function() {
var listviewClasses = "";
listviewClasses += this.options.inset ? " ui-listview-inset" : "", this.options.inset && (listviewClasses += (this.options.corners ? " ui-corner-all" : "") + (this.options.shadow ? " ui-shadow" : "")), // create listview markup
this.element.addClass(" ui-listview" + listviewClasses), this.refresh(!0);
},
// TODO: Remove in 1.5
_findFirstElementByTagName: function(ele, nextProp, lcName, ucName) {
var dict = {};
for(dict[lcName] = dict[ucName] = !0; ele;){
if (dict[ele.nodeName]) return ele;
ele = ele[nextProp];
}
return null;
},
// TODO: Remove in 1.5
_addThumbClasses: function(containers) {
var i, img, len = containers.length;
for(i = 0; i < len; i++)(img = $(this._findFirstElementByTagName(containers[i].firstChild, "nextSibling", "img", "IMG"))).length && $(this._findFirstElementByTagName(img[0].parentNode, "parentNode", "li", "LI")).addClass(img.hasClass("ui-li-icon") ? "ui-li-has-icon" : "ui-li-has-thumb");
},
_getChildrenByTagName: function(ele, lcName, ucName) {
var results = [], dict = {};
for(dict[lcName] = dict[ucName] = !0, ele = ele.firstChild; ele;)dict[ele.nodeName] && results.push(ele), ele = ele.nextSibling;
return $(results);
},
_beforeListviewRefresh: $.noop,
_afterListviewRefresh: $.noop,
refresh: function(create) {
var buttonClass, pos, numli, item, itemClass, itemTheme, itemIcon, icon, a, isDivider, startCount, newStartCount, value, last, splittheme, splitThemeClass, altButtonClass, dividerTheme, li, o = this.options, $list = this.element, ol = !!$.nodeName($list[0], "ol"), start = $list.attr("start"), itemClassDict = {}, countBubbles = $list.find(".ui-li-count"), countTheme = getAttr($list[0], "counttheme") || this.options.countTheme, countThemeClass = countTheme ? "ui-body-" + countTheme : "ui-body-inherit";
for(o.theme && $list.addClass("ui-group-theme-" + o.theme), ol && (start || 0 === start) && (startCount = parseInt(start, 10) - 1, $list.css("counter-reset", "listnumbering " + startCount)), this._beforeListviewRefresh(), pos = 0, numli = (li = this._getChildrenByTagName($list[0], "li", "LI")).length; pos < numli; pos++)item = li.eq(pos), itemClass = "", (create || 0 > item[0].className.search(/\bui-li-static\b|\bui-li-divider\b/)) && (a = this._getChildrenByTagName(item[0], "a", "A"), isDivider = "list-divider" === getAttr(item[0], "role"), value = item.attr("value"), itemTheme = getAttr(item[0], "theme"), a.length && 0 > a[0].className.search(/\bui-btn\b/) && !isDivider ? (icon = !1 !== (itemIcon = getAttr(item[0], "icon")) && (itemIcon || o.icon), // TODO: Remove in 1.5 together with links.js (links.js / .ui-link deprecated in 1.4)
a.removeClass("ui-link"), buttonClass = "ui-btn", itemTheme && (buttonClass += " ui-btn-" + itemTheme), a.length > 1 ? (itemClass = "ui-li-has-alt", splitThemeClass = (splittheme = getAttr((last = a.last())[0], "theme") || o.splitTheme || getAttr(item[0], "theme", !0)) ? " ui-btn-" + splittheme : "", altButtonClass = "ui-btn ui-btn-icon-notext ui-icon-" + (getAttr(last[0], "icon") || getAttr(item[0], "icon") || o.splitIcon) + splitThemeClass, last.attr("title", $.trim(last.getEncodedText())).addClass(altButtonClass).empty()) : icon && (buttonClass += " ui-btn-icon-right ui-icon-" + icon), a.first().addClass(buttonClass)) : isDivider ? (itemClass = "ui-li-divider ui-bar-" + (getAttr(item[0], "theme") || o.dividerTheme || o.theme || "inherit"), item.attr("role", "heading")) : a.length <= 0 && (itemClass = "ui-li-static ui-body-" + (itemTheme || "inherit")), ol && value && (newStartCount = parseInt(value, 10) - 1, item.css("counter-reset", "listnumbering " + newStartCount))), itemClassDict[itemClass] || (itemClassDict[itemClass] = []), itemClassDict[itemClass].push(item[0]);
// Set the appropriate listview item classes on each list item.
// The main reason we didn't do this
// in the for-loop above is because we can eliminate per-item function overhead
// by calling addClass() and children() once or twice afterwards. This
// can give us a significant boost on platforms like WP7.5.
for(itemClass in itemClassDict)$(itemClassDict[itemClass]).addClass(itemClass);
countBubbles.each(function() {
$(this).closest("li").addClass("ui-li-has-count");
}), countThemeClass && countBubbles.addClass(countThemeClass), // Deprecated in 1.4. From 1.5 you have to add class ui-li-has-thumb or ui-li-has-icon to the LI.
this._addThumbClasses(li), this._addThumbClasses(li.find(".ui-btn")), this._afterListviewRefresh(), this._addFirstLastClasses(li, this._getVisibles(li, create), create);
}
}, $.mobile.behaviors.addFirstLastClasses));
}(jQuery), function($, undefined) {
$.widget("mobile.listview", $.mobile.listview, {
options: {
autodividers: !1,
autodividersSelector: function(elt) {
// look for the text in the given element
var text = $.trim(elt.text()) || null;
return text ? // create the text for the divider (first uppercased letter)
text = text.slice(0, 1).toUpperCase() : null;
}
},
_beforeListviewRefresh: function() {
this.options.autodividers && (this._replaceDividers(), this._superApply(arguments));
},
_replaceDividers: function() {
var i, lis, li, dividerText, divider, lastDividerText = null, list = this.element;
for(list.children("li:jqmData(role='list-divider')").remove(), lis = list.children("li"), i = 0; i < lis.length; i++)li = lis[i], (dividerText = this.options.autodividersSelector($(li))) && lastDividerText !== dividerText && ((divider = document1.createElement("li")).appendChild(document1.createTextNode(dividerText)), divider.setAttribute("data-" + $.mobile.ns + "role", "list-divider"), li.parentNode.insertBefore(divider, li)), lastDividerText = dividerText;
}
});
}(jQuery), function($, undefined) {
var rdivider = /(^|\s)ui-li-divider($|\s)/, rhidden = /(^|\s)ui-screen-hidden($|\s)/;
$.widget("mobile.listview", $.mobile.listview, {
options: {
hideDividers: !1
},
_afterListviewRefresh: function() {
var items, idx, item, hideDivider = !0;
if (this._superApply(arguments), this.options.hideDividers) for(idx = (items = this._getChildrenByTagName(this.element[0], "li", "LI")).length - 1; idx > -1; idx--)(item = items[idx]).className.match(rdivider) ? (hideDivider && (item.className = item.className + " ui-screen-hidden"), hideDivider = !0) : item.className.match(rhidden) || (hideDivider = !1);
}
});
}(jQuery), jQuery.mobile.nojs = function(target) {
jQuery(":jqmData(role='nojs')", target).addClass("ui-nojs");
}, jQuery.mobile.behaviors.formReset = {
_handleFormReset: function() {
this._on(this.element.closest("form"), {
reset: function() {
this._delay("_reset");
}
});
}
}, /*
* "checkboxradio" plugin
*/ function($, undefined) {
var escapeId = $.mobile.path.hashToSelector;
$.widget("mobile.checkboxradio", $.extend({
initSelector: "input:not( :jqmData(role='flipswitch' ) )[type='checkbox'],input[type='radio']:not( :jqmData(role='flipswitch' ))",
options: {
theme: "inherit",
mini: !1,
wrapperClass: null,
enhanced: !1,
iconpos: "left"
},
_create: function() {
var input = this.element, o = this.options, inheritAttr = function(input, dataAttr) {
return input.jqmData(dataAttr) || input.closest("form, fieldset").jqmData(dataAttr);
}, // NOTE: Windows Phone could not find the label through a selector
// filter works though.
parentLabel = input.closest("label"), label = parentLabel.length ? parentLabel : input.closest("form, fieldset, :jqmData(role='page'), :jqmData(role='dialog')").find("label").filter("[for='" + escapeId(input[0].id) + "']").first(), inputtype = input[0].type;
("checkbox" === inputtype || "radio" === inputtype) && (this.element[0].disabled && (this.options.disabled = !0), o.iconpos = inheritAttr(input, "iconpos") || label.attr("data-" + $.mobile.ns + "iconpos") || o.iconpos, // Establish options
o.mini = inheritAttr(input, "mini") || o.mini, // Expose for other methods
$.extend(this, {
input: input,
label: label,
parentLabel: parentLabel,
inputtype: inputtype,
checkedClass: "ui-" + inputtype + "-on",
uncheckedClass: "ui-" + inputtype + "-off"
}), this.options.enhanced || this._enhance(), this._on(label, {
vmouseover: "_handleLabelVMouseOver",
vclick: "_handleLabelVClick"
}), this._on(input, {
vmousedown: "_cacheVals",
vclick: "_handleInputVClick",
focus: "_handleInputFocus",
blur: "_handleInputBlur"
}), this._handleFormReset(), this.refresh());
},
_enhance: function() {
this.label.addClass("ui-btn ui-corner-all"), this.parentLabel.length > 0 ? this.input.add(this.label).wrapAll(this._wrapper()) : (//this.element.replaceWith( this.input.add( this.label ).wrapAll( this._wrapper() ) );
this.element.wrap(this._wrapper()), this.element.parent().prepend(this.label)), // Wrap the input + label in a div
this._setOptions({
theme: this.options.theme,
iconpos: this.options.iconpos,
mini: this.options.mini
});
},
_wrapper: function() {
return $("<div class='" + (this.options.wrapperClass ? this.options.wrapperClass : "") + " ui-" + this.inputtype + (this.options.disabled ? " ui-state-disabled" : "") + "' ></div>");
},
_handleInputFocus: function() {
this.label.addClass($.mobile.focusClass);
},
_handleInputBlur: function() {
this.label.removeClass($.mobile.focusClass);
},
_handleInputVClick: function() {
// Adds checked attribute to checked input when keyboard is used
this.element.prop("checked", this.element.is(":checked")), this._getInputSet().not(this.element).prop("checked", !1), this._updateAll();
},
_handleLabelVMouseOver: function(event1) {
this.label.parent().hasClass("ui-state-disabled") && event1.stopPropagation();
},
_handleLabelVClick: function(event1) {
var input = this.element;
if (input.is(":disabled")) {
event1.preventDefault();
return;
}
return this._cacheVals(), input.prop("checked", "radio" === this.inputtype || !input.prop("checked")), // trigger click handler's bound directly to the input as a substitute for
// how label clicks behave normally in the browsers
// TODO: it would be nice to let the browser's handle the clicks and pass them
// through to the associate input. we can swallow that click at the parent
// wrapper element level
input.triggerHandler("click"), // Input set for common radio buttons will contain all the radio
// buttons, but will not for checkboxes. clearing the checked status
// of other radios ensures the active button state is applied properly
this._getInputSet().not(input).prop("checked", !1), this._updateAll(), !1;
},
_cacheVals: function() {
this._getInputSet().each(function() {
$(this).attr("data-" + $.mobile.ns + "cacheVal", this.checked);
});
},
// Returns those radio buttons that are supposed to be in the same group as
// this radio button. In the case of a checkbox or a radio lacking a name
// attribute, it returns this.element.
_getInputSet: function() {
var selector, formId, radio = this.element[0], name = radio.name, form = radio.form, doc = this.element.parents().last().get(0), // A radio is always a member of its own group
radios = this.element;
return name && "radio" === this.inputtype && doc && (selector = "input[type='radio'][name='" + escapeId(name) + "']", form ? ((formId = form.id) && (radios = $(selector + "[form='" + escapeId(formId) + "']", doc)), // Also add to those the radios in the form itself
radios = $(form).find(selector).filter(function() {
// Some radios inside the form may belong to some other form by virtue of
// having a form attribute defined on them, so we must filter them out here
return this.form === form;
}).add(radios)) : // Collect all those radios which are also outside of a form and match our name
radios = $(selector, doc).filter(function() {
return !this.form;
})), radios;
},
_updateAll: function() {
var self = this;
this._getInputSet().each(function() {
var $this = $(this);
(this.checked || "checkbox" === self.inputtype) && $this.trigger("change");
}).checkboxradio("refresh");
},
_reset: function() {
this.refresh();
},
// Is the widget supposed to display an icon?
_hasIcon: function() {
var controlgroup, controlgroupWidget, controlgroupConstructor = $.mobile.controlgroup;
return(// If the controlgroup widget is defined ...
!controlgroupConstructor || !((controlgroup = this.element.closest(":mobile-controlgroup," + controlgroupConstructor.prototype.initSelector)).length > 0) || (// ... look for a controlgroup widget instance, and ...
(controlgroupWidget = $.data(controlgroup[0], "mobile-controlgroup")) ? controlgroupWidget.options.type : controlgroup.attr("data-" + $.mobile.ns + "type")) !== "horizontal");
},
refresh: function() {
var hasIcon = this._hasIcon(), isChecked = this.element[0].checked, active = $.mobile.activeBtnClass, iconposClass = "ui-btn-icon-" + this.options.iconpos, addClasses = [], removeClasses = [];
hasIcon ? (removeClasses.push(active), addClasses.push(iconposClass)) : (removeClasses.push(iconposClass), (isChecked ? addClasses : removeClasses).push(active)), isChecked ? (addClasses.push(this.checkedClass), removeClasses.push(this.uncheckedClass)) : (addClasses.push(this.uncheckedClass), removeClasses.push(this.checkedClass)), this.label.addClass(addClasses.join(" ")).removeClass(removeClasses.join(" "));
},
widget: function() {
return this.label.parent();
},
_setOptions: function(options) {
var label = this.label, currentOptions = this.options, outer = this.widget(), hasIcon = this._hasIcon();
void 0 !== options.disabled && (this.input.prop("disabled", !!options.disabled), outer.toggleClass("ui-state-disabled", !!options.disabled)), void 0 !== options.mini && outer.toggleClass("ui-mini", !!options.mini), options.theme !== undefined && label.removeClass("ui-btn-" + currentOptions.theme).addClass("ui-btn-" + options.theme), options.wrapperClass !== undefined && outer.removeClass(currentOptions.wrapperClass).addClass(options.wrapperClass), options.iconpos !== undefined && hasIcon ? label.removeClass("ui-btn-icon-" + currentOptions.iconpos).addClass("ui-btn-icon-" + options.iconpos) : hasIcon || label.removeClass("ui-btn-icon-" + currentOptions.iconpos), this._super(options);
}
}, $.mobile.behaviors.formReset));
}(jQuery), function($, undefined) {
$.widget("mobile.button", {
initSelector: "input[type='button'], input[type='submit'], input[type='reset']",
options: {
theme: null,
icon: null,
iconpos: "left",
iconshadow: !1,
corners: !0,
shadow: !0,
inline: null,
mini: null,
wrapperClass: null,
enhanced: !1
},
_create: function() {
this.element.is(":disabled") && (this.options.disabled = !0), this.options.enhanced || this._enhance(), $.extend(this, {
wrapper: this.element.parent()
}), this._on({
focus: function() {
this.widget().addClass($.mobile.focusClass);
},
blur: function() {
this.widget().removeClass($.mobile.focusClass);
}
}), this.refresh(!0);
},
_enhance: function() {
this.element.wrap(this._button());
},
_button: function() {
var options = this.options, iconClasses = this._getIconClasses(this.options);
return $("<div class='ui-btn ui-input-btn" + (options.wrapperClass ? " " + options.wrapperClass : "") + (options.theme ? " ui-btn-" + options.theme : "") + (options.corners ? " ui-corner-all" : "") + (options.shadow ? " ui-shadow" : "") + (options.inline ? " ui-btn-inline" : "") + (options.mini ? " ui-mini" : "") + (options.disabled ? " ui-state-disabled" : "") + (iconClasses ? " " + iconClasses : "") + "' >" + this.element.val() + "</div>");
},
widget: function() {
return this.wrapper;
},
_destroy: function() {
this.element.insertBefore(this.button), this.button.remove();
},
_getIconClasses: function(options) {
return options.icon ? "ui-icon-" + options.icon + (options.iconshadow ? " ui-shadow-icon" : "") + " ui-btn-icon-" + options.iconpos : "";
},
_setOptions: function(options) {
var outer = this.widget();
void 0 !== options.theme && outer.removeClass(this.options.theme).addClass("ui-btn-" + options.theme), void 0 !== options.corners && outer.toggleClass("ui-corner-all", options.corners), options.shadow !== undefined && outer.toggleClass("ui-shadow", options.shadow), options.inline !== undefined && outer.toggleClass("ui-btn-inline", options.inline), options.mini !== undefined && outer.toggleClass("ui-mini", options.mini), options.disabled !== undefined && (this.element.prop("disabled", options.disabled), outer.toggleClass("ui-state-disabled", options.disabled)), (options.icon !== undefined || options.iconshadow !== undefined /* TODO: Deprecated in 1.4, remove in 1.5. */ || options.iconpos !== undefined) && outer.removeClass(this._getIconClasses(this.options)).addClass(this._getIconClasses($.extend({}, this.options, options))), this._super(options);
},
refresh: function(create) {
var originalElement, isDisabled = this.element.prop("disabled");
this.options.icon && "notext" === this.options.iconpos && this.element.attr("title") && this.element.attr("title", this.element.val()), create || (originalElement = this.element.detach(), $(this.wrapper).text(this.element.val()).append(originalElement)), this.options.disabled !== isDisabled && this._setOptions({
disabled: isDisabled
});
}
});
}(jQuery), disabledZoom = (initialContent = (meta = jQuery("meta[name=viewport]")).attr("content")) + ",maximum-scale=1, user-scalable=no", enabledZoom = initialContent + ",maximum-scale=10, user-scalable=yes", disabledInitially = /(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test(initialContent), jQuery.mobile.zoom = jQuery.extend({}, {
enabled: !disabledInitially,
locked: !1,
disable: function(lock) {
disabledInitially || jQuery.mobile.zoom.locked || (meta.attr("content", disabledZoom), jQuery.mobile.zoom.enabled = !1, jQuery.mobile.zoom.locked = lock || !1);
},
enable: function(unlock) {
disabledInitially || jQuery.mobile.zoom.locked && !0 !== unlock || (meta.attr("content", enabledZoom), jQuery.mobile.zoom.enabled = !0, jQuery.mobile.zoom.locked = !1);
},
restore: function() {
disabledInitially || (meta.attr("content", initialContent), jQuery.mobile.zoom.enabled = !0);
}
}), function($, undefined) {
$.widget("mobile.textinput", {
initSelector: "input[type='text'],input[type='search'],:jqmData(type='search'),input[type='number'],:jqmData(type='number'),input[type='password'],input[type='email'],input[type='url'],input[type='tel'],textarea,input[type='time'],input[type='date'],input[type='month'],input[type='week'],input[type='datetime'],input[type='datetime-local'],input[type='color'],input:not([type]),input[type='file']",
options: {
theme: null,
corners: !0,
mini: !1,
// This option defaults to true on iOS devices.
preventFocusZoom: /iPhone|iPad|iPod/.test(navigator.platform) && navigator.userAgent.indexOf("AppleWebKit") > -1,
wrapperClass: "",
enhanced: !1
},
_create: function() {
var options = this.options, isSearch = this.element.is("[type='search'], :jqmData(type='search')"), isTextarea = "TEXTAREA" === this.element[0].tagName, isRange = this.element.is("[data-" + ($.mobile.ns || "") + "type='range']"), inputNeedsWrap = (this.element.is("input") || this.element.is("[data-" + ($.mobile.ns || "") + "type='search']")) && !isRange;
this.element.prop("disabled") && (options.disabled = !0), $.extend(this, {
classes: this._classesFromOptions(),
isSearch: isSearch,
isTextarea: isTextarea,
isRange: isRange,
inputNeedsWrap: inputNeedsWrap
}), this._autoCorrect(), options.enhanced || this._enhance(), this._on({
focus: "_handleFocus",
blur: "_handleBlur"
});
},
refresh: function() {
this.setOptions({
disabled: this.element.is(":disabled")
});
},
_enhance: function() {
var elementClasses = [];
this.isTextarea && elementClasses.push("ui-input-text"), (this.isTextarea || this.isRange) && elementClasses.push("ui-shadow-inset"), this.inputNeedsWrap ? this.element.wrap(this._wrap()) : elementClasses = elementClasses.concat(this.classes), this.element.addClass(elementClasses.join(" "));
},
widget: function() {
return this.inputNeedsWrap ? this.element.parent() : this.element;
},
_classesFromOptions: function() {
var options = this.options, classes = [];
return classes.push("ui-body-" + (null === options.theme ? "inherit" : options.theme)), options.corners && classes.push("ui-corner-all"), options.mini && classes.push("ui-mini"), options.disabled && classes.push("ui-state-disabled"), options.wrapperClass && classes.push(options.wrapperClass), classes;
},
_wrap: function() {
return $("<div class='" + (this.isSearch ? "ui-input-search " : "ui-input-text ") + this.classes.join(" ") + " ui-shadow-inset'></div>");
},
_autoCorrect: function() {
// XXX: Temporary workaround for issue 785 (Apple bug 8910589).
// Turn off autocorrect and autocomplete on non-iOS 5 devices
// since the popup they use can't be dismissed by the user. Note
// that we test for the presence of the feature by looking for
// the autocorrect property on the input element. We currently
// have no test for iOS 5 or newer so we're temporarily using
// the touchOverflow support flag for jQM 1.0. Yes, I feel dirty.
// - jblas
void 0 === this.element[0].autocorrect || $.support.touchOverflow || (// Set the attribute instead of the property just in case there
// is code that attempts to make modifications via HTML.
this.element[0].setAttribute("autocorrect", "off"), this.element[0].setAttribute("autocomplete", "off"));
},
_handleBlur: function() {
this.widget().removeClass($.mobile.focusClass), this.options.preventFocusZoom && $.mobile.zoom.enable(!0);
},
_handleFocus: function() {
this.options.preventFocusZoom && $.mobile.zoom.disable(!0), this.widget().addClass($.mobile.focusClass);
},
_setOptions: function(options) {
var outer = this.widget();
this._super(options), (void 0 !== options.disabled || void 0 !== options.mini || options.corners !== undefined || options.theme !== undefined || options.wrapperClass !== undefined) && (outer.removeClass(this.classes.join(" ")), this.classes = this._classesFromOptions(), outer.addClass(this.classes.join(" "))), options.disabled !== undefined && this.element.prop("disabled", !!options.disabled);
},
_destroy: function() {
!this.options.enhanced && (this.inputNeedsWrap && this.element.unwrap(), this.element.removeClass("ui-input-text " + this.classes.join(" ")));
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.slider", $.extend({
initSelector: "input[type='range'], :jqmData(type='range'), :jqmData(role='slider')",
widgetEventPrefix: "slide",
options: {
theme: null,
trackTheme: null,
corners: !0,
mini: !1,
highlight: !1
},
_create: function() {
// TODO: Each of these should have comments explain what they're for
var bg, options, wrapper, j, length, i, optionsCount, origTabIndex, side, activeClass, sliderImg, control = this.element, trackTheme = this.options.trackTheme || $.mobile.getAttribute(control[0], "theme"), cornerClass = this.options.corners || control.jqmData("corners") ? " ui-corner-all" : "", miniClass = this.options.mini || control.jqmData("mini") ? " ui-mini" : "", cType = control[0].nodeName.toLowerCase(), isToggleSwitch = "select" === cType, isRangeslider = control.parent().is(":jqmData(role='rangeslider')"), controlID = control.attr("id"), $label = $("[for='" + controlID + "']"), labelID = $label.attr("id") || controlID + "-label", min = isToggleSwitch ? 0 : parseFloat(control.attr("min")), max = isToggleSwitch ? control.find("option").length - 1 : parseFloat(control.attr("max")), step = window.parseFloat(control.attr("step") || 1), domHandle = document1.createElement("a"), handle = $(domHandle), domSlider = document1.createElement("div"), slider = $(domSlider), valuebg = !!this.options.highlight && !isToggleSwitch && ((bg = document1.createElement("div")).className = "ui-slider-bg " + $.mobile.activeBtnClass, $(bg).prependTo(slider));
if ($label.attr("id", labelID), this.isToggleSwitch = isToggleSwitch, domHandle.setAttribute("href", "#"), domSlider.setAttribute("role", "application"), domSlider.className = [
this.isToggleSwitch ? "ui-slider ui-slider-track ui-shadow-inset " : "ui-slider-track ui-shadow-inset ",
isToggleSwitch ? "ui-slider-switch" : "",
trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit",
cornerClass,
miniClass
].join(""), domHandle.className = "ui-slider-handle", domSlider.appendChild(domHandle), handle.attr({
role: "slider",
"aria-valuemin": min,
"aria-valuemax": max,
"aria-valuenow": this._value(),
"aria-valuetext": this._value(),
title: this._value(),
"aria-labelledby": labelID
}), $.extend(this, {
slider: slider,
handle: handle,
control: control,
type: cType,
step: step,
max: max,
min: min,
valuebg: valuebg,
isRangeslider: isRangeslider,
dragging: !1,
beforeStart: null,
userModified: !1,
mouseMoved: !1
}), isToggleSwitch) {
for(// TODO: restore original tabindex (if any) in a destroy method
(origTabIndex = control.attr("tabindex")) && handle.attr("tabindex", origTabIndex), control.attr("tabindex", "-1").focus(function() {
$(this).blur(), handle.focus();
}), (wrapper = document1.createElement("div")).className = "ui-slider-inneroffset", j = 0, length = domSlider.childNodes.length; j < length; j++)wrapper.appendChild(domSlider.childNodes[j]);
for(domSlider.appendChild(wrapper), // slider.wrapInner( "<div class='ui-slider-inneroffset'></div>" );
// make the handle move with a smooth transition
handle.addClass("ui-slider-handle-snapping"), i = 0, optionsCount = (options = control.find("option")).length; i < optionsCount; i++)side = i ? "a" : "b", activeClass = i ? " " + $.mobile.activeBtnClass : "", (sliderImg = document1.createElement("span")).className = [
"ui-slider-label ui-slider-label-",
side,
activeClass
].join(""), sliderImg.setAttribute("role", "img"), sliderImg.appendChild(document1.createTextNode(options[i].innerHTML)), $(sliderImg).prependTo(slider);
this._labels = $(".ui-slider-label", slider);
}
// monitor the input for updated values
control.addClass(isToggleSwitch ? "ui-slider-switch" : "ui-slider-input"), this._on(control, {
change: "_controlChange",
keyup: "_controlKeyup",
blur: "_controlBlur",
vmouseup: "_controlVMouseUp"
}), slider.bind("vmousedown", $.proxy(this._sliderVMouseDown, this)).bind("vclick", !1), // We have to instantiate a new function object for the unbind to work properly
// since the method itself is defined in the prototype (causing it to unbind everything)
this._on(document1, {
vmousemove: "_preventDocumentDrag"
}), this._on(slider.add(document1), {
vmouseup: "_sliderVMouseUp"
}), slider.insertAfter(control), isToggleSwitch || isRangeslider || (wrapper = this.options.mini ? "<div class='ui-slider ui-mini'>" : "<div class='ui-slider'>", control.add(slider).wrapAll(wrapper)), // bind the handle event callbacks and set the context to the widget instance
this._on(this.handle, {
vmousedown: "_handleVMouseDown",
keydown: "_handleKeydown",
keyup: "_handleKeyup"
}), this.handle.bind("vclick", !1), this._handleFormReset(), this.refresh(void 0, void 0, !0);
},
_setOptions: function(options) {
options.theme !== undefined && this._setTheme(options.theme), options.trackTheme !== undefined && this._setTrackTheme(options.trackTheme), options.corners !== undefined && this._setCorners(options.corners), options.mini !== undefined && this._setMini(options.mini), options.highlight !== undefined && this._setHighlight(options.highlight), options.disabled !== undefined && this._setDisabled(options.disabled), this._super(options);
},
_controlChange: function(event1) {
// if the user dragged the handle, the "change" event was triggered from inside refresh(); don't call refresh() again
if (!1 === this._trigger("controlchange", event1)) return !1;
this.mouseMoved || this.refresh(this._value(), !0);
},
_controlKeyup: function() {
// necessary?
this.refresh(this._value(), !0, !0);
},
_controlBlur: function() {
this.refresh(this._value(), !0);
},
// it appears the clicking the up and down buttons in chrome on
// range/number inputs doesn't trigger a change until the field is
// blurred. Here we check thif the value has changed and refresh
_controlVMouseUp: function() {
this._checkedRefresh();
},
// NOTE force focus on handle
_handleVMouseDown: function() {
this.handle.focus();
},
_handleKeydown: function(event1) {
var index = this._value();
if (!this.options.disabled) {
// In all cases prevent the default and mark the handle as active
switch(event1.keyCode){
case $.mobile.keyCode.HOME:
case $.mobile.keyCode.END:
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
event1.preventDefault(), this._keySliding || (this._keySliding = !0, this.handle.addClass("ui-state-active"));
}
// move the slider according to the keypress
switch(event1.keyCode){
case $.mobile.keyCode.HOME:
this.refresh(this.min);
break;
case $.mobile.keyCode.END:
this.refresh(this.max);
break;
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
this.refresh(index + this.step);
break;
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
this.refresh(index - this.step);
}
}
},
_handleKeyup: function() {
this._keySliding && (this._keySliding = !1, this.handle.removeClass("ui-state-active"));
},
_sliderVMouseDown: function(event1) {
return(// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
!this.options.disabled && (1 === event1.which || 0 === event1.which || event1.which === undefined) && !1 !== this._trigger("beforestart", event1) && (this.dragging = !0, this.userModified = !1, this.mouseMoved = !1, this.isToggleSwitch && (this.beforeStart = this.element[0].selectedIndex), this.refresh(event1), this._trigger("start"), !1));
},
_sliderVMouseUp: function() {
if (this.dragging) return this.dragging = !1, this.isToggleSwitch && (// make the handle move with a smooth transition
this.handle.addClass("ui-slider-handle-snapping"), this.mouseMoved ? this.userModified ? this.refresh(+(0 === this.beforeStart)) : this.refresh(this.beforeStart) : // this is just a click, change the value
this.refresh(+(0 === this.beforeStart))), this.mouseMoved = !1, this._trigger("stop"), !1;
},
_preventDocumentDrag: function(event1) {
return(// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
!1 !== this._trigger("drag", event1) && (this.dragging && !this.options.disabled ? (// this.mouseMoved must be updated before refresh() because it will be used in the control "change" event
this.mouseMoved = !0, this.isToggleSwitch && // make the handle move in sync with the mouse
this.handle.removeClass("ui-slider-handle-snapping"), this.refresh(event1), // only after refresh() you can calculate this.userModified
this.userModified = this.beforeStart !== this.element[0].selectedIndex, !1) : void 0));
},
_checkedRefresh: function() {
this.value !== this._value() && this.refresh(this._value());
},
_value: function() {
return this.isToggleSwitch ? this.element[0].selectedIndex : parseFloat(this.element.val());
},
_reset: function() {
this.refresh(undefined, !1, !0);
},
refresh: function(val, isfromControl, preventInputUpdate) {
// NOTE: we don't return here because we want to support programmatic
// alteration of the input value, which should still update the slider
var bg, left, width, data, pxStep, percent, control, isInput, optionElements, min, max, step, newval, valModStep, alignValue, percentPerStep, handlePercent, aPercent, bPercent, valueChanged, parentTheme = $.mobile.getAttribute(this.element[0], "theme"), theme = this.options.theme || parentTheme, trackTheme = this.options.trackTheme || parentTheme, cornerClass = this.options.corners ? " ui-corner-all" : "", miniClass = this.options.mini ? " ui-mini" : "";
if (this.slider[0].className = [
this.isToggleSwitch ? "ui-slider ui-slider-switch ui-slider-track ui-shadow-inset" : "ui-slider-track ui-shadow-inset",
trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit",
cornerClass,
miniClass
].join(""), (this.options.disabled || this.element.prop("disabled")) && this.disable(), // set the stored value for comparison later
this.value = this._value(), this.options.highlight && !this.isToggleSwitch && 0 === this.slider.find(".ui-slider-bg").length && (this.valuebg = ((bg = document1.createElement("div")).className = "ui-slider-bg " + $.mobile.activeBtnClass, $(bg).prependTo(this.slider))), this.handle.addClass("ui-btn" + (theme ? " ui-btn-" + theme : "") + " ui-shadow"), control = this.element, optionElements = (isInput = !this.isToggleSwitch) ? [] : control.find("option"), min = isInput ? parseFloat(control.attr("min")) : 0, max = isInput ? parseFloat(control.attr("max")) : optionElements.length - 1, step = isInput && parseFloat(control.attr("step")) > 0 ? parseFloat(control.attr("step")) : 1, "object" == typeof val) {
if (data = val, left = this.slider.offset().left, pxStep = (width = this.slider.width()) / ((max - min) / step), !this.dragging || data.pageX < left - 8 || data.pageX > left + width + 8) return;
percent = pxStep > 1 ? (data.pageX - left) / width * 100 : Math.round((data.pageX - left) / width * 100);
} else null == val && (val = isInput ? parseFloat(control.val() || 0) : control[0].selectedIndex), percent = (parseFloat(val) - min) / (max - min) * 100;
if (!isNaN(percent) && (//from jQuery UI slider, the following source will round to the nearest step
valModStep = ((newval = percent / 100 * (max - min) + min) - min) % step, alignValue = newval - valModStep, 2 * Math.abs(valModStep) >= step && (alignValue += valModStep > 0 ? step : -step), percentPerStep = 100 / ((max - min) / step), // Since JavaScript has problems with large floats, round
// the final value to 5 digits after the decimal point (see jQueryUI: #4124)
newval = parseFloat(alignValue.toFixed(5)), void 0 === pxStep && (pxStep = width / ((max - min) / step)), pxStep > 1 && isInput && (percent = (newval - min) * percentPerStep * (1 / step)), percent < 0 && (percent = 0), percent > 100 && (percent = 100), newval < min && (newval = min), newval > max && (newval = max), this.handle.css("left", percent + "%"), this.handle[0].setAttribute("aria-valuenow", isInput ? newval : optionElements.eq(newval).attr("value")), this.handle[0].setAttribute("aria-valuetext", isInput ? newval : optionElements.eq(newval).getEncodedText()), this.handle[0].setAttribute("title", isInput ? newval : optionElements.eq(newval).getEncodedText()), this.valuebg && this.valuebg.css("width", percent + "%"), this._labels && (handlePercent = this.handle.width() / this.slider.width() * 100, aPercent = percent && handlePercent + (100 - handlePercent) * percent / 100, bPercent = 100 === percent ? 0 : Math.min(handlePercent + 100 - aPercent, 100), this._labels.each(function() {
var ab = $(this).hasClass("ui-slider-label-a");
$(this).width((ab ? aPercent : bPercent) + "%");
})), !preventInputUpdate)) {
if (valueChanged = !1, isInput ? (valueChanged = control.val() !== newval, control.val(newval)) : (valueChanged = control[0].selectedIndex !== newval, control[0].selectedIndex = newval), !1 === this._trigger("beforechange", val)) return !1;
!isfromControl && valueChanged && control.trigger("change");
}
},
_setHighlight: function(value) {
(value = !!value) ? (this.options.highlight = !!value, this.refresh()) : this.valuebg && (this.valuebg.remove(), this.valuebg = !1);
},
_setTheme: function(value) {
this.handle.removeClass("ui-btn-" + this.options.theme).addClass("ui-btn-" + value);
var currentTheme = this.options.theme ? this.options.theme : "inherit";
this.control.removeClass("ui-body-" + currentTheme).addClass("ui-body-" + (value || "inherit"));
},
_setTrackTheme: function(value) {
var currentTrackTheme = this.options.trackTheme ? this.options.trackTheme : "inherit";
this.slider.removeClass("ui-body-" + currentTrackTheme).addClass("ui-body-" + (value || "inherit"));
},
_setMini: function(value) {
value = !!value, this.isToggleSwitch || this.isRangeslider || (this.slider.parent().toggleClass("ui-mini", value), this.element.toggleClass("ui-mini", value)), this.slider.toggleClass("ui-mini", value);
},
_setCorners: function(value) {
this.slider.toggleClass("ui-corner-all", value), this.isToggleSwitch || this.control.toggleClass("ui-corner-all", value);
},
_setDisabled: function(value) {
value = !!value, this.element.prop("disabled", value), this.slider.toggleClass("ui-state-disabled", value).attr("aria-disabled", value);
}
}, $.mobile.behaviors.formReset));
}(jQuery), function($, undefined) {
var popup;
$.widget("mobile.slider", $.mobile.slider, {
options: {
popupEnabled: !1,
showValue: !1
},
_create: function() {
this._super(), $.extend(this, {
_currentValue: null,
_popup: null,
_popupVisible: !1
}), this._setOption("popupEnabled", this.options.popupEnabled), this._on(this.handle, {
vmousedown: "_showPopup"
}), this._on(this.slider.add(this.document), {
vmouseup: "_hidePopup"
}), this._refresh();
},
// position the popup centered 5px above the handle
_positionPopup: function() {
var dstOffset = this.handle.offset();
this._popup.offset({
left: dstOffset.left + (this.handle.width() - this._popup.width()) / 2,
top: dstOffset.top - this._popup.outerHeight() - 5
});
},
_setOption: function(key, value) {
this._super(key, value), "showValue" === key ? this.handle.html(value && !this.options.mini ? this._value() : "") : "popupEnabled" === key && value && !this._popup && (this._popup = (popup || (popup = $("<div></div>", {
class: "ui-slider-popup ui-shadow ui-corner-all"
})), popup.clone()).addClass("ui-body-" + (this.options.theme || "a")).hide().insertBefore(this.element));
},
// show value on the handle and in popup
refresh: function() {
this._super.apply(this, arguments), this._refresh();
},
_refresh: function() {
var newValue, o = this.options;
o.popupEnabled && // remove the title attribute from the handle (which is
// responsible for the annoying tooltip); NB we have
// to do it here as the jqm slider sets it every time
// the slider's value changes :(
this.handle.removeAttr("title"), (newValue = this._value()) !== this._currentValue && (this._currentValue = newValue, o.popupEnabled && this._popup ? (this._positionPopup(), this._popup.html(newValue)) : o.showValue && !this.options.mini && this.handle.html(newValue));
},
_showPopup: function() {
this.options.popupEnabled && !this._popupVisible && (this.handle.html(""), this._popup.show(), this._positionPopup(), this._popupVisible = !0);
},
_hidePopup: function() {
var o = this.options;
o.popupEnabled && this._popupVisible && (o.showValue && !o.mini && this.handle.html(this._value()), this._popup.hide(), this._popupVisible = !1);
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.flipswitch", $.extend({
options: {
onText: "On",
offText: "Off",
theme: null,
enhanced: !1,
wrapperClass: null,
corners: !0,
mini: !1
},
_create: function() {
this.options.enhanced ? $.extend(this, {
flipswitch: this.element.parent(),
on: this.element.find(".ui-flipswitch-on").eq(0),
off: this.element.find(".ui-flipswitch-off").eq(0),
type: this.element.get(0).tagName
}) : this._enhance(), this._handleFormReset(), // Transfer tabindex to "on" element and make input unfocusable
this._originalTabIndex = this.element.attr("tabindex"), null != this._originalTabIndex && this.on.attr("tabindex", this._originalTabIndex), this.element.attr("tabindex", "-1"), this._on({
focus: "_handleInputFocus"
}), this.element.is(":disabled") && this._setOptions({
disabled: !0
}), this._on(this.flipswitch, {
click: "_toggle",
swipeleft: "_left",
swiperight: "_right"
}), this._on(this.on, {
keydown: "_keydown"
}), this._on({
change: "refresh"
});
},
_handleInputFocus: function() {
this.on.focus();
},
widget: function() {
return this.flipswitch;
},
_left: function() {
this.flipswitch.removeClass("ui-flipswitch-active"), "SELECT" === this.type ? this.element.get(0).selectedIndex = 0 : this.element.prop("checked", !1), this.element.trigger("change");
},
_right: function() {
this.flipswitch.addClass("ui-flipswitch-active"), "SELECT" === this.type ? this.element.get(0).selectedIndex = 1 : this.element.prop("checked", !0), this.element.trigger("change");
},
_enhance: function() {
var flipswitch = $("<div>"), options = this.options, element = this.element, theme = options.theme ? options.theme : "inherit", // The "on" button is an anchor so it's focusable
on = $("<a></a>", {
href: "#"
}), off = $("<span></span>"), type = element.get(0).tagName, onText = "INPUT" === type ? options.onText : element.find("option").eq(1).text(), offText = "INPUT" === type ? options.offText : element.find("option").eq(0).text();
on.addClass("ui-flipswitch-on ui-btn ui-shadow ui-btn-inherit").text(onText), off.addClass("ui-flipswitch-off").text(offText), flipswitch.addClass("ui-flipswitch ui-shadow-inset ui-bar-" + theme + " " + (options.wrapperClass ? options.wrapperClass : "") + " " + (element.is(":checked") || element.find("option").eq(1).is(":selected") ? "ui-flipswitch-active" : "") + (element.is(":disabled") ? " ui-state-disabled" : "") + (options.corners ? " ui-corner-all" : "") + (options.mini ? " ui-mini" : "")).append(on, off), element.addClass("ui-flipswitch-input").after(flipswitch).appendTo(flipswitch), $.extend(this, {
flipswitch: flipswitch,
on: on,
off: off,
type: type
});
},
_reset: function() {
this.refresh();
},
refresh: function() {
var direction, existingDirection = this.flipswitch.hasClass("ui-flipswitch-active") ? "_right" : "_left";
(direction = "SELECT" === this.type ? this.element.get(0).selectedIndex > 0 ? "_right" : "_left" : this.element.prop("checked") ? "_right" : "_left") !== existingDirection && this[direction]();
},
_toggle: function() {
this[this.flipswitch.hasClass("ui-flipswitch-active") ? "_left" : "_right"]();
},
_keydown: function(e) {
e.which === $.mobile.keyCode.LEFT ? this._left() : e.which === $.mobile.keyCode.RIGHT ? this._right() : e.which === $.mobile.keyCode.SPACE && (this._toggle(), e.preventDefault());
},
_setOptions: function(options) {
if (void 0 !== options.theme) {
var currentTheme = options.theme ? options.theme : "inherit", newTheme = options.theme ? options.theme : "inherit";
this.widget().removeClass("ui-bar-" + currentTheme).addClass("ui-bar-" + newTheme);
}
void 0 !== options.onText && this.on.text(options.onText), options.offText !== undefined && this.off.text(options.offText), options.disabled !== undefined && this.widget().toggleClass("ui-state-disabled", options.disabled), options.mini !== undefined && this.widget().toggleClass("ui-mini", options.mini), options.corners !== undefined && this.widget().toggleClass("ui-corner-all", options.corners), this._super(options);
},
_destroy: function() {
!this.options.enhanced && (null != this._originalTabIndex ? this.element.attr("tabindex", this._originalTabIndex) : this.element.removeAttr("tabindex"), this.on.remove(), this.off.remove(), this.element.unwrap(), this.flipswitch.remove(), this.removeClass("ui-flipswitch-input"));
}
}, $.mobile.behaviors.formReset));
}(jQuery), function($, undefined) {
$.widget("mobile.rangeslider", $.extend({
options: {
theme: null,
trackTheme: null,
corners: !0,
mini: !1,
highlight: !0
},
_create: function() {
var $el = this.element, elClass = this.options.mini ? "ui-rangeslider ui-mini" : "ui-rangeslider", _inputFirst = $el.find("input").first(), _inputLast = $el.find("input").last(), _label = $el.find("label").first(), _sliderWidgetFirst = $.data(_inputFirst.get(0), "mobile-slider") || $.data(_inputFirst.slider().get(0), "mobile-slider"), _sliderWidgetLast = $.data(_inputLast.get(0), "mobile-slider") || $.data(_inputLast.slider().get(0), "mobile-slider"), _sliderFirst = _sliderWidgetFirst.slider, _sliderLast = _sliderWidgetLast.slider, firstHandle = _sliderWidgetFirst.handle, _sliders = $("<div class='ui-rangeslider-sliders' />").appendTo($el);
_inputFirst.addClass("ui-rangeslider-first"), _inputLast.addClass("ui-rangeslider-last"), $el.addClass(elClass), _sliderFirst.appendTo(_sliders), _sliderLast.appendTo(_sliders), _label.insertBefore($el), firstHandle.prependTo(_sliderLast), $.extend(this, {
_inputFirst: _inputFirst,
_inputLast: _inputLast,
_sliderFirst: _sliderFirst,
_sliderLast: _sliderLast,
_label: _label,
_targetVal: null,
_sliderTarget: !1,
_sliders: _sliders,
_proxy: !1
}), this.refresh(), this._on(this.element.find("input.ui-slider-input"), {
slidebeforestart: "_slidebeforestart",
slidestop: "_slidestop",
slidedrag: "_slidedrag",
slidebeforechange: "_change",
blur: "_change",
keyup: "_change"
}), this._on({
mousedown: "_change"
}), this._on(this.element.closest("form"), {
reset: "_handleReset"
}), this._on(firstHandle, {
vmousedown: "_dragFirstHandle"
});
},
_handleReset: function() {
var self = this;
//we must wait for the stack to unwind before updateing other wise sliders will not have updated yet
setTimeout(function() {
self._updateHighlight();
}, 0);
},
_dragFirstHandle: function(event1) {
return(//if the first handle is dragged send the event to the first slider
$.data(this._inputFirst.get(0), "mobile-slider").dragging = !0, $.data(this._inputFirst.get(0), "mobile-slider").refresh(event1), !1);
},
_slidedrag: function(event1) {
var first = $(event1.target).is(this._inputFirst), otherSlider = first ? this._inputLast : this._inputFirst;
//if the drag was initiated on an extreme and the other handle is focused send the events to
//the closest handle
if (this._sliderTarget = !1, "first" === this._proxy && first || "last" === this._proxy && !first) return $.data(otherSlider.get(0), "mobile-slider").dragging = !0, $.data(otherSlider.get(0), "mobile-slider").refresh(event1), !1;
},
_slidestop: function(event1) {
var first = $(event1.target).is(this._inputFirst);
this._proxy = !1, //this stops dragging of the handle and brings the active track to the front
//this makes clicks on the track go the the last handle used
this.element.find("input").trigger("vmouseup"), this._sliderFirst.css("z-index", first ? 1 : "");
},
_slidebeforestart: function(event1) {
this._sliderTarget = !1, $(event1.originalEvent.target).hasClass("ui-slider-track") && (this._sliderTarget = !0, this._targetVal = $(event1.target).val());
},
_setOptions: function(options) {
void 0 !== options.theme && this._setTheme(options.theme), void 0 !== options.trackTheme && this._setTrackTheme(options.trackTheme), options.mini !== undefined && this._setMini(options.mini), options.highlight !== undefined && this._setHighlight(options.highlight), this._super(options), this.refresh();
},
refresh: function() {
var $el = this.element, o = this.options;
(this._inputFirst.is(":disabled") || this._inputLast.is(":disabled")) && (this.options.disabled = !0), $el.find("input").slider({
theme: o.theme,
trackTheme: o.trackTheme,
disabled: o.disabled,
corners: o.corners,
mini: o.mini,
highlight: o.highlight
}).slider("refresh"), this._updateHighlight();
},
_change: function(event1) {
if ("keyup" === event1.type) return this._updateHighlight(), !1;
var self = this, min = parseFloat(this._inputFirst.val(), 10), max = parseFloat(this._inputLast.val(), 10), first = $(event1.target).hasClass("ui-rangeslider-first"), thisSlider = first ? this._inputFirst : this._inputLast, otherSlider = first ? this._inputLast : this._inputFirst;
if (this._inputFirst.val() > this._inputLast.val() && "mousedown" === event1.type && !$(event1.target).hasClass("ui-slider-handle")) thisSlider.blur();
else if ("mousedown" === event1.type) return;
if (min > max && !this._sliderTarget ? (//this prevents min from being greater then max
thisSlider.val(first ? max : min).slider("refresh"), this._trigger("normalize")) : min > max && (//this makes it so clicks on the target on either extreme go to the closest handle
thisSlider.val(this._targetVal).slider("refresh"), //You must wait for the stack to unwind so first slider is updated before updating second
setTimeout(function() {
otherSlider.val(first ? min : max).slider("refresh"), $.data(otherSlider.get(0), "mobile-slider").handle.focus(), self._sliderFirst.css("z-index", first ? "" : 1), self._trigger("normalize");
}, 0), this._proxy = first ? "first" : "last"), min === max ? ($.data(thisSlider.get(0), "mobile-slider").handle.css("z-index", 1), $.data(otherSlider.get(0), "mobile-slider").handle.css("z-index", 0)) : ($.data(otherSlider.get(0), "mobile-slider").handle.css("z-index", ""), $.data(thisSlider.get(0), "mobile-slider").handle.css("z-index", "")), this._updateHighlight(), min >= max) return !1;
},
_updateHighlight: function() {
var min = parseInt($.data(this._inputFirst.get(0), "mobile-slider").handle.get(0).style.left, 10), max = parseInt($.data(this._inputLast.get(0), "mobile-slider").handle.get(0).style.left, 10);
this.element.find(".ui-slider-bg").css({
"margin-left": min + "%",
width: max - min + "%"
});
},
_setTheme: function(value) {
this._inputFirst.slider("option", "theme", value), this._inputLast.slider("option", "theme", value);
},
_setTrackTheme: function(value) {
this._inputFirst.slider("option", "trackTheme", value), this._inputLast.slider("option", "trackTheme", value);
},
_setMini: function(value) {
this._inputFirst.slider("option", "mini", value), this._inputLast.slider("option", "mini", value), this.element.toggleClass("ui-mini", !!value);
},
_setHighlight: function(value) {
this._inputFirst.slider("option", "highlight", value), this._inputLast.slider("option", "highlight", value);
},
_destroy: function() {
this._label.prependTo(this.element), this.element.removeClass("ui-rangeslider ui-mini"), this._inputFirst.after(this._sliderFirst), this._inputLast.after(this._sliderLast), this._sliders.remove(), this.element.find("input").removeClass("ui-rangeslider-first ui-rangeslider-last").slider("destroy");
}
}, $.mobile.behaviors.formReset));
}(jQuery), function($, undefined) {
$.widget("mobile.textinput", $.mobile.textinput, {
options: {
clearBtn: !1,
clearBtnText: "Clear text"
},
_create: function() {
this._super(), (this.options.clearBtn || this.isSearch) && this._addClearBtn();
},
clearButton: function() {
return $("<a href='#' class='ui-input-clear ui-btn ui-icon-delete ui-btn-icon-notext ui-corner-all' title='" + this.options.clearBtnText + "'>" + this.options.clearBtnText + "</a>");
},
_clearBtnClick: function(event1) {
this.element.val("").focus().trigger("change"), this._clearBtn.addClass("ui-input-clear-hidden"), event1.preventDefault();
},
_addClearBtn: function() {
this.options.enhanced || this._enhanceClear(), $.extend(this, {
_clearBtn: this.widget().find("a.ui-input-clear")
}), this._bindClearEvents(), this._toggleClear();
},
_enhanceClear: function() {
this.clearButton().appendTo(this.widget()), this.widget().addClass("ui-input-has-clear");
},
_bindClearEvents: function() {
this._on(this._clearBtn, {
click: "_clearBtnClick"
}), this._on({
keyup: "_toggleClear",
change: "_toggleClear",
input: "_toggleClear",
focus: "_toggleClear",
blur: "_toggleClear",
cut: "_toggleClear",
paste: "_toggleClear"
});
},
_unbindClear: function() {
this._off(this._clearBtn, "click"), this._off(this.element, "keyup change input focus blur cut paste");
},
_setOptions: function(options) {
this._super(options), void 0 === options.clearBtn || this.element.is("textarea, :jqmData(type='range')") || (options.clearBtn ? this._addClearBtn() : this._destroyClear()), void 0 !== options.clearBtnText && this._clearBtn !== undefined && this._clearBtn.text(options.clearBtnText).attr("title", options.clearBtnText);
},
_toggleClear: function() {
this._delay("_toggleClearClass", 0);
},
_toggleClearClass: function() {
this._clearBtn.toggleClass("ui-input-clear-hidden", !this.element.val());
},
_destroyClear: function() {
this.widget().removeClass("ui-input-has-clear"), this._unbindClear(), this._clearBtn.remove();
},
_destroy: function() {
this._super(), this._destroyClear();
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.textinput", $.mobile.textinput, {
options: {
autogrow: !0,
keyupTimeoutBuffer: 100
},
_create: function() {
this._super(), this.options.autogrow && this.isTextarea && this._autogrow();
},
_autogrow: function() {
this.element.addClass("ui-textinput-autogrow"), this._on({
keyup: "_timeout",
change: "_timeout",
input: "_timeout",
paste: "_timeout"
}), // Attach to the various you-have-become-visible notifications that the
// various framework elements emit.
// TODO: Remove all but the updatelayout handler once #6426 is fixed.
this._on(!0, this.document, {
// TODO: Move to non-deprecated event
pageshow: "_handleShow",
popupbeforeposition: "_handleShow",
updatelayout: "_handleShow",
panelopen: "_handleShow"
});
},
// Synchronously fix the widget height if this widget's parents are such
// that they show/hide content at runtime. We still need to check whether
// the widget is actually visible in case it is contained inside multiple
// such containers. For example: panel contains collapsible contains
// autogrow textinput. The panel may emit "panelopen" indicating that its
// content has become visible, but the collapsible is still collapsed, so
// the autogrow textarea is still not visible.
_handleShow: function(event1) {
$.contains(event1.target, this.element[0]) && this.element.is(":visible") && ("popupbeforeposition" !== event1.type && this.element.addClass("ui-textinput-autogrow-resize").animationComplete($.proxy(function() {
this.element.removeClass("ui-textinput-autogrow-resize");
}, this), "transition"), this._timeout());
},
_unbindAutogrow: function() {
this.element.removeClass("ui-textinput-autogrow"), this._off(this.element, "keyup change input paste"), this._off(this.document, "pageshow popupbeforeposition updatelayout panelopen");
},
keyupTimeout: null,
_prepareHeightUpdate: function(delay) {
this.keyupTimeout && clearTimeout(this.keyupTimeout), void 0 === delay ? this._updateHeight() : this.keyupTimeout = this._delay("_updateHeight", delay);
},
_timeout: function() {
this._prepareHeightUpdate(this.options.keyupTimeoutBuffer);
},
_updateHeight: function() {
var paddingTop, scrollHeight, clientHeight, borderTop, height, scrollTop = this.window.scrollTop();
this.keyupTimeout = 0, "onpage" in this.element[0] || this.element.css({
height: 0,
"min-height": 0,
"max-height": 0
}), scrollHeight = this.element[0].scrollHeight, clientHeight = this.element[0].clientHeight, borderTop = parseFloat(this.element.css("border-top-width")), height = scrollHeight + (borderTop + parseFloat(this.element.css("border-bottom-width"))) + 15, 0 === clientHeight && (paddingTop = parseFloat(this.element.css("padding-top")), height += paddingTop + parseFloat(this.element.css("padding-bottom"))), this.element.css({
height: height,
"min-height": "",
"max-height": ""
}), this.window.scrollTop(scrollTop);
},
refresh: function() {
this.options.autogrow && this.isTextarea && this._updateHeight();
},
_setOptions: function(options) {
this._super(options), void 0 !== options.autogrow && this.isTextarea && (options.autogrow ? this._autogrow() : this._unbindAutogrow());
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.selectmenu", $.extend({
initSelector: "select:not( :jqmData(role='slider')):not( :jqmData(role='flipswitch') )",
options: {
theme: null,
icon: "carat-d",
iconpos: "right",
inline: !1,
corners: !0,
shadow: !0,
iconshadow: !1,
overlayTheme: null,
dividerTheme: null,
hidePlaceholderMenuItems: !0,
closeText: "Close",
nativeMenu: !0,
// This option defaults to true on iOS devices.
preventFocusZoom: /iPhone|iPad|iPod/.test(navigator.platform) && navigator.userAgent.indexOf("AppleWebKit") > -1,
mini: !1
},
_button: function() {
return $("<div/>");
},
_setDisabled: function(value) {
return this.element.attr("disabled", value), this.button.attr("aria-disabled", value), this._setOption("disabled", value);
},
_focusButton: function() {
var self = this;
setTimeout(function() {
self.button.focus();
}, 40);
},
_selectOptions: function() {
return this.select.find("option");
},
// setup items that are generally necessary for select menu extension
_preExtension: function() {
var inline = this.options.inline || this.element.jqmData("inline"), mini = this.options.mini || this.element.jqmData("mini"), classes = "";
~this.element[0].className.indexOf("ui-btn-left") && (classes = " ui-btn-left"), ~this.element[0].className.indexOf("ui-btn-right") && (classes = " ui-btn-right"), inline && (classes += " ui-btn-inline"), mini && (classes += " ui-mini"), this.select = this.element.removeClass("ui-btn-left ui-btn-right").wrap("<div class='ui-select" + classes + "'>"), this.selectId = this.select.attr("id") || "select-" + this.uuid, this.buttonId = this.selectId + "-button", this.label = $("label[for='" + this.selectId + "']"), this.isMultiple = this.select[0].multiple;
},
_destroy: function() {
var wrapper = this.element.parents(".ui-select");
wrapper.length > 0 && (wrapper.is(".ui-btn-left, .ui-btn-right") && this.element.addClass(wrapper.hasClass("ui-btn-left") ? "ui-btn-left" : "ui-btn-right"), this.element.insertAfter(wrapper), wrapper.remove());
},
_create: function() {
this._preExtension(), this.button = this._button();
var self = this, options = this.options, iconpos = !!options.icon && (options.iconpos || this.select.jqmData("iconpos")), button = this.button.insertBefore(this.select).attr("id", this.buttonId).addClass("ui-btn" + (options.icon ? " ui-icon-" + options.icon + " ui-btn-icon-" + iconpos + (options.iconshadow ? " ui-shadow-icon" : "") : "") + (options.theme ? " ui-btn-" + options.theme : "") + (options.corners ? " ui-corner-all" : "") + (options.shadow ? " ui-shadow" : ""));
this.setButtonText(), options.nativeMenu && window.opera && window.opera.version && button.addClass("ui-select-nativeonly"), this.isMultiple && (this.buttonCount = $("<span>").addClass("ui-li-count ui-body-inherit").hide().appendTo(button.addClass("ui-li-has-count"))), (options.disabled || this.element.attr("disabled")) && this.disable(), // Events on native select
this.select.change(function() {
self.refresh(), options.nativeMenu && this.blur();
}), this._handleFormReset(), this._on(this.button, {
keydown: "_handleKeydown"
}), this.build();
},
build: function() {
var self = this;
this.select.appendTo(self.button).bind("vmousedown", function() {
// Add active class to button
self.button.addClass($.mobile.activeBtnClass);
}).bind("focus", function() {
self.button.addClass($.mobile.focusClass);
}).bind("blur", function() {
self.button.removeClass($.mobile.focusClass);
}).bind("focus vmouseover", function() {
self.button.trigger("vmouseover");
}).bind("vmousemove", function() {
// Remove active class on scroll/touchmove
self.button.removeClass($.mobile.activeBtnClass);
}).bind("change blur vmouseout", function() {
self.button.trigger("vmouseout").removeClass($.mobile.activeBtnClass);
}), // In many situations, iOS will zoom into the select upon tap, this prevents that from happening
self.button.bind("vmousedown", function() {
self.options.preventFocusZoom && $.mobile.zoom.disable(!0);
}), self.label.bind("click focus", function() {
self.options.preventFocusZoom && $.mobile.zoom.disable(!0);
}), self.select.bind("focus", function() {
self.options.preventFocusZoom && $.mobile.zoom.disable(!0);
}), self.button.bind("mouseup", function() {
self.options.preventFocusZoom && setTimeout(function() {
$.mobile.zoom.enable(!0);
}, 0);
}), self.select.bind("blur", function() {
self.options.preventFocusZoom && $.mobile.zoom.enable(!0);
});
},
selected: function() {
return this._selectOptions().filter(":selected");
},
selectedIndices: function() {
var self = this;
return this.selected().map(function() {
return self._selectOptions().index(this);
}).get();
},
setButtonText: function() {
var selected = this.selected(), text = this.placeholder, span = $(document1.createElement("span"));
this.button.children("span").not(".ui-li-count").remove().end().end().prepend(((text = selected.length ? selected.map(function() {
return $(this).text();
}).get().join(", ") : this.placeholder) ? span.text(text) : // Set the contents to which we write as   to be XHTML compliant - see gh-6699
span.html(" "), span.addClass(this.select.attr("class")).addClass(selected.attr("class")).removeClass("ui-screen-hidden")));
},
setButtonCount: function() {
var selected = this.selected();
// multiple count inside button
this.isMultiple && this.buttonCount[selected.length > 1 ? "show" : "hide"]().text(selected.length);
},
_handleKeydown: function() {
this._delay("_refreshButton");
},
_reset: function() {
this.refresh();
},
_refreshButton: function() {
this.setButtonText(), this.setButtonCount();
},
refresh: function() {
this._refreshButton();
},
// open and close preserved in native selects
// to simplify users code when looping over selects
open: $.noop,
close: $.noop,
disable: function() {
this._setDisabled(!0), this.button.addClass("ui-state-disabled");
},
enable: function() {
this._setDisabled(!1), this.button.removeClass("ui-state-disabled");
}
}, $.mobile.behaviors.formReset));
}(jQuery), jQuery.mobile.links = function(target) {
//links within content areas, tests included with page
jQuery(target).find("a").jqmEnhanceable().filter(":jqmData(rel='popup')[href][href!='']").each(function() {
// Accessibility info for popups
var idref = this.getAttribute("href").substring(1);
idref && (this.setAttribute("aria-haspopup", !0), this.setAttribute("aria-owns", idref), this.setAttribute("aria-expanded", !1));
}).end().not(".ui-btn, :jqmData(role='none'), :jqmData(role='nojs')").addClass("ui-link");
}, function($, undefined) {
function fitSegmentInsideSegment(windowSize, segmentSize, offset, desired) {
var returnValue = desired;
return windowSize < segmentSize ? offset + (windowSize - segmentSize) / 2 : Math.min(Math.max(offset, desired - segmentSize / 2), offset + windowSize - segmentSize);
}
function getWindowCoordinates(theWindow) {
return {
x: theWindow.scrollLeft(),
y: theWindow.scrollTop(),
cx: theWindow[0].innerWidth || theWindow.width(),
cy: theWindow[0].innerHeight || theWindow.height()
};
}
$.widget("mobile.popup", {
options: {
wrapperClass: null,
theme: null,
overlayTheme: null,
shadow: !0,
corners: !0,
transition: "none",
positionTo: "origin",
tolerance: null,
closeLinkSelector: "a:jqmData(rel='back')",
closeLinkEvents: "click.popup",
navigateEvents: "navigate.popup",
closeEvents: "navigate.popup pagebeforechange.popup",
dismissible: !0,
enhanced: !1,
// NOTE Windows Phone 7 has a scroll position caching issue that
// requires us to disable popup history management by default
// https://github.com/jquery/jquery-mobile/issues/4784
//
// NOTE this option is modified in _create!
history: !$.mobile.browser.oldIE
},
_create: function() {
var theElement = this.element, myId = theElement.attr("id"), currentOptions = this.options;
// We need to adjust the history option to be false if there's no AJAX nav.
// We can't do it in the option declarations because those are run before
// it is determined whether there shall be AJAX nav.
currentOptions.history = currentOptions.history && $.mobile.ajaxEnabled && $.mobile.hashListeningEnabled, // Define instance variables
$.extend(this, {
_scrollTop: 0,
_page: theElement.closest(".ui-page"),
_ui: null,
_fallbackTransition: "",
_currentTransition: !1,
_prerequisites: null,
_isOpen: !1,
_tolerance: null,
_resizeData: null,
_ignoreResizeTo: 0,
_orientationchangeInProgress: !1
}), 0 === this._page.length && (this._page = $("body")), currentOptions.enhanced ? this._ui = {
container: theElement.parent(),
screen: theElement.parent().prev(),
placeholder: $(this.document[0].getElementById(myId + "-placeholder"))
} : (this._ui = this._enhance(theElement, myId), this._applyTransition(currentOptions.transition)), this._setTolerance(currentOptions.tolerance)._ui.focusElement = this._ui.container, // Event handlers
this._on(this._ui.screen, {
vclick: "_eatEventAndClose"
}), this._on(this.window, {
orientationchange: $.proxy(this, "_handleWindowOrientationchange"),
resize: $.proxy(this, "_handleWindowResize"),
keyup: $.proxy(this, "_handleWindowKeyUp")
}), this._on(this.document, {
focusin: "_handleDocumentFocusIn"
});
},
_enhance: function(theElement, myId) {
var currentOptions = this.options, wrapperClass = currentOptions.wrapperClass, ui = {
screen: $("<div class='ui-screen-hidden ui-popup-screen " + this._themeClassFromOption("ui-overlay-", currentOptions.overlayTheme) + "'></div>"),
placeholder: $("<div style='display: none;'><!-- placeholder --></div>"),
container: $("<div class='ui-popup-container ui-popup-hidden ui-popup-truncate" + (wrapperClass ? " " + wrapperClass : "") + "'></div>")
}, fragment = this.document[0].createDocumentFragment();
return fragment.appendChild(ui.screen[0]), fragment.appendChild(ui.container[0]), myId && (ui.screen.attr("id", myId + "-screen"), ui.container.attr("id", myId + "-popup"), ui.placeholder.attr("id", myId + "-placeholder").html("<!-- placeholder for " + myId + " -->")), // Apply the proto
this._page[0].appendChild(fragment), // Leave a placeholder where the element used to be
ui.placeholder.insertAfter(theElement), theElement.detach().addClass("ui-popup " + this._themeClassFromOption("ui-body-", currentOptions.theme) + " " + (currentOptions.shadow ? "ui-overlay-shadow " : "") + (currentOptions.corners ? "ui-corner-all " : "")).appendTo(ui.container), ui;
},
_eatEventAndClose: function(theEvent) {
return theEvent.preventDefault(), theEvent.stopImmediatePropagation(), this.options.dismissible && this.close(), !1;
},
// Make sure the screen covers the entire document - CSS is sometimes not
// enough to accomplish this.
_resizeScreen: function() {
var screen1 = this._ui.screen, popupHeight = this._ui.container.outerHeight(!0), screenHeight = screen1.removeAttr("style").height(), // Subtracting 1 here is necessary for an obscure Andrdoid 4.0 bug where
// the browser hangs if the screen covers the entire document :/
documentHeight = this.document.height() - 1;
screenHeight < documentHeight ? screen1.height(documentHeight) : popupHeight > screenHeight && screen1.height(popupHeight);
},
_handleWindowKeyUp: function(theEvent) {
if (this._isOpen && theEvent.keyCode === $.mobile.keyCode.ESCAPE) return this._eatEventAndClose(theEvent);
},
_expectResizeEvent: function() {
var windowCoordinates = getWindowCoordinates(this.window);
if (this._resizeData) {
if (windowCoordinates.x === this._resizeData.windowCoordinates.x && windowCoordinates.y === this._resizeData.windowCoordinates.y && windowCoordinates.cx === this._resizeData.windowCoordinates.cx && windowCoordinates.cy === this._resizeData.windowCoordinates.cy) // timeout not refreshed
return !1;
// clear existing timeout - it will be refreshed below
clearTimeout(this._resizeData.timeoutId);
}
return this._resizeData = {
timeoutId: this._delay("_resizeTimeout", 200),
windowCoordinates: windowCoordinates
}, !0;
},
_resizeTimeout: function() {
this._isOpen ? this._expectResizeEvent() || (this._ui.container.hasClass("ui-popup-hidden") && (// effectively rapid-open the popup while leaving the screen intact
this._ui.container.removeClass("ui-popup-hidden ui-popup-truncate"), this.reposition({
positionTo: "window"
}), this._ignoreResizeEvents()), this._resizeScreen(), this._resizeData = null, this._orientationchangeInProgress = !1) : (this._resizeData = null, this._orientationchangeInProgress = !1);
},
_stopIgnoringResizeEvents: function() {
this._ignoreResizeTo = 0;
},
_ignoreResizeEvents: function() {
this._ignoreResizeTo && clearTimeout(this._ignoreResizeTo), this._ignoreResizeTo = this._delay("_stopIgnoringResizeEvents", 1000);
},
_handleWindowResize: function() {
this._isOpen && 0 === this._ignoreResizeTo && (this._expectResizeEvent() || this._orientationchangeInProgress) && !this._ui.container.hasClass("ui-popup-hidden") && // effectively rapid-close the popup while leaving the screen intact
this._ui.container.addClass("ui-popup-hidden ui-popup-truncate").removeAttr("style");
},
_handleWindowOrientationchange: function() {
!this._orientationchangeInProgress && this._isOpen && 0 === this._ignoreResizeTo && (this._expectResizeEvent(), this._orientationchangeInProgress = !0);
},
// When the popup is open, attempting to focus on an element that is not a
// child of the popup will redirect focus to the popup
_handleDocumentFocusIn: function(theEvent) {
var target, targetElement = theEvent.target, ui = this._ui;
if (this._isOpen) {
if (targetElement !== ui.container[0]) {
if (0 === (target = $(targetElement)).parents().filter(ui.container[0]).length) return $(this.document[0].activeElement).one("focus", function() {
target.blur();
}), ui.focusElement.focus(), theEvent.preventDefault(), theEvent.stopImmediatePropagation(), !1;
ui.focusElement[0] === ui.container[0] && (ui.focusElement = target);
}
this._ignoreResizeEvents();
}
},
_themeClassFromOption: function(prefix, value) {
return value ? "none" === value ? "" : prefix + value : prefix + "inherit";
},
_applyTransition: function(value) {
return value && (this._ui.container.removeClass(this._fallbackTransition), "none" !== value && (this._fallbackTransition = $.mobile._maybeDegradeTransition(value), "none" === this._fallbackTransition && (this._fallbackTransition = ""), this._ui.container.addClass(this._fallbackTransition))), this;
},
_setOptions: function(newOptions) {
var currentOptions = this.options, theElement = this.element, screen1 = this._ui.screen;
return void 0 !== newOptions.wrapperClass && this._ui.container.removeClass(currentOptions.wrapperClass).addClass(newOptions.wrapperClass), void 0 !== newOptions.theme && theElement.removeClass(this._themeClassFromOption("ui-body-", currentOptions.theme)).addClass(this._themeClassFromOption("ui-body-", newOptions.theme)), newOptions.overlayTheme !== undefined && (screen1.removeClass(this._themeClassFromOption("ui-overlay-", currentOptions.overlayTheme)).addClass(this._themeClassFromOption("ui-overlay-", newOptions.overlayTheme)), this._isOpen && screen1.addClass("in")), newOptions.shadow !== undefined && theElement.toggleClass("ui-overlay-shadow", newOptions.shadow), newOptions.corners !== undefined && theElement.toggleClass("ui-corner-all", newOptions.corners), newOptions.transition === undefined || this._currentTransition || this._applyTransition(newOptions.transition), newOptions.tolerance !== undefined && this._setTolerance(newOptions.tolerance), newOptions.disabled !== undefined && newOptions.disabled && this.close(), this._super(newOptions);
},
_setTolerance: function(value) {
var ar, tol = {
t: 30,
r: 15,
b: 30,
l: 15
};
if (undefined !== value) switch(ar = String(value).split(","), $.each(ar, function(idx, val) {
ar[idx] = parseInt(val, 10);
}), ar.length){
// All values are to be the same
case 1:
isNaN(ar[0]) || (tol.t = tol.r = tol.b = tol.l = ar[0]);
break;
// The first value denotes top/bottom tolerance, and the second value denotes left/right tolerance
case 2:
isNaN(ar[0]) || (tol.t = tol.b = ar[0]), isNaN(ar[1]) || (tol.l = tol.r = ar[1]);
break;
// The array contains values in the order top, right, bottom, left
case 4:
isNaN(ar[0]) || (tol.t = ar[0]), isNaN(ar[1]) || (tol.r = ar[1]), isNaN(ar[2]) || (tol.b = ar[2]), isNaN(ar[3]) || (tol.l = ar[3]);
}
return this._tolerance = tol, this;
},
_clampPopupWidth: function(infoOnly) {
var windowCoordinates = getWindowCoordinates(this.window), // rectangle within which the popup must fit
rectangle = {
x: this._tolerance.l,
y: windowCoordinates.y + this._tolerance.t,
cx: windowCoordinates.cx - this._tolerance.l - this._tolerance.r,
cy: windowCoordinates.cy - this._tolerance.t - this._tolerance.b
};
return infoOnly || // Clamp the width of the menu before grabbing its size
this._ui.container.css("max-width", rectangle.cx), {
rc: rectangle,
menuSize: {
cx: this._ui.container.outerWidth(!0),
cy: this._ui.container.outerHeight(!0)
}
};
},
_calculateFinalLocation: function(desired, clampInfo) {
var returnValue, rectangle = clampInfo.rc, menuSize = clampInfo.menuSize;
return(// Make sure the top of the menu is visible
// Center the menu over the desired coordinates, while not going outside
// the window tolerances. This will center wrt. the window if the popup is
// too large.
(returnValue = {
left: fitSegmentInsideSegment(rectangle.cx, menuSize.cx, rectangle.x, desired.x),
top: fitSegmentInsideSegment(rectangle.cy, menuSize.cy, rectangle.y, desired.y)
}).top = Math.max(0, returnValue.top), // If the height of the menu is smaller than the height of the document
// align the bottom with the bottom of the document
returnValue.top -= Math.min(returnValue.top, Math.max(0, returnValue.top + menuSize.cy - this.document.height())), returnValue);
},
// Try and center the overlay over the given coordinates
_placementCoords: function(desired) {
return this._calculateFinalLocation(desired, this._clampPopupWidth());
},
_createPrerequisites: function(screenPrerequisite, containerPrerequisite, whenDone) {
var prerequisites, self = this;
// It is important to maintain both the local variable prerequisites and
// self._prerequisites. The local variable remains in the closure of the
// functions which call the callbacks passed in. The comparison between the
// local variable and self._prerequisites is necessary, because once a
// function has been passed to .animationComplete() it will be called next
// time an animation completes, even if that's not the animation whose end
// the function was supposed to catch (for example, if an abort happens
// during the opening animation, the .animationComplete handler is not
// called for that animation anymore, but the handler remains attached, so
// it is called the next time the popup is opened - making it stale.
// Comparing the local variable prerequisites to the widget-level variable
// self._prerequisites ensures that callbacks triggered by a stale
// .animationComplete will be ignored.
(prerequisites = {
screen: $.Deferred(),
container: $.Deferred()
}).screen.then(function() {
prerequisites === self._prerequisites && screenPrerequisite();
}), prerequisites.container.then(function() {
prerequisites === self._prerequisites && containerPrerequisite();
}), $.when(prerequisites.screen, prerequisites.container).done(function() {
prerequisites === self._prerequisites && (self._prerequisites = null, whenDone());
}), self._prerequisites = prerequisites;
},
_animate: function(args) {
if (// NOTE before removing the default animation of the screen
// this had an animate callback that would resolve the deferred
// now the deferred is resolved immediately
// TODO remove the dependency on the screen deferred
this._ui.screen.removeClass(args.classToRemove).addClass(args.screenClassToAdd), args.prerequisites.screen.resolve(), args.transition && "none" !== args.transition && (args.applyTransition && this._applyTransition(args.transition), this._fallbackTransition)) {
this._ui.container.addClass(args.containerClassToAdd).removeClass(args.classToRemove).animationComplete($.proxy(args.prerequisites.container, "resolve"));
return;
}
this._ui.container.removeClass(args.classToRemove), args.prerequisites.container.resolve();
},
// The desired coordinates passed in will be returned untouched if no reference element can be identified via
// desiredPosition.positionTo. Nevertheless, this function ensures that its return value always contains valid
// x and y coordinates by specifying the center middle of the window if the coordinates are absent.
// options: { x: coordinate, y: coordinate, positionTo: string: "origin", "window", or jQuery selector
_desiredCoords: function(openOptions) {
var offset, dst = null, windowCoordinates = getWindowCoordinates(this.window), x = openOptions.x, y = openOptions.y, pTo = openOptions.positionTo;
// Establish which element will serve as the reference
if (pTo && "origin" !== pTo) {
if ("window" === pTo) x = windowCoordinates.cx / 2 + windowCoordinates.x, y = windowCoordinates.cy / 2 + windowCoordinates.y;
else {
try {
dst = $(pTo);
} catch (err) {
dst = null;
}
dst && (dst.filter(":visible"), 0 === dst.length && (dst = null));
}
}
return dst && (x = (offset = dst.offset()).left + dst.outerWidth() / 2, y = offset.top + dst.outerHeight() / 2), ("number" !== $.type(x) || isNaN(x)) && (x = windowCoordinates.cx / 2 + windowCoordinates.x), ("number" !== $.type(y) || isNaN(y)) && (y = windowCoordinates.cy / 2 + windowCoordinates.y), {
x: x,
y: y
};
},
_reposition: function(openOptions) {
// We only care about position-related parameters for repositioning
openOptions = {
x: openOptions.x,
y: openOptions.y,
positionTo: openOptions.positionTo
}, this._trigger("beforeposition", undefined, openOptions), this._ui.container.offset(this._placementCoords(this._desiredCoords(openOptions)));
},
reposition: function(openOptions) {
this._isOpen && this._reposition(openOptions);
},
_openPrerequisitesComplete: function() {
var id = this.element.attr("id");
this._ui.container.addClass("ui-popup-active"), this._isOpen = !0, this._resizeScreen(), this._ui.container.attr("tabindex", "0").focus(), this._ignoreResizeEvents(), id && this.document.find("[aria-haspopup='true'][aria-owns='" + id + "']").attr("aria-expanded", !0), this._trigger("afteropen");
},
_open: function(options) {
var ua, // Rendering engine is Webkit, and capture major version
wkmatch, wkversion, androidmatch, andversion, chromematch, openOptions = $.extend({}, this.options, options), // TODO move blacklist to private method
androidBlacklist = (wkversion = !!(wkmatch = (ua = navigator.userAgent).match(/AppleWebKit\/([0-9\.]+)/)) && wkmatch[1], andversion = !!(androidmatch = ua.match(/Android (\d+(?:\.\d+))/)) && androidmatch[1], chromematch = ua.indexOf("Chrome") > -1, null !== androidmatch && "4.0" === andversion && !!wkversion && !!(wkversion > 534.13) && !chromematch);
// Count down to triggering "popupafteropen" - we have two prerequisites:
// 1. The popup window animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites($.noop, $.noop, $.proxy(this, "_openPrerequisitesComplete")), this._currentTransition = openOptions.transition, this._applyTransition(openOptions.transition), this._ui.screen.removeClass("ui-screen-hidden"), this._ui.container.removeClass("ui-popup-truncate"), // Give applications a chance to modify the contents of the container before it appears
this._reposition(openOptions), this._ui.container.removeClass("ui-popup-hidden"), this.options.overlayTheme && androidBlacklist && /* TODO: The native browser on Android 4.0.X ("Ice Cream Sandwich") suffers from an issue where the popup overlay appears to be z-indexed above the popup itself when certain other styles exist on the same page -- namely, any element set to `position: fixed` and certain types of input. These issues are reminiscent of previously uncovered bugs in older versions of Android's native browser: https://github.com/scottjehl/Device-Bugs/issues/3
This fix closes the following bugs ( I use "closes" with reluctance, and stress that this issue should be revisited as soon as possible ):
https://github.com/jquery/jquery-mobile/issues/4816
https://github.com/jquery/jquery-mobile/issues/4844
https://github.com/jquery/jquery-mobile/issues/4874
*/ // TODO sort out why this._page isn't working
this.element.closest(".ui-page").addClass("ui-popup-open"), this._animate({
additionalCondition: !0,
transition: openOptions.transition,
classToRemove: "",
screenClassToAdd: "in",
containerClassToAdd: "in",
applyTransition: !1,
prerequisites: this._prerequisites
});
},
_closePrerequisiteScreen: function() {
this._ui.screen.removeClass("out").addClass("ui-screen-hidden");
},
_closePrerequisiteContainer: function() {
this._ui.container.removeClass("reverse out").addClass("ui-popup-hidden ui-popup-truncate").removeAttr("style");
},
_closePrerequisitesDone: function() {
var container = this._ui.container, id = this.element.attr("id");
container.removeAttr("tabindex"), // remove the global mutex for popups
$.mobile.popup.active = undefined, // Blur elements inside the container, including the container
$(":focus", container[0]).add(container[0]).blur(), id && this.document.find("[aria-haspopup='true'][aria-owns='" + id + "']").attr("aria-expanded", !1), // alert users that the popup is closed
this._trigger("afterclose");
},
_close: function(immediate) {
this._ui.container.removeClass("ui-popup-active"), this._page.removeClass("ui-popup-open"), this._isOpen = !1, // Count down to triggering "popupafterclose" - we have two prerequisites:
// 1. The popup window reverse animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites($.proxy(this, "_closePrerequisiteScreen"), $.proxy(this, "_closePrerequisiteContainer"), $.proxy(this, "_closePrerequisitesDone")), this._animate({
additionalCondition: this._ui.screen.hasClass("in"),
transition: immediate ? "none" : this._currentTransition,
classToRemove: "in",
screenClassToAdd: "out",
containerClassToAdd: "reverse out",
applyTransition: !0,
prerequisites: this._prerequisites
});
},
_unenhance: function() {
!this.options.enhanced && (// Put the element back to where the placeholder was and remove the "ui-popup" class
this._setOptions({
theme: $.mobile.popup.prototype.options.theme
}), this.element// Cannot directly insertAfter() - we need to detach() first, because
// insertAfter() will do nothing if the payload div was not attached
// to the DOM at the time the widget was created, and so the payload
// will remain inside the container even after we call insertAfter().
// If that happens and we remove the container a few lines below, we
// will cause an infinite recursion - #5244
.detach().insertAfter(this._ui.placeholder).removeClass("ui-popup ui-overlay-shadow ui-corner-all ui-body-inherit"), this._ui.screen.remove(), this._ui.container.remove(), this._ui.placeholder.remove());
},
_destroy: function() {
return $.mobile.popup.active === this ? (this.element.one("popupafterclose", $.proxy(this, "_unenhance")), this.close()) : this._unenhance(), this;
},
_closePopup: function(theEvent, data) {
var parsedDst, toUrl, currentOptions = this.options, immediate = !1;
!(theEvent && theEvent.isDefaultPrevented()) && $.mobile.popup.active === this && (// restore location on screen
window.scrollTo(0, this._scrollTop), theEvent && "pagebeforechange" === theEvent.type && data && (parsedDst = "string" == typeof data.toPage ? data.toPage : data.toPage.jqmData("url"), toUrl = (parsedDst = $.mobile.path.parseUrl(parsedDst)).pathname + parsedDst.search + parsedDst.hash, this._myUrl !== $.mobile.path.makeUrlAbsolute(toUrl) ? // Going to a different page - close immediately
immediate = !0 : theEvent.preventDefault()), // remove nav bindings
this.window.off(currentOptions.closeEvents), // unbind click handlers added when history is disabled
this.element.undelegate(currentOptions.closeLinkSelector, currentOptions.closeLinkEvents), this._close(immediate));
},
// any navigation event after a popup is opened should close the popup
// NOTE the pagebeforechange is bound to catch navigation events that don't
// alter the url (eg, dialogs from popups)
_bindContainerClose: function() {
this.window.on(this.options.closeEvents, $.proxy(this, "_closePopup"));
},
widget: function() {
return this._ui.container;
},
// TODO no clear deliniation of what should be here and
// what should be in _open. Seems to be "visual" vs "history" for now
open: function(options) {
var url, hashkey, activePage, currentIsDialog, urlHistory, self = this, currentOptions = this.options;
return $.mobile.popup.active || currentOptions.disabled || ((// set the global popup mutex
$.mobile.popup.active = this, this._scrollTop = this.window.scrollTop(), currentOptions.history) ? (// cache some values for min/readability
urlHistory = $.mobile.navigate.history, hashkey = $.mobile.dialogHashKey, currentIsDialog = !!(activePage = $.mobile.activePage) && activePage.hasClass("ui-dialog"), this._myUrl = url = urlHistory.getActive().url, url.indexOf(hashkey) > -1 && !currentIsDialog && urlHistory.activeIndex > 0) ? (self._open(options), self._bindContainerClose()) : (-1 !== url.indexOf(hashkey) || currentIsDialog ? url = $.mobile.path.parseLocation().hash + hashkey : url += url.indexOf("#") > -1 ? hashkey : "#" + hashkey, 0 === urlHistory.activeIndex && url === urlHistory.initialDst && (url += hashkey), // swallow the the initial navigation event, and bind for the next
this.window.one("beforenavigate", function(theEvent) {
theEvent.preventDefault(), self._open(options), self._bindContainerClose();
}), this.urlAltered = !0, $.mobile.navigate(url, {
role: "dialog"
})) : (self._open(options), self._bindContainerClose(), // When histoy is disabled we have to grab the data-rel
// back link clicks so we can close the popup instead of
// relying on history to do it for us
self.element.delegate(currentOptions.closeLinkSelector, currentOptions.closeLinkEvents, function(theEvent) {
self.close(), theEvent.preventDefault();
}))), this;
},
close: function() {
return $.mobile.popup.active !== this || (this._scrollTop = this.window.scrollTop(), this.options.history && this.urlAltered ? ($.mobile.back(), this.urlAltered = !1) : // simulate the nav bindings having fired
this._closePopup()), this;
}
}), // TODO this can be moved inside the widget
$.mobile.popup.handleLink = function($link) {
var offset, path = $.mobile.path, // NOTE make sure to get only the hash from the href because ie7 (wp7)
// returns the absolute href in this case ruining the element selection
popup = $(path.hashToSelector(path.parseUrl($link.attr("href")).hash)).first();
popup.length > 0 && popup.data("mobile-popup") && (offset = $link.offset(), popup.popup("open", {
x: offset.left + $link.outerWidth() / 2,
y: offset.top + $link.outerHeight() / 2,
transition: $link.jqmData("transition"),
positionTo: $link.jqmData("position-to")
})), //remove after delay
setTimeout(function() {
$link.removeClass($.mobile.activeBtnClass);
}, 300);
}, // TODO move inside _create
$.mobile.document.on("pagebeforechange", function(theEvent, data) {
"popup" === data.options.role && ($.mobile.popup.handleLink(data.options.link), theEvent.preventDefault());
});
}(jQuery), /*
* custom "selectmenu" plugin
*/ function($, undefined) {
var unfocusableItemSelector = ".ui-disabled,.ui-state-disabled,.ui-li-divider,.ui-screen-hidden,:jqmData(role='placeholder')", goToAdjacentItem = function(item, target, direction) {
var adjacent = item[direction + "All"]().not(unfocusableItemSelector).first();
// if there's a previous option, focus it
adjacent.length && (target.blur().attr("tabindex", "-1"), adjacent.find("a").first().focus());
};
$.widget("mobile.selectmenu", $.mobile.selectmenu, {
_create: function() {
var o = this.options;
return(// Custom selects cannot exist inside popups, so revert the "nativeMenu"
// option to true if a parent is a popup
o.nativeMenu = o.nativeMenu || this.element.parents(":jqmData(role='popup'),:mobile-popup").length > 0, this._super());
},
_handleSelectFocus: function() {
this.element.blur(), this.button.focus();
},
_handleKeydown: function(event1) {
this._super(event1), this._handleButtonVclickKeydown(event1);
},
_handleButtonVclickKeydown: function(event1) {
!this.options.disabled && !this.isOpen && ("vclick" === event1.type || event1.keyCode && (event1.keyCode === $.mobile.keyCode.ENTER || event1.keyCode === $.mobile.keyCode.SPACE)) && (this._decideFormat(), "overlay" === this.menuType ? this.button.attr("href", "#" + this.popupId).attr("data-" + ($.mobile.ns || "") + "rel", "popup") : this.button.attr("href", "#" + this.dialogId).attr("data-" + ($.mobile.ns || "") + "rel", "dialog"), this.isOpen = !0);
},
_handleListFocus: function(e) {
var params = "focusin" === e.type ? {
tabindex: "0",
event: "vmouseover"
} : {
tabindex: "-1",
event: "vmouseout"
};
$(e.target).attr("tabindex", params.tabindex).trigger(params.event);
},
_handleListKeydown: function(event1) {
var target = $(event1.target), li = target.closest("li");
// switch logic based on which key was pressed
switch(event1.keyCode){
// up or left arrow keys
case 38:
return goToAdjacentItem(li, target, "prev"), !1;
// down or right arrow keys
case 40:
return goToAdjacentItem(li, target, "next"), !1;
// If enter or space is pressed, trigger click
case 13:
case 32:
return target.trigger("click"), !1;
}
},
_handleMenuPageHide: function() {
// TODO centralize page removal binding / handling in the page plugin.
// Suggestion from @jblas to do refcounting
//
// TODO extremely confusing dependency on the open method where the pagehide.remove
// bindings are stripped to prevent the parent page from disappearing. The way
// we're keeping pages in the DOM right now sucks
//
// rebind the page remove that was unbound in the open function
// to allow for the parent page removal from actions other than the use
// of a dialog sized custom select
//
// doing this here provides for the back button on the custom select dialog
this.thisPage.page("bindRemove");
},
_handleHeaderCloseClick: function() {
if ("overlay" === this.menuType) return this.close(), !1;
},
build: function() {
var selectId, popupId, dialogId, label, thisPage, isMultiple, menuId, themeAttr, overlayTheme, overlayThemeAttr, dividerThemeAttr, menuPage, listbox, list, header, headerTitle, menuPageContent, menuPageClose, headerClose, self, o = this.options;
return o.nativeMenu ? this._super() : (self = this, popupId = (selectId = this.selectId) + "-listbox", dialogId = selectId + "-dialog", label = this.label, thisPage = this.element.closest(".ui-page"), isMultiple = this.element[0].multiple, menuId = selectId + "-menu", themeAttr = o.theme ? " data-" + $.mobile.ns + "theme='" + o.theme + "'" : "", overlayThemeAttr = (overlayTheme = o.overlayTheme || o.theme || null) ? " data-" + $.mobile.ns + "overlay-theme='" + overlayTheme + "'" : "", dividerThemeAttr = o.dividerTheme && isMultiple ? " data-" + $.mobile.ns + "divider-theme='" + o.dividerTheme + "'" : "", menuPage = $("<div data-" + $.mobile.ns + "role='dialog' class='ui-selectmenu' id='" + dialogId + "'" + themeAttr + overlayThemeAttr + "><div data-" + $.mobile.ns + "role='header'><div class='ui-title'>" + label.getEncodedText() + "</div></div><div data-" + $.mobile.ns + "role='content'></div></div>"), listbox = $("<div id='" + popupId + "' class='ui-selectmenu'></div>").insertAfter(this.select).popup({
theme: o.overlayTheme
}), list = $("<ul class='ui-selectmenu-list' id='" + menuId + "' role='listbox' aria-labelledby='" + this.buttonId + "'" + themeAttr + dividerThemeAttr + "></ul>").appendTo(listbox), header = $("<div class='ui-header ui-bar-" + (o.theme ? o.theme : "inherit") + "'></div>").prependTo(listbox), headerTitle = $("<h1 class='ui-title'></h1>").appendTo(header), this.isMultiple && (headerClose = $("<a>", {
role: "button",
text: o.closeText,
href: "#",
class: "ui-btn ui-corner-all ui-btn-left ui-btn-icon-notext ui-icon-delete"
}).appendTo(header)), $.extend(this, {
selectId: selectId,
menuId: menuId,
popupId: popupId,
dialogId: dialogId,
thisPage: thisPage,
menuPage: menuPage,
label: label,
isMultiple: isMultiple,
theme: o.theme,
listbox: listbox,
list: list,
header: header,
headerTitle: headerTitle,
headerClose: headerClose,
menuPageContent: menuPageContent,
menuPageClose: menuPageClose,
placeholder: ""
}), // Create list from select, update state
this.refresh(), void 0 === this._origTabIndex && // Map undefined to false, because this._origTabIndex === undefined
// indicates that we have not yet checked whether the select has
// originally had a tabindex attribute, whereas false indicates that
// we have checked the select for such an attribute, and have found
// none present.
(this._origTabIndex = null !== this.select[0].getAttribute("tabindex") && this.select.attr("tabindex")), this.select.attr("tabindex", "-1"), this._on(this.select, {
focus: "_handleSelectFocus"
}), // Button events
this._on(this.button, {
vclick: "_handleButtonVclickKeydown"
}), // Events for list items
this.list.attr("role", "listbox"), this._on(this.list, {
focusin: "_handleListFocus",
focusout: "_handleListFocus",
keydown: "_handleListKeydown"
}), this.list.delegate("li:not(.ui-disabled,.ui-state-disabled,.ui-li-divider)", "click", function(event1) {
// index of option tag to be selected
var oldIndex = self.select[0].selectedIndex, newIndex = $.mobile.getAttribute(this, "option-index"), option = self._selectOptions().eq(newIndex)[0];
// toggle selected status on the tag for multi selects
option.selected = !self.isMultiple || !option.selected, self.isMultiple && $(this).find("a").toggleClass("ui-checkbox-on", option.selected).toggleClass("ui-checkbox-off", !option.selected), (self.isMultiple || oldIndex !== newIndex) && self.select.trigger("change"), self.isMultiple ? self.list.find("li:not(.ui-li-divider)").eq(newIndex).find("a").first().focus() : self.close(), event1.preventDefault();
}), // button refocus ensures proper height calculation
// by removing the inline style and ensuring page inclusion
this._on(this.menuPage, {
pagehide: "_handleMenuPageHide"
}), // Events on the popup
this._on(this.listbox, {
popupafterclose: "close"
}), this.isMultiple && this._on(this.headerClose, {
click: "_handleHeaderCloseClick"
}), this);
},
_isRebuildRequired: function() {
var list = this.list.find("li");
// TODO exceedingly naive method to determine difference
// ignores value changes etc in favor of a forcedRebuild
// from the user in the refresh method
return this._selectOptions().not(".ui-screen-hidden").text() !== list.text();
},
selected: function() {
return this._selectOptions().filter(":selected:not( :jqmData(placeholder='true') )");
},
refresh: function(force) {
var self, indices;
if (this.options.nativeMenu) return this._super(force);
self = this, (force || this._isRebuildRequired()) && self._buildList(), indices = this.selectedIndices(), self.setButtonText(), self.setButtonCount(), self.list.find("li:not(.ui-li-divider)").find("a").removeClass($.mobile.activeBtnClass).end().attr("aria-selected", !1).each(function(i) {
if ($.inArray(i, indices) > -1) {
var item = $(this);
// Aria selected attr
item.attr("aria-selected", !0), self.isMultiple ? item.find("a").removeClass("ui-checkbox-off").addClass("ui-checkbox-on") : item.hasClass("ui-screen-hidden") ? item.next().find("a").addClass($.mobile.activeBtnClass) : item.find("a").addClass($.mobile.activeBtnClass);
}
});
},
close: function() {
!this.options.disabled && this.isOpen && ("page" === this.menuType ? (this.menuPage.dialog("close"), this.list.appendTo(this.listbox)) : this.listbox.popup("close"), this._focusButton(), // allow the dialog to be closed again
this.isOpen = !1);
},
open: function() {
this.button.click();
},
_focusMenuItem: function() {
var selector = this.list.find("a." + $.mobile.activeBtnClass);
0 === selector.length && (selector = this.list.find("li:not(" + unfocusableItemSelector + ") a.ui-btn")), selector.first().focus();
},
_decideFormat: function() {
var $window = this.window, menuHeight = this.list.parent().outerHeight(), scrollTop = $window.scrollTop(), btnOffset = this.button.offset().top, screenHeight = $window.height();
menuHeight > screenHeight - 80 || !$.support.scrollTop ? (this.menuPage.appendTo($.mobile.pageContainer).page(), this.menuPageContent = this.menuPage.find(".ui-content"), this.menuPageClose = this.menuPage.find(".ui-header a"), // prevent the parent page from being removed from the DOM,
// otherwise the results of selecting a list item in the dialog
// fall into a black hole
this.thisPage.unbind("pagehide.remove"), 0 === scrollTop && btnOffset > screenHeight && this.thisPage.one("pagehide", function() {
$(this).jqmData("lastScroll", btnOffset);
}), this.menuPage.one({
pageshow: $.proxy(this, "_focusMenuItem"),
pagehide: $.proxy(this, "close")
}), this.menuType = "page", this.menuPageContent.append(this.list), this.menuPage.find("div .ui-title").text(this.label.text())) : (this.menuType = "overlay", this.listbox.one({
popupafteropen: $.proxy(this, "_focusMenuItem")
}));
},
_buildList: function() {
var $options, numOptions, select, optGroup, i, option, $option, parent, text, anchor, classes, optLabel, divider, item, o = this.options, placeholder = this.placeholder, needPlaceholder = !0, dataPrefix = "data-" + $.mobile.ns, dataIndexAttr = dataPrefix + "option-index", dataIconAttr = dataPrefix + "icon", dataRoleAttr = dataPrefix + "role", dataPlaceholderAttr = dataPrefix + "placeholder", fragment = document1.createDocumentFragment(), isPlaceholderItem = !1;
for(this.list.empty().filter(".ui-listview").listview("destroy"), numOptions = ($options = this._selectOptions()).length, select = this.select[0], i = 0; i < numOptions; i++, isPlaceholderItem = !1)// Do not create options based on ui-screen-hidden select options
!($option = $(option = $options[i])).hasClass("ui-screen-hidden") && (parent = option.parentNode, text = $option.text(), anchor = document1.createElement("a"), classes = [], anchor.setAttribute("href", "#"), anchor.appendChild(document1.createTextNode(text)), parent !== select && "optgroup" === parent.nodeName.toLowerCase() && (optLabel = parent.getAttribute("label")) !== optGroup && ((divider = document1.createElement("li")).setAttribute(dataRoleAttr, "list-divider"), divider.setAttribute("role", "option"), divider.setAttribute("tabindex", "-1"), divider.appendChild(document1.createTextNode(optLabel)), fragment.appendChild(divider), optGroup = optLabel), needPlaceholder && (!option.getAttribute("value") || 0 === text.length || $option.jqmData("placeholder")) && (needPlaceholder = !1, isPlaceholderItem = !0, null === option.getAttribute(dataPlaceholderAttr) && (this._removePlaceholderAttr = !0), option.setAttribute(dataPlaceholderAttr, !0), o.hidePlaceholderMenuItems && classes.push("ui-screen-hidden"), placeholder !== text && (placeholder = this.placeholder = text)), item = document1.createElement("li"), option.disabled && (classes.push("ui-state-disabled"), item.setAttribute("aria-disabled", !0)), item.setAttribute(dataIndexAttr, i), item.setAttribute(dataIconAttr, "false"), isPlaceholderItem && item.setAttribute(dataPlaceholderAttr, !0), item.className = classes.join(" "), item.setAttribute("role", "option"), anchor.setAttribute("tabindex", "-1"), this.isMultiple && $(anchor).addClass("ui-btn ui-checkbox-off ui-btn-icon-right"), item.appendChild(anchor), fragment.appendChild(item));
this.list[0].appendChild(fragment), this.isMultiple || placeholder.length ? this.headerTitle.text(this.placeholder) : this.header.addClass("ui-screen-hidden"), // Now populated, create listview
this.list.listview();
},
_button: function() {
return this.options.nativeMenu ? this._super() : $("<a>", {
href: "#",
role: "button",
// TODO value is undefined at creation
id: this.buttonId,
"aria-haspopup": "true",
// TODO value is undefined at creation
"aria-owns": this.menuId
});
},
_destroy: function() {
this.options.nativeMenu || (this.close(), void 0 !== this._origTabIndex && (!1 !== this._origTabIndex ? this.select.attr("tabindex", this._origTabIndex) : this.select.removeAttr("tabindex")), this._removePlaceholderAttr && this._selectOptions().removeAttr("data-" + $.mobile.ns + "placeholder"), // Remove the popup
this.listbox.remove(), // Remove the dialog
this.menuPage.remove()), // Chain up
this._super();
}
});
}(jQuery), // buttonMarkup is deprecated as of 1.4.0 and will be removed in 1.5.0.
function($, undefined) {
// General policy: Do not access data-* attributes except during enhancement.
// In all other cases we determine the state of the button exclusively from its
// className. That's why optionsToClasses expects a full complement of options,
// and the jQuery plugin completes the set of options from the default values.
// Map classes to buttonMarkup boolean options - used in classNameToOptions()
var reverseBoolOptionMap = {
"ui-shadow": "shadow",
"ui-corner-all": "corners",
"ui-btn-inline": "inline",
"ui-shadow-icon": "iconshadow" /* TODO: Remove in 1.5 */ ,
"ui-mini": "mini"
}, getAttrFixed = function() {
var ret = $.mobile.getAttribute.apply(this, arguments);
return null == ret ? undefined : ret;
}, capitalLettersRE = /[A-Z]/g;
function camelCase2Hyphenated(c) {
return "-" + c.toLowerCase();
}
// $.fn.buttonMarkup:
// DOM: gets/sets .className
//
// @options: options to apply to the elements in the jQuery object
// @overwriteClasses: boolean indicating whether to honour existing classes
//
// Calculates the classes to apply to the elements in the jQuery object based on
// the options passed in. If @overwriteClasses is true, it sets the className
// property of each element in the jQuery object to the buttonMarkup classes
// it calculates based on the options passed in.
//
// If you wish to preserve any classes that are already present on the elements
// inside the jQuery object, including buttonMarkup-related classes that were
// added by a previous call to $.fn.buttonMarkup() or during page enhancement
// then you should omit @overwriteClasses or set it to false.
$.fn.buttonMarkup = function(options, overwriteClasses) {
var idx, data, el, retrievedOptions, optionKey, defaults = $.fn.buttonMarkup.defaults;
for(idx = 0; idx < this.length; idx++){
// If this is the first call on this element, retrieve remaining options
// from the data-attributes
if (el = this[idx], data = overwriteClasses ? {
alreadyEnhanced: !1,
unknownClasses: []
} : // classes
// classNameToOptions:
// @classes: A string containing a .className-style space-separated class list
//
// Loops over @classes and calculates an options object based on the
// buttonMarkup-related classes it finds. It records unrecognized classes in an
// array.
//
// Returns: An object containing the following items:
//
// "options": buttonMarkup options found to be present because of the
// presence/absence of corresponding classes
//
// "unknownClasses": a string containing all the non-buttonMarkup-related
// classes found in @classes
//
// "alreadyEnhanced": A boolean indicating whether the ui-btn class was among
// those found to be present
function(classes) {
var idx, map, unknownClass, alreadyEnhanced = !1, noIcon = !0, o = {
icon: "",
inline: !1,
shadow: !1,
corners: !1,
iconshadow: !1,
mini: !1
}, unknownClasses = [];
// Loop over the classes
for(idx = 0, classes = classes.split(" "); idx < classes.length; idx++)// Assume it's an unrecognized class
unknownClass = !0, undefined !== // Recognize boolean options from the presence of classes
(map = reverseBoolOptionMap[classes[idx]]) ? (unknownClass = !1, o[map] = !0) : 0 === classes[idx].indexOf("ui-btn-icon-") ? (unknownClass = !1, noIcon = !1, o.iconpos = classes[idx].substring(12)) : 0 === classes[idx].indexOf("ui-icon-") ? (unknownClass = !1, o.icon = classes[idx].substring(8)) : 0 === classes[idx].indexOf("ui-btn-") && 8 === classes[idx].length ? (unknownClass = !1, o.theme = classes[idx].substring(7)) : "ui-btn" === classes[idx] && (unknownClass = !1, alreadyEnhanced = !0), unknownClass && unknownClasses.push(classes[idx]);
return noIcon && (o.icon = ""), {
options: o,
unknownClasses: unknownClasses,
alreadyEnhanced: alreadyEnhanced
};
}(el.className), retrievedOptions = $.extend({}, // If the element already has the class ui-btn, then we assume that
// it has passed through buttonMarkup before - otherwise, the options
// returned by classNameToOptions do not correctly reflect the state of
// the element
data.alreadyEnhanced ? data.options : {}, // Finally, apply the options passed in
options), !data.alreadyEnhanced) for(optionKey in defaults)retrievedOptions[optionKey] === undefined && (retrievedOptions[optionKey] = getAttrFixed(el, optionKey.replace(capitalLettersRE, camelCase2Hyphenated)));
el.className = // optionsToClasses:
// @options: A complete set of options to convert to class names.
// @existingClasses: extra classes to add to the result
//
// Converts @options to buttonMarkup classes and returns the result as an array
// that can be converted to an element's className with .join( " " ). All
// possible options must be set inside @options. Use $.fn.buttonMarkup.defaults
// to get a complete set and use $.extend to override your choice of options
// from that set.
(function(options, existingClasses) {
var classes = existingClasses || [];
// Create a string from the array and return it
return(// Add classes to the array - first ui-btn
classes.push("ui-btn"), options.theme && classes.push("ui-btn-" + options.theme), options.icon && (classes = classes.concat([
"ui-icon-" + options.icon,
"ui-btn-icon-" + options.iconpos
]), options.iconshadow && classes.push("ui-shadow-icon")), options.inline && classes.push("ui-btn-inline"), options.shadow && classes.push("ui-shadow"), options.corners && classes.push("ui-corner-all"), options.mini && classes.push("ui-mini"), classes);
})(// Merge all the options and apply them as classes
$.extend({}, // The defaults form the basis
defaults, // Add the computed options
retrievedOptions), // ... and re-apply any unrecognized classes that were found
data.unknownClasses).join(" "), "button" !== el.tagName.toLowerCase() && el.setAttribute("role", "button");
}
return this;
}, // buttonMarkup defaults. This must be a complete set, i.e., a value must be
// given here for all recognized options
$.fn.buttonMarkup.defaults = {
icon: "",
iconpos: "left",
theme: null,
inline: !1,
shadow: !0,
corners: !0,
iconshadow: !1,
mini: !1
}, $.extend($.fn.buttonMarkup, {
initSelector: "a:jqmData(role='button'), .ui-bar > a, .ui-bar > :jqmData(role='controlgroup') > a, button"
});
}(jQuery), function($, undefined) {
$.widget("mobile.controlgroup", $.extend({
options: {
enhanced: !1,
theme: null,
shadow: !1,
corners: !0,
excludeInvisible: !0,
type: "vertical",
mini: !1
},
_create: function() {
var elem = this.element, opts = this.options;
$.fn.buttonMarkup && this.element.find($.fn.buttonMarkup.initSelector).buttonMarkup(), // Enhance child widgets
$.each(this._childWidgets, $.proxy(function(number, widgetName) {
$.mobile[widgetName] && this.element.find($.mobile[widgetName].initSelector).not($.mobile.page.prototype.keepNativeSelector())[widgetName]();
}, this)), $.extend(this, {
_ui: null,
_initialRefresh: !0
}), opts.enhanced ? this._ui = {
groupLegend: elem.children(".ui-controlgroup-label").children(),
childWrapper: elem.children(".ui-controlgroup-controls")
} : this._ui = this._enhance();
},
_childWidgets: [
"checkboxradio",
"selectmenu",
"button"
],
_themeClassFromOption: function(value) {
return value ? "none" === value ? "" : "ui-group-theme-" + value : "";
},
_enhance: function() {
var elem = this.element, opts = this.options, ui = {
groupLegend: elem.children("legend"),
childWrapper: elem.addClass("ui-controlgroup ui-controlgroup-" + ("horizontal" === opts.type ? "horizontal" : "vertical") + " " + this._themeClassFromOption(opts.theme) + " " + (opts.corners ? "ui-corner-all " : "") + (opts.mini ? "ui-mini " : "")).wrapInner("<div class='ui-controlgroup-controls " + (!0 === opts.shadow ? "ui-shadow" : "") + "'></div>").children()
};
return ui.groupLegend.length > 0 && $("<div role='heading' class='ui-controlgroup-label'></div>").append(ui.groupLegend).prependTo(elem), ui;
},
_init: function() {
this.refresh();
},
_setOptions: function(options) {
var callRefresh, returnValue, elem = this.element;
return void 0 !== options.type && (elem.removeClass("ui-controlgroup-horizontal ui-controlgroup-vertical").addClass("ui-controlgroup-" + ("horizontal" === options.type ? "horizontal" : "vertical")), callRefresh = !0), void 0 !== options.theme && elem.removeClass(this._themeClassFromOption(this.options.theme)).addClass(this._themeClassFromOption(options.theme)), options.corners !== undefined && elem.toggleClass("ui-corner-all", options.corners), options.mini !== undefined && elem.toggleClass("ui-mini", options.mini), options.shadow !== undefined && this._ui.childWrapper.toggleClass("ui-shadow", options.shadow), options.excludeInvisible !== undefined && (this.options.excludeInvisible = options.excludeInvisible, callRefresh = !0), returnValue = this._super(options), callRefresh && this.refresh(), returnValue;
},
container: function() {
return this._ui.childWrapper;
},
refresh: function() {
var $el = this.container(), els = $el.find(".ui-btn").not(".ui-slider-handle"), create = this._initialRefresh;
$.mobile.checkboxradio && $el.find(":mobile-checkboxradio").checkboxradio("refresh"), this._addFirstLastClasses(els, this.options.excludeInvisible ? this._getVisibles(els, create) : els, create), this._initialRefresh = !1;
},
// Caveat: If the legend is not the first child of the controlgroup at enhance
// time, it will be after _destroy().
_destroy: function() {
var ui, buttons, opts = this.options;
if (opts.enhanced) return this;
ui = this._ui, buttons = this.element.removeClass("ui-controlgroup ui-controlgroup-horizontal ui-controlgroup-vertical ui-corner-all ui-mini " + this._themeClassFromOption(opts.theme)).find(".ui-btn").not(".ui-slider-handle"), this._removeFirstLastClasses(buttons), ui.groupLegend.unwrap(), ui.childWrapper.children().unwrap();
}
}, $.mobile.behaviors.addFirstLastClasses));
}(jQuery), function($, undefined) {
$.widget("mobile.toolbar", {
initSelector: ":jqmData(role='footer'), :jqmData(role='header')",
options: {
theme: null,
addBackBtn: !1,
backBtnTheme: null,
backBtnText: "Back"
},
_create: function() {
var leftbtn, rightbtn, role = this.element.is(":jqmData(role='header')") ? "header" : "footer", page = this.element.closest(".ui-page");
0 === page.length && (page = !1, this._on(this.document, {
pageshow: "refresh"
})), $.extend(this, {
role: role,
page: page,
leftbtn: leftbtn,
rightbtn: rightbtn
}), this.element.attr("role", "header" === role ? "banner" : "contentinfo").addClass("ui-" + role), this.refresh(), this._setOptions(this.options);
},
_setOptions: function(o) {
if (void 0 !== o.addBackBtn && (this.options.addBackBtn && "header" === this.role && $(".ui-page").length > 1 && this.page[0].getAttribute("data-" + $.mobile.ns + "url") !== $.mobile.path.stripHash(location.hash) && !this.leftbtn ? this._addBackButton() : this.element.find(".ui-toolbar-back-btn").remove()), null != o.backBtnTheme && this.element.find(".ui-toolbar-back-btn").addClass("ui-btn ui-btn-" + o.backBtnTheme), void 0 !== o.backBtnText && this.element.find(".ui-toolbar-back-btn .ui-btn-text").text(o.backBtnText), o.theme !== undefined) {
var currentTheme = this.options.theme ? this.options.theme : "inherit", newTheme = o.theme ? o.theme : "inherit";
this.element.removeClass("ui-bar-" + currentTheme).addClass("ui-bar-" + newTheme);
}
this._super(o);
},
refresh: function() {
"header" === this.role && this._addHeaderButtonClasses(), this.page || (this._setRelative(), "footer" === this.role && this.element.appendTo("body")), this._addHeadingClasses(), this._btnMarkup();
},
//we only want this to run on non fixed toolbars so make it easy to override
_setRelative: function() {
$("[data-" + $.mobile.ns + "role='page']").css({
position: "relative"
});
},
// Deprecated in 1.4. As from 1.5 button classes have to be present in the markup.
_btnMarkup: function() {
this.element.children("a").filter(":not([data-" + $.mobile.ns + "role='none'])").attr("data-" + $.mobile.ns + "role", "button"), this.element.trigger("create");
},
// Deprecated in 1.4. As from 1.5 ui-btn-left/right classes have to be present in the markup.
_addHeaderButtonClasses: function() {
var $headeranchors = this.element.children("a, button");
this.leftbtn = $headeranchors.hasClass("ui-btn-left"), this.rightbtn = $headeranchors.hasClass("ui-btn-right"), this.leftbtn = this.leftbtn || $headeranchors.eq(0).not(".ui-btn-right").addClass("ui-btn-left").length, this.rightbtn = this.rightbtn || $headeranchors.eq(1).addClass("ui-btn-right").length;
},
_addBackButton: function() {
var options = this.options, theme = options.backBtnTheme || options.theme;
$("<a role='button' href='javascript:void(0);' class='ui-btn ui-corner-all ui-shadow ui-btn-left " + (theme ? "ui-btn-" + theme + " " : "") + "ui-toolbar-back-btn ui-icon-carat-l ui-btn-icon-left' data-" + $.mobile.ns + "rel='back'>" + options.backBtnText + "</a>").prependTo(this.element);
},
_addHeadingClasses: function() {
this.element.children("h1, h2, h3, h4, h5, h6").addClass("ui-title")// Regardless of h element number in src, it becomes h1 for the enhanced page
.attr({
role: "heading",
"aria-level": "1"
});
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.toolbar", $.mobile.toolbar, {
options: {
position: null,
visibleOnPageShow: !0,
disablePageZoom: !0,
transition: "slide",
fullscreen: !1,
tapToggle: !0,
tapToggleBlacklist: "a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed, .ui-flipswitch, .ui-popup, .ui-panel, .ui-panel-dismiss-open",
hideDuringFocus: "input, textarea, select",
updatePagePadding: !0,
trackPersistentToolbars: !0,
// Browser detection! Weeee, here we go...
// Unfortunately, position:fixed is costly, not to mention probably impossible, to feature-detect accurately.
// Some tests exist, but they currently return false results in critical devices and browsers, which could lead to a broken experience.
// Testing fixed positioning is also pretty obtrusive to page load, requiring injected elements and scrolling the window
// The following function serves to rule out some popular browsers with known fixed-positioning issues
// This is a plugin option like any other, so feel free to improve or overwrite it
supportBlacklist: function() {
return !$.support.fixedPosition;
}
},
_create: function() {
this._super(), "fixed" !== this.options.position || this.options.supportBlacklist() || this._makeFixed();
},
_makeFixed: function() {
this.element.addClass("ui-" + this.role + "-fixed"), this.updatePagePadding(), this._addTransitionClass(), this._bindPageEvents(), this._bindToggleHandlers();
},
_setOptions: function(o) {
if ("fixed" === o.position && "fixed" !== this.options.position && this._makeFixed(), "fixed" === this.options.position && !this.options.supportBlacklist()) {
var $page = this.page ? this.page : $(".ui-page-active").length > 0 ? $(".ui-page-active") : $(".ui-page").eq(0);
void 0 !== o.fullscreen && (o.fullscreen ? (this.element.addClass("ui-" + this.role + "-fullscreen"), $page.addClass("ui-page-" + this.role + "-fullscreen")) : (this.element.removeClass("ui-" + this.role + "-fullscreen"), $page.removeClass("ui-page-" + this.role + "-fullscreen").addClass("ui-page-" + this.role + "-fixed")));
}
this._super(o);
},
_addTransitionClass: function() {
var tclass = this.options.transition;
tclass && "none" !== tclass && ("slide" === tclass && (tclass = this.element.hasClass("ui-header") ? "slidedown" : "slideup"), this.element.addClass(tclass));
},
_bindPageEvents: function() {
var page = this.page ? this.element.closest(".ui-page") : this.document;
//page event bindings
// Fixed toolbars require page zoom to be disabled, otherwise usability issues crop up
// This method is meant to disable zoom while a fixed-positioned toolbar page is visible
this._on(page, {
pagebeforeshow: "_handlePageBeforeShow",
webkitAnimationStart: "_handleAnimationStart",
animationstart: "_handleAnimationStart",
updatelayout: "_handleAnimationStart",
pageshow: "_handlePageShow",
pagebeforehide: "_handlePageBeforeHide"
});
},
_handlePageBeforeShow: function() {
var o = this.options;
o.disablePageZoom && $.mobile.zoom.disable(!0), o.visibleOnPageShow || this.hide(!0);
},
_handleAnimationStart: function() {
this.options.updatePagePadding && this.updatePagePadding(this.page ? this.page : ".ui-page-active");
},
_handlePageShow: function() {
this.updatePagePadding(this.page ? this.page : ".ui-page-active"), this.options.updatePagePadding && this._on(this.window, {
throttledresize: "updatePagePadding"
});
},
_handlePageBeforeHide: function(e, ui) {
var thisFooter, thisHeader, nextFooter, nextHeader, o = this.options;
o.disablePageZoom && $.mobile.zoom.enable(!0), o.updatePagePadding && this._off(this.window, "throttledresize"), o.trackPersistentToolbars && (thisFooter = $(".ui-footer-fixed:jqmData(id)", this.page), thisHeader = $(".ui-header-fixed:jqmData(id)", this.page), nextFooter = thisFooter.length && ui.nextPage && $(".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData("id") + "')", ui.nextPage) || $(), nextHeader = thisHeader.length && ui.nextPage && $(".ui-header-fixed:jqmData(id='" + thisHeader.jqmData("id") + "')", ui.nextPage) || $(), (nextFooter.length || nextHeader.length) && (nextFooter.add(nextHeader).appendTo($.mobile.pageContainer), ui.nextPage.one("pageshow", function() {
nextHeader.prependTo(this), nextFooter.appendTo(this);
})));
},
_visible: !0,
// This will set the content element's top or bottom padding equal to the toolbar's height
updatePagePadding: function(tbPage) {
var $el = this.element, header = "header" === this.role, pos = parseFloat($el.css(header ? "top" : "bottom"));
// This behavior only applies to "fixed", not "fullscreen"
!this.options.fullscreen && (// tbPage argument can be a Page object or an event, if coming from throttled resize.
tbPage = tbPage && void 0 === tbPage.type && tbPage || this.page || $el.closest(".ui-page"), $(tbPage = this.page ? this.page : ".ui-page-active").css("padding-" + (header ? "top" : "bottom"), $el.outerHeight() + pos));
},
_useTransition: function(notransition) {
var $win = this.window, $el = this.element, scroll = $win.scrollTop(), elHeight = $el.height(), pHeight = this.page ? $el.closest(".ui-page").height() : $(".ui-page-active").height(), viewportHeight = $.mobile.getScreenHeight();
return !notransition && (this.options.transition && "none" !== this.options.transition && ("header" === this.role && !this.options.fullscreen && scroll > elHeight || "footer" === this.role && !this.options.fullscreen && scroll + viewportHeight < pHeight - elHeight) || this.options.fullscreen);
},
show: function(notransition) {
var hideClass = "ui-fixed-hidden", $el = this.element;
this._useTransition(notransition) ? $el.removeClass("out " + hideClass).addClass("in").animationComplete(function() {
$el.removeClass("in");
}) : $el.removeClass(hideClass), this._visible = !0;
},
hide: function(notransition) {
var hideClass = "ui-fixed-hidden", $el = this.element, // if it's a slide transition, our new transitions need the reverse class as well to slide outward
outclass = "out" + ("slide" === this.options.transition ? " reverse" : "");
this._useTransition(notransition) ? $el.addClass(outclass).removeClass("in").animationComplete(function() {
$el.addClass(hideClass).removeClass(outclass);
}) : $el.addClass(hideClass).removeClass(outclass), this._visible = !1;
},
toggle: function() {
this[this._visible ? "hide" : "show"]();
},
_bindToggleHandlers: function() {
var delayShow, delayHide, self = this, o = self.options, isVisible = !0;
// tap toggle
(this.page ? this.page : $(".ui-page")).bind("vclick", function(e) {
o.tapToggle && !$(e.target).closest(o.tapToggleBlacklist).length && self.toggle();
}).bind("focusin focusout", function(e) {
//this hides the toolbars on a keyboard pop to give more screen room and prevent ios bug which
//positions fixed toolbars in the middle of the screen on pop if the input is near the top or
//bottom of the screen addresses issues #4410 Footer navbar moves up when clicking on a textbox in an Android environment
//and issue #4113 Header and footer change their position after keyboard popup - iOS
//and issue #4410 Footer navbar moves up when clicking on a textbox in an Android environment
screen.width < 1025 && $(e.target).is(o.hideDuringFocus) && !$(e.target).closest(".ui-header-fixed, .ui-footer-fixed").length && ("focusout" !== e.type || isVisible ? "focusin" === e.type && isVisible && (//if we have jumped to another input clear the time out to cancel the show.
clearTimeout(delayShow), isVisible = !1, delayHide = setTimeout(function() {
self.hide();
}, 0)) : (isVisible = !0, //wait for the stack to unwind and see if we have jumped to another input
clearTimeout(delayHide), delayShow = setTimeout(function() {
self.show();
}, 0)));
});
},
_setRelative: function() {
"fixed" !== this.options.position && $("[data-" + $.mobile.ns + "role='page']").css({
position: "relative"
});
},
_destroy: function() {
var $el = this.element, header = $el.hasClass("ui-header");
$el.closest(".ui-page").css("padding-" + (header ? "top" : "bottom"), ""), $el.removeClass("ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden"), $el.closest(".ui-page").removeClass("ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen");
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.toolbar", $.mobile.toolbar, {
_makeFixed: function() {
this._super(), this._workarounds();
},
//check the browser and version and run needed workarounds
_workarounds: function() {
var ua = navigator.userAgent, platform = navigator.platform, // Rendering engine is Webkit, and capture major version
wkmatch = ua.match(/AppleWebKit\/([0-9]+)/), wkversion = !!wkmatch && wkmatch[1], os = null;
//set the os we are working in if it dosent match one with workarounds return
if (platform.indexOf("iPhone") > -1 || platform.indexOf("iPad") > -1 || platform.indexOf("iPod") > -1) os = "ios";
else {
if (!(ua.indexOf("Android") > -1)) return;
os = "android";
}
//check os version if it dosent match one with workarounds return
if ("ios" === os) //iOS workarounds
this._bindScrollWorkaround();
else {
if ("android" !== os || !wkversion || !(wkversion < 534)) return;
//Android 2.3 run all Android 2.3 workaround
this._bindScrollWorkaround(), this._bindListThumbWorkaround();
}
},
//Utility class for checking header and footer positions relative to viewport
_viewportOffset: function() {
var $el = this.element, header = $el.hasClass("ui-header"), offset = Math.abs($el.offset().top - this.window.scrollTop());
return header || (offset = Math.round(offset - this.window.height() + $el.outerHeight()) - 60), offset;
},
//bind events for _triggerRedraw() function
_bindScrollWorkaround: function() {
var self = this;
//bind to scrollstop and check if the toolbars are correctly positioned
this._on(this.window, {
scrollstop: function() {
//check if the header is visible and if its in the right place
self._viewportOffset() > 2 && self._visible && self._triggerRedraw();
}
});
},
//this addresses issue #4250 Persistent footer instability in v1.1 with long select lists in Android 2.3.3
//and issue #3748 Android 2.x: Page transitions broken when fixed toolbars used
//the absolutely positioned thumbnail in a list view causes problems with fixed position buttons above in a nav bar
//setting the li's to -webkit-transform:translate3d(0,0,0); solves this problem to avoide potential issues in other
//platforms we scope this with the class ui-android-2x-fix
_bindListThumbWorkaround: function() {
this.element.closest(".ui-page").addClass("ui-android-2x-fixed");
},
//this addresses issues #4337 Fixed header problem after scrolling content on iOS and Android
//and device bugs project issue #1 Form elements can lose click hit area in position: fixed containers.
//this also addresses not on fixed toolbars page in docs
//adding 1px of padding to the bottom then removing it causes a "redraw"
//which positions the toolbars correctly (they will always be visually correct)
_triggerRedraw: function() {
var paddingBottom = parseFloat($(".ui-page-active").css("padding-bottom"));
//trigger page redraw to fix incorrectly positioned fixed elements
$(".ui-page-active").css("padding-bottom", paddingBottom + 1 + "px"), //if the padding is reset with out a timeout the reposition will not occure.
//this is independant of JQM the browser seems to need the time to react.
setTimeout(function() {
$(".ui-page-active").css("padding-bottom", paddingBottom + "px");
}, 0);
},
destroy: function() {
this._super(), //Remove the class we added to the page previously in android 2.x
this.element.closest(".ui-page-active").removeClass("ui-android-2x-fix");
}
});
}(jQuery), function($, undefined) {
var ieHack = $.mobile.browser.oldIE && $.mobile.browser.oldIE <= 8, uiTemplate = $("<div class='ui-popup-arrow-guide'></div><div class='ui-popup-arrow-container" + (ieHack ? " ie" : "") + "'><div class='ui-popup-arrow'></div></div>");
$.widget("mobile.popup", $.mobile.popup, {
options: {
arrow: ""
},
_create: function() {
var ret = this._super();
return this.options.arrow && (this._ui.arrow = this._addArrow()), ret;
},
_addArrow: function() {
var clone, gd, ct, ar, theme, opts = this.options, ar1 = (gd = (clone = uiTemplate.clone()).eq(0), ar = (ct = clone.eq(1)).children(), {
arEls: ct.add(gd),
gd: gd,
ct: ct,
ar: ar
});
return theme = this._themeClassFromOption("ui-body-", opts.theme), ar1.ar.addClass(theme + (opts.shadow ? " ui-overlay-shadow" : "")), ar1.arEls.hide().appendTo(this.element), ar1;
},
_unenhance: function() {
var ar = this._ui.arrow;
return ar && ar.arEls.remove(), this._super();
},
// Pretend to show an arrow described by @p and @dir and calculate the
// distance from the desired point. If a best-distance is passed in, return
// the minimum of the one passed in and the one calculated.
_tryAnArrow: function(p, dir, desired, s, best) {
var result, r, diff, desiredForArrow = {}, tip = {};
return s.arFull[p.dimKey] > s.guideDims[p.dimKey] || (desiredForArrow[p.fst] = desired[p.fst] + (s.arHalf[p.oDimKey] + s.menuHalf[p.oDimKey]) * p.offsetFactor - s.contentBox[p.fst] + (s.clampInfo.menuSize[p.oDimKey] - s.contentBox[p.oDimKey]) * p.arrowOffsetFactor, desiredForArrow[p.snd] = desired[p.snd], r = {
x: (result = s.result || this._calculateFinalLocation(desiredForArrow, s.clampInfo)).left,
y: result.top
}, tip[p.fst] = r[p.fst] + s.contentBox[p.fst] + p.tipOffset, tip[p.snd] = Math.max(result[p.prop] + s.guideOffset[p.prop] + s.arHalf[p.dimKey], Math.min(result[p.prop] + s.guideOffset[p.prop] + s.guideDims[p.dimKey] - s.arHalf[p.dimKey], desired[p.snd])), diff = Math.abs(desired.x - tip.x) + Math.abs(desired.y - tip.y), (!best || diff < best.diff) && (// Convert tip offset to coordinates inside the popup
tip[p.snd] -= s.arHalf[p.dimKey] + result[p.prop] + s.contentBox[p.snd], best = {
dir: dir,
diff: diff,
result: result,
posProp: p.prop,
posVal: tip[p.snd]
})), best;
},
_getPlacementState: function(clamp) {
var offset, gdOffset, ar = this._ui.arrow, state = {
clampInfo: this._clampPopupWidth(!clamp),
arFull: {
cx: ar.ct.width(),
cy: ar.ct.height()
},
guideDims: {
cx: ar.gd.width(),
cy: ar.gd.height()
},
guideOffset: ar.gd.offset()
};
return offset = this.element.offset(), ar.gd.css({
left: 0,
top: 0,
right: 0,
bottom: 0
}), state.contentBox = {
x: (gdOffset = ar.gd.offset()).left - offset.left,
y: gdOffset.top - offset.top,
cx: ar.gd.width(),
cy: ar.gd.height()
}, ar.gd.removeAttr("style"), // The arrow box moves between guideOffset and guideOffset + guideDims - arFull
state.guideOffset = {
left: state.guideOffset.left - offset.left,
top: state.guideOffset.top - offset.top
}, state.arHalf = {
cx: state.arFull.cx / 2,
cy: state.arFull.cy / 2
}, state.menuHalf = {
cx: state.clampInfo.menuSize.cx / 2,
cy: state.clampInfo.menuSize.cy / 2
}, state;
},
_placementCoords: function(desired) {
var state, best, params, elOffset, bgRef, optionValue = this.options.arrow, ar = this._ui.arrow;
return ar ? (ar.arEls.show(), bgRef = {}, params = {
l: {
fst: "x",
snd: "y",
prop: "top",
dimKey: "cy",
oDimKey: "cx",
offsetFactor: 1,
tipOffset: -(state = this._getPlacementState(!0)).arHalf.cx,
arrowOffsetFactor: 0
},
r: {
fst: "x",
snd: "y",
prop: "top",
dimKey: "cy",
oDimKey: "cx",
offsetFactor: -1,
tipOffset: state.arHalf.cx + state.contentBox.cx,
arrowOffsetFactor: 1
},
b: {
fst: "y",
snd: "x",
prop: "left",
dimKey: "cx",
oDimKey: "cy",
offsetFactor: -1,
tipOffset: state.arHalf.cy + state.contentBox.cy,
arrowOffsetFactor: 1
},
t: {
fst: "y",
snd: "x",
prop: "left",
dimKey: "cx",
oDimKey: "cy",
offsetFactor: 1,
tipOffset: -state.arHalf.cy,
arrowOffsetFactor: 0
}
}, // Try each side specified in the options to see on which one the arrow
// should be placed such that the distance between the tip of the arrow and
// the desired coordinates is the shortest.
$.each((!0 === optionValue ? "l,t,r,b" : optionValue).split(","), $.proxy(function(key, value) {
best = this._tryAnArrow(params[value], value, desired, state, best);
}, this)), best) ? (// Move the arrow into place
ar.ct.removeClass("ui-popup-arrow-l ui-popup-arrow-t ui-popup-arrow-r ui-popup-arrow-b").addClass("ui-popup-arrow-" + best.dir).removeAttr("style").css(best.posProp, best.posVal).show(), ieHack || (elOffset = this.element.offset(), bgRef[params[best.dir].fst] = ar.ct.offset(), bgRef[params[best.dir].snd] = {
left: elOffset.left + state.contentBox.x,
top: elOffset.top + state.contentBox.y
}), best.result) : (ar.arEls.hide(), this._super(desired)) : this._super(desired);
},
_setOptions: function(opts) {
var newTheme, oldTheme = this.options.theme, ar = this._ui.arrow, ret = this._super(opts);
if (void 0 !== opts.arrow) {
if (!ar && opts.arrow) {
this._ui.arrow = this._addArrow();
// Important to return here so we don't set the same options all over
// again below.
return;
}
ar && !opts.arrow && (ar.arEls.remove(), this._ui.arrow = null);
}
return(// Reassign with potentially new arrow
(ar = this._ui.arrow) && (void 0 !== opts.theme && (oldTheme = this._themeClassFromOption("ui-body-", oldTheme), newTheme = this._themeClassFromOption("ui-body-", opts.theme), ar.ar.removeClass(oldTheme).addClass(newTheme)), opts.shadow !== undefined && ar.ar.toggleClass("ui-overlay-shadow", opts.shadow)), ret);
},
_destroy: function() {
var ar = this._ui.arrow;
return ar && ar.arEls.remove(), this._super();
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.panel", {
options: {
classes: {
panel: "ui-panel",
panelOpen: "ui-panel-open",
panelClosed: "ui-panel-closed",
panelFixed: "ui-panel-fixed",
panelInner: "ui-panel-inner",
modal: "ui-panel-dismiss",
modalOpen: "ui-panel-dismiss-open",
pageContainer: "ui-panel-page-container",
pageWrapper: "ui-panel-wrapper",
pageFixedToolbar: "ui-panel-fixed-toolbar",
pageContentPrefix: "ui-panel-page-content" /* Used for wrapper and fixed toolbars position, display and open classes. */ ,
animate: "ui-panel-animate"
},
animate: !0,
theme: null,
position: "left",
dismissible: !0,
display: "reveal",
swipeClose: !0,
positionFixed: !1
},
_closeLink: null,
_parentPage: null,
_page: null,
_modal: null,
_panelInner: null,
_wrapper: null,
_fixedToolbars: null,
_create: function() {
var el = this.element, parentPage = el.closest(".ui-page, :jqmData(role='page')");
// expose some private props to other methods
$.extend(this, {
_closeLink: el.find(":jqmData(rel='close')"),
_parentPage: parentPage.length > 0 && parentPage,
_openedPage: null,
_page: this._getPage,
_panelInner: this._getPanelInner(),
_fixedToolbars: this._getFixedToolbars
}), "overlay" !== this.options.display && this._getWrapper(), this._addPanelClasses(), $.support.cssTransform3d && this.options.animate && this.element.addClass(this.options.classes.animate), this._bindUpdateLayout(), this._bindCloseEvents(), this._bindLinkListeners(), this._bindPageEvents(), this.options.dismissible && this._createModal(), this._bindSwipeEvents();
},
_getPanelInner: function() {
var panelInner = this.element.find("." + this.options.classes.panelInner);
return 0 === panelInner.length && (panelInner = this.element.children().wrapAll("<div class='" + this.options.classes.panelInner + "' />").parent()), panelInner;
},
_createModal: function() {
var self = this, target = self._parentPage ? self._parentPage.parent() : self.element.parent();
self._modal = $("<div class='" + self.options.classes.modal + "'></div>").on("mousedown", function() {
self.close();
}).appendTo(target);
},
_getPage: function() {
return this._openedPage || this._parentPage || $("." + $.mobile.activePageClass);
},
_getWrapper: function() {
var wrapper = this._page().find("." + this.options.classes.pageWrapper);
0 === wrapper.length && (wrapper = this._page().children(".ui-header:not(.ui-header-fixed), .ui-content:not(.ui-popup), .ui-footer:not(.ui-footer-fixed)").wrapAll("<div class='" + this.options.classes.pageWrapper + "'></div>").parent()), this._wrapper = wrapper;
},
_getFixedToolbars: function() {
var extFixedToolbars = $("body").children(".ui-header-fixed, .ui-footer-fixed"), intFixedToolbars = this._page().find(".ui-header-fixed, .ui-footer-fixed");
return extFixedToolbars.add(intFixedToolbars).addClass(this.options.classes.pageFixedToolbar);
},
_getPosDisplayClasses: function(prefix) {
return prefix + "-position-" + this.options.position + " " + prefix + "-display-" + this.options.display;
},
_getPanelClasses: function() {
var panelClasses = this.options.classes.panel + " " + this._getPosDisplayClasses(this.options.classes.panel) + " " + this.options.classes.panelClosed + " ui-body-" + (this.options.theme ? this.options.theme : "inherit");
return this.options.positionFixed && (panelClasses += " " + this.options.classes.panelFixed), panelClasses;
},
_addPanelClasses: function() {
this.element.addClass(this._getPanelClasses());
},
_handleCloseClickAndEatEvent: function(event1) {
if (!event1.isDefaultPrevented()) return event1.preventDefault(), this.close(), !1;
},
_handleCloseClick: function(event1) {
event1.isDefaultPrevented() || this.close();
},
_bindCloseEvents: function() {
this._on(this._closeLink, {
click: "_handleCloseClick"
}), this._on({
"click a:jqmData(ajax='false')": "_handleCloseClick"
});
},
_positionPanel: function(scrollToTop) {
var panelInnerHeight = this._panelInner.outerHeight(), expand = panelInnerHeight > $.mobile.getScreenHeight();
expand || !this.options.positionFixed ? (expand && (this._unfixPanel(), $.mobile.resetActivePageHeight(panelInnerHeight)), scrollToTop && this.window[0].scrollTo(0, $.mobile.defaultHomeScroll)) : this._fixPanel();
},
_bindFixListener: function() {
this._on($(window), {
throttledresize: "_positionPanel"
});
},
_unbindFixListener: function() {
this._off($(window), "throttledresize");
},
_unfixPanel: function() {
this.options.positionFixed && $.support.fixedPosition && this.element.removeClass(this.options.classes.panelFixed);
},
_fixPanel: function() {
this.options.positionFixed && $.support.fixedPosition && this.element.addClass(this.options.classes.panelFixed);
},
_bindUpdateLayout: function() {
var self = this;
self.element.on("updatelayout", function() {
self._open && self._positionPanel();
});
},
_bindLinkListeners: function() {
this._on("body", {
"click a": "_handleClick"
});
},
_handleClick: function(e) {
var link, panelId = this.element.attr("id");
if (e.currentTarget.href.split("#")[1] === panelId && void 0 !== panelId) return e.preventDefault(), (link = $(e.target)).hasClass("ui-btn") && (link.addClass($.mobile.activeBtnClass), this.element.one("panelopen panelclose", function() {
link.removeClass($.mobile.activeBtnClass);
})), this.toggle(), !1;
},
_bindSwipeEvents: function() {
var self = this, area = self._modal ? self.element.add(self._modal) : self.element;
// on swipe, close the panel
self.options.swipeClose && ("left" === self.options.position ? area.on("swipeleft.panel", function() {
self.close();
}) : area.on("swiperight.panel", function() {
self.close();
}));
},
_bindPageEvents: function() {
var self = this;
this.document// Close the panel if another panel on the page opens
.on("panelbeforeopen", function(e) {
self._open && e.target !== self.element[0] && self.close();
})// On escape, close? might need to have a target check too...
.on("keyup.panel", function(e) {
27 === e.keyCode && self._open && self.close();
}), this._parentPage || "overlay" === this.options.display || this._on(this.document, {
pageshow: "_getWrapper"
}), self._parentPage ? this.document.on("pagehide", ":jqmData(role='page')", function() {
self._open && self.close(!0);
}) : this.document.on("pagebeforehide", function() {
self._open && self.close(!0);
});
},
// state storage of open or closed
_open: !1,
_pageContentOpenClasses: null,
_modalOpenClasses: null,
open: function(immediate) {
if (!this._open) {
var self = this, o = self.options, _openPanel = function() {
self.document.off("panelclose"), self._page().jqmData("panel", "open"), $.support.cssTransform3d && o.animate && "overlay" !== o.display && (self._wrapper.addClass(o.classes.animate), self._fixedToolbars().addClass(o.classes.animate)), !immediate && $.support.cssTransform3d && o.animate ? self.element.animationComplete(complete, "transition") : setTimeout(complete, 0), o.theme && "overlay" !== o.display && self._page().parent().addClass(o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme), self.element.removeClass(o.classes.panelClosed).addClass(o.classes.panelOpen), self._positionPanel(!0), self._pageContentOpenClasses = self._getPosDisplayClasses(o.classes.pageContentPrefix), "overlay" !== o.display && (self._page().parent().addClass(o.classes.pageContainer), self._wrapper.addClass(self._pageContentOpenClasses), self._fixedToolbars().addClass(self._pageContentOpenClasses)), self._modalOpenClasses = self._getPosDisplayClasses(o.classes.modal) + " " + o.classes.modalOpen, self._modal && self._modal.addClass(self._modalOpenClasses).height(Math.max(self._modal.height(), self.document.height()));
}, complete = function() {
"overlay" !== o.display && (self._wrapper.addClass(o.classes.pageContentPrefix + "-open"), self._fixedToolbars().addClass(o.classes.pageContentPrefix + "-open")), self._bindFixListener(), self._trigger("open"), self._openedPage = self._page();
};
self._trigger("beforeopen"), "open" === self._page().jqmData("panel") ? self.document.on("panelclose", function() {
_openPanel();
}) : _openPanel(), self._open = !0;
}
},
close: function(immediate) {
if (this._open) {
var self = this, o = this.options, complete = function() {
o.theme && "overlay" !== o.display && self._page().parent().removeClass(o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme), self.element.addClass(o.classes.panelClosed), "overlay" !== o.display && (self._page().parent().removeClass(o.classes.pageContainer), self._wrapper.removeClass(o.classes.pageContentPrefix + "-open"), self._fixedToolbars().removeClass(o.classes.pageContentPrefix + "-open")), $.support.cssTransform3d && o.animate && "overlay" !== o.display && (self._wrapper.removeClass(o.classes.animate), self._fixedToolbars().removeClass(o.classes.animate)), self._fixPanel(), self._unbindFixListener(), $.mobile.resetActivePageHeight(), self._page().jqmRemoveData("panel"), self._trigger("close"), self._openedPage = null;
};
self._trigger("beforeclose"), self.element.removeClass(o.classes.panelOpen), "overlay" !== o.display && (self._wrapper.removeClass(self._pageContentOpenClasses), self._fixedToolbars().removeClass(self._pageContentOpenClasses)), !immediate && $.support.cssTransform3d && o.animate ? self.element.animationComplete(complete, "transition") : setTimeout(complete, 0), self._modal && self._modal.removeClass(self._modalOpenClasses), self._open = !1;
}
},
toggle: function() {
this[this._open ? "close" : "open"]();
},
_destroy: function() {
var o = this.options, multiplePanels = $("body > :mobile-panel").length + $.mobile.activePage.find(":mobile-panel").length > 1;
"overlay" !== o.display && (0 === $("body > :mobile-panel").add($.mobile.activePage.find(":mobile-panel")).not(".ui-panel-display-overlay").not(this.element).length && this._wrapper.children().unwrap(), this._open && (this._fixedToolbars().removeClass(o.classes.pageContentPrefix + "-open"), $.support.cssTransform3d && o.animate && this._fixedToolbars().removeClass(o.classes.animate), this._page().parent().removeClass(o.classes.pageContainer), o.theme && this._page().parent().removeClass(o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme))), multiplePanels || this.document.off("panelopen panelclose"), this._open && this._page().jqmRemoveData("panel"), this._panelInner.children().unwrap(), this.element.removeClass([
this._getPanelClasses(),
o.classes.panelOpen,
o.classes.animate
].join(" ")).off("swipeleft.panel swiperight.panel").off("panelbeforeopen").off("panelhide").off("keyup.panel").off("updatelayout"), this._modal && this._modal.remove();
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.table", {
options: {
classes: {
table: "ui-table"
},
enhanced: !1
},
_create: function() {
this.options.enhanced || this.element.addClass(this.options.classes.table), // extend here, assign on refresh > _setHeaders
$.extend(this, {
// Expose headers and allHeaders properties on the widget
// headers references the THs within the first TR in the table
headers: void 0,
// allHeaders references headers, plus all THs in the thead, which may
// include several rows, or not
allHeaders: void 0
}), this._refresh(!0);
},
_setHeaders: function() {
var trs = this.element.find("thead tr");
this.headers = this.element.find("tr:eq(0)").children(), this.allHeaders = this.headers.add(trs.children());
},
refresh: function() {
this._refresh();
},
rebuild: $.noop,
_refresh: function() {
var table = this.element, trs = table.find("thead tr");
// updating headers on refresh (fixes #5880)
this._setHeaders(), // Iterate over the trs
trs.each(function() {
var columnCount = 0;
// Iterate over the children of the tr
$(this).children().each(function() {
var j, span = parseInt(this.getAttribute("colspan"), 10), selector = ":nth-child(" + (columnCount + 1) + ")";
if (this.setAttribute("data-" + $.mobile.ns + "colstart", columnCount + 1), span) for(j = 0; j < span - 1; j++)selector += ", :nth-child(" + (++columnCount + 1) + ")";
// Store "cells" data on header as a reference to all cells in the
// same column as this TH
$(this).jqmData("cells", table.find("tr").not(trs.eq(0)).not(this).children(selector)), columnCount++;
});
});
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.table", $.mobile.table, {
options: {
mode: "columntoggle",
columnBtnTheme: null,
columnPopupTheme: null,
columnBtnText: "Columns...",
classes: $.extend($.mobile.table.prototype.options.classes, {
popup: "ui-table-columntoggle-popup",
columnBtn: "ui-table-columntoggle-btn",
priorityPrefix: "ui-table-priority-",
columnToggleTable: "ui-table-columntoggle"
})
},
_create: function() {
this._super(), "columntoggle" === this.options.mode && ($.extend(this, {
_menu: null
}), this.options.enhanced ? (this._menu = $(this.document[0].getElementById(this._id() + "-popup")).children().first(), this._addToggles(this._menu, !0)) : (this._menu = this._enhanceColToggle(), this.element.addClass(this.options.classes.columnToggleTable)), this._setupEvents(), this._setToggleState());
},
_id: function() {
return this.element.attr("id") || this.widgetName + this.uuid;
},
_setupEvents: function() {
//NOTE: inputs are bound in bindToggles,
// so it can be called on refresh, too
// update column toggles on resize
this._on(this.window, {
throttledresize: "_setToggleState"
}), this._on(this._menu, {
"change input": "_menuInputChange"
});
},
_addToggles: function(menu, keep) {
var inputs, checkboxIndex = 0, opts = this.options, container = menu.controlgroup("container");
keep ? inputs = menu.find("input") : container.empty(), // create the hide/show toggles
this.headers.not("td").each(function() {
var header = $(this), priority = $.mobile.getAttribute(this, "priority"), cells = header.add(header.jqmData("cells"));
priority && (cells.addClass(opts.classes.priorityPrefix + priority), (keep ? inputs.eq(checkboxIndex++) : $("<label><input type='checkbox' checked />" + (header.children("abbr").first().attr("title") || header.text()) + "</label>").appendTo(container).children(0).checkboxradio({
theme: opts.columnPopupTheme
})).jqmData("cells", cells));
}), keep || menu.controlgroup("refresh");
},
_menuInputChange: function(evt) {
var input = $(evt.target), checked = input[0].checked;
input.jqmData("cells").toggleClass("ui-table-cell-hidden", !checked).toggleClass("ui-table-cell-visible", checked), input[0].getAttribute("locked") ? (input.removeAttr("locked"), this._unlockCells(input.jqmData("cells"))) : input.attr("locked", !0);
},
_unlockCells: function(cells) {
// allow hide/show via CSS only = remove all toggle-locks
cells.removeClass("ui-table-cell-hidden ui-table-cell-visible");
},
_enhanceColToggle: function() {
var id, menuButton, popup, menu, table = this.element, opts = this.options, ns = $.mobile.ns, fragment = this.document[0].createDocumentFragment();
return menuButton = $("<a href='#" + (id = this._id() + "-popup") + "' class='" + opts.classes.columnBtn + " ui-btn ui-btn-" + (opts.columnBtnTheme || "a") + " ui-corner-all ui-shadow ui-mini' data-" + ns + "rel='popup'>" + opts.columnBtnText + "</a>"), popup = $("<div class='" + opts.classes.popup + "' id='" + id + "'></div>"), menu = $("<fieldset></fieldset>").controlgroup(), // set extension here, send "false" to trigger build/rebuild
this._addToggles(menu, !1), menu.appendTo(popup), fragment.appendChild(popup[0]), fragment.appendChild(menuButton[0]), table.before(fragment), popup.popup(), menu;
},
rebuild: function() {
this._super(), "columntoggle" === this.options.mode && // NOTE: rebuild passes "false", while refresh passes "undefined"
// both refresh the table, but inside addToggles, !false will be true,
// so a rebuild call can be indentified
this._refresh(!1);
},
_refresh: function(create) {
this._super(create), create || "columntoggle" !== this.options.mode || (// columns not being replaced must be cleared from input toggle-locks
this._unlockCells(this.element.find(".ui-table-cell-hidden, .ui-table-cell-visible")), // update columntoggles and cells
this._addToggles(this._menu, create), // check/uncheck
this._setToggleState());
},
_setToggleState: function() {
this._menu.find("input").each(function() {
var checkbox = $(this);
this.checked = "table-cell" === checkbox.jqmData("cells").eq(0).css("display"), checkbox.checkboxradio("refresh");
});
},
_destroy: function() {
this._super();
}
});
}(jQuery), function($, undefined) {
$.widget("mobile.table", $.mobile.table, {
options: {
mode: "reflow",
classes: $.extend($.mobile.table.prototype.options.classes, {
reflowTable: "ui-table-reflow",
cellLabels: "ui-table-cell-label"
})
},
_create: function() {
// If it's not reflow mode, return here.
this._super(), "reflow" === this.options.mode && (this.options.enhanced || (this.element.addClass(this.options.classes.reflowTable), this._updateReflow()));
},
rebuild: function() {
this._super(), "reflow" === this.options.mode && this._refresh(!1);
},
_refresh: function(create) {
this._super(create), create || "reflow" !== this.options.mode || this._updateReflow();
},
_updateReflow: function() {
var table = this, opts = this.options;
// get headers in reverse order so that top-level headers are appended last
$(table.allHeaders.get().reverse()).each(function() {
var iteration, filter, cells = $(this).jqmData("cells"), colstart = $.mobile.getAttribute(this, "colstart"), hierarchyClass = cells.not(this).filter("thead th").length && " ui-table-cell-label-top", text = $(this).text();
"" !== text && (hierarchyClass ? (iteration = parseInt(this.getAttribute("colspan"), 10), filter = "", iteration && (filter = "td:nth-child(" + iteration + "n + " + colstart + ")"), table._addLabels(cells.filter(filter), opts.classes.cellLabels + hierarchyClass, text)) : table._addLabels(cells, opts.classes.cellLabels, text));
});
},
_addLabels: function(cells, label, text) {
// .not fixes #6006
cells.not(":has(b." + label + ")").prepend("<b class='" + label + "'>" + text + "</b>");
}
});
}(jQuery), function($, undefined) {
// TODO rename filterCallback/deprecate and default to the item itself as the first argument
var defaultFilterCallback = function(index, searchValue) {
return -1 === ("" + ($.mobile.getAttribute(this, "filtertext") || $(this).text())).toLowerCase().indexOf(searchValue);
};
$.widget("mobile.filterable", {
initSelector: ":jqmData(filter='true')",
options: {
filterReveal: !1,
filterCallback: defaultFilterCallback,
enhanced: !1,
input: null,
children: "> li, > option, > optgroup option, > tbody tr, > .ui-controlgroup-controls > .ui-btn, > .ui-controlgroup-controls > .ui-checkbox, > .ui-controlgroup-controls > .ui-radio"
},
_create: function() {
var opts = this.options;
$.extend(this, {
_search: null,
_timer: 0
}), this._setInput(opts.input), opts.enhanced || this._filterItems((this._search && this._search.val() || "").toLowerCase());
},
_onKeyUp: function() {
var val, lastval, search = this._search;
if (search) {
if (val = search.val().toLowerCase(), (lastval = $.mobile.getAttribute(search[0], "lastval") + "") && lastval === val) // Execute the handler only once per value change
return;
this._timer && (window.clearTimeout(this._timer), this._timer = 0), this._timer = this._delay(function() {
this._trigger("beforefilter", null, {
input: search
}), // Change val as lastval for next execution
search[0].setAttribute("data-" + $.mobile.ns + "lastval", val), this._filterItems(val), this._timer = 0;
}, 250);
}
},
_getFilterableItems: function() {
var elem = this.element, children = this.options.children, items = children ? $.isFunction(children) ? children() : children.nodeName ? $(children) : children.jquery ? children : this.element.find(children) : {
length: 0
};
return 0 === items.length && (items = elem.children()), items;
},
_filterItems: function(val) {
var idx, callback, length, show = [], hide = [], opts = this.options, filterItems = this._getFilterableItems();
if (null != val) // Partition the items into those to be hidden and those to be shown
for(idx = 0, callback = opts.filterCallback || defaultFilterCallback, length = filterItems.length; idx < length; idx++)(callback.call(filterItems[idx], idx, val) ? hide : show).push(filterItems[idx]);
0 === hide.length ? filterItems[opts.filterReveal ? "addClass" : "removeClass"]("ui-screen-hidden") : ($(hide).addClass("ui-screen-hidden"), $(show).removeClass("ui-screen-hidden")), this._refreshChildWidget(), this._trigger("filter", null, {
items: filterItems
});
},
// The Default implementation of _refreshChildWidget attempts to call
// refresh on collapsibleset, controlgroup, selectmenu, or listview
_refreshChildWidget: function() {
var widget, idx, recognizedWidgets = [
"collapsibleset",
"selectmenu",
"controlgroup",
"listview"
];
for(idx = recognizedWidgets.length - 1; idx > -1; idx--)widget = recognizedWidgets[idx], $.mobile[widget] && (widget = this.element.data("mobile-" + widget)) && $.isFunction(widget.refresh) && widget.refresh();
},
// TODO: When the input is not internal, do not even store it in this._search
_setInput: function(selector) {
var search = this._search;
this._timer && (window.clearTimeout(this._timer), this._timer = 0), search && (this._off(search, "keyup change input"), search = null), selector && (search = selector.jquery ? selector : selector.nodeName ? $(selector) : this.document.find(selector), this._on(search, {
keyup: "_onKeyUp",
change: "_onKeyUp",
input: "_onKeyUp"
})), this._search = search;
},
_setOptions: function(options) {
var refilter = void 0 !== options.filterReveal || void 0 !== options.filterCallback || options.children !== undefined;
this._super(options), options.input !== undefined && (this._setInput(options.input), refilter = !0), refilter && this.refresh();
},
_destroy: function() {
var opts = this.options, items = this._getFilterableItems();
opts.enhanced ? items.toggleClass("ui-screen-hidden", opts.filterReveal) : items.removeClass("ui-screen-hidden");
},
refresh: function() {
this._timer && (window.clearTimeout(this._timer), this._timer = 0), this._filterItems((this._search && this._search.val() || "").toLowerCase());
}
});
}(jQuery), rDividerListItem = /(^|\s)ui-li-divider(\s|$)/, origDefaultFilterCallback = jQuery.mobile.filterable.prototype.options.filterCallback, // Override the default filter callback with one that does not hide list dividers
jQuery.mobile.filterable.prototype.options.filterCallback = function(index, searchValue) {
return !this.className.match(rDividerListItem) && origDefaultFilterCallback.call(this, index, searchValue);
}, jQuery.widget("mobile.filterable", jQuery.mobile.filterable, {
options: {
filterPlaceholder: "Filter items...",
filterTheme: null
},
_create: function() {
var idx, widgetName, elem = this.element, recognizedWidgets = [
"collapsibleset",
"selectmenu",
"controlgroup",
"listview"
], createHandlers = {};
for(this._super(), jQuery.extend(this, {
_widget: null
}), idx = recognizedWidgets.length - 1; idx > -1; idx--)if (widgetName = recognizedWidgets[idx], jQuery.mobile[widgetName]) {
if (this._setWidget(elem.data("mobile-" + widgetName))) break;
createHandlers[widgetName + "create"] = "_handleCreate";
}
this._widget || this._on(elem, createHandlers);
},
_handleCreate: function(evt) {
this._setWidget(this.element.data("mobile-" + evt.type.substring(0, evt.type.length - 6)));
},
_trigger: function(type, event1, data) {
this._widget && "mobile-listview" === this._widget.widgetFullName && "beforefilter" === type && // Also trigger listviewbeforefilter if this widget is also a listview
this._widget._trigger("beforefilter", event1, data), this._super(type, event1, data);
},
_setWidget: function(widget) {
if (!this._widget && widget) {
var self, orig;
this._widget = widget, this._widget._setOptions = (self = this, orig = this._widget._setOptions, function(options) {
orig.call(this, options), self._syncTextInputOptions(options);
});
}
return this._widget && (this._syncTextInputOptions(this._widget.options), "listview" === this._widget.widgetName && (this._widget.options.hideDividers = !0, this._widget.element.listview("refresh"))), !!this._widget;
},
_isSearchInternal: function() {
return this._search && this._search.jqmData("ui-filterable-" + this.uuid + "-internal");
},
_setInput: function(selector) {
var opts = this.options, updatePlaceholder = !0, textinputOpts = {};
if (!selector) {
if (this._isSearchInternal()) // Ignore the call to set a new input if the selector goes to falsy and
// the current textinput is already of the internally generated variety.
return;
// Generating a new textinput widget. No need to set the placeholder
// further down the function.
updatePlaceholder = !1, selector = jQuery("<input data-" + jQuery.mobile.ns + "type='search' placeholder='" + opts.filterPlaceholder + "'></input>").jqmData("ui-filterable-" + this.uuid + "-internal", !0), jQuery("<form class='ui-filterable'></form>").append(selector).submit(function(evt) {
evt.preventDefault(), selector.blur();
}).insertBefore(this.element), jQuery.mobile.textinput && (null != this.options.filterTheme && (textinputOpts.theme = opts.filterTheme), selector.textinput(textinputOpts));
}
this._super(selector), this._isSearchInternal() && updatePlaceholder && this._search.attr("placeholder", this.options.filterPlaceholder);
},
_setOptions: function(options) {
var ret = this._super(options);
return void 0 !== options.filterPlaceholder && this._isSearchInternal() && this._search.attr("placeholder", options.filterPlaceholder), options.filterTheme !== undefined9 && this._search && jQuery.mobile.textinput && this._search.textinput("option", "theme", options.filterTheme), ret;
},
_destroy: function() {
this._isSearchInternal() && this._search.remove(), this._super();
},
_syncTextInputOptions: function(options) {
var idx, textinputOptions = {};
// We only sync options if the filterable's textinput is of the internally
// generated variety, rather than one specified by the user.
if (this._isSearchInternal() && jQuery.mobile.textinput) {
// Apply only the options understood by textinput
for(idx in jQuery.mobile.textinput.prototype.options)options[idx] !== undefined9 && ("theme" === idx && null != this.options.filterTheme ? textinputOptions[idx] = this.options.filterTheme : textinputOptions[idx] = options[idx]);
this._search.textinput("option", textinputOptions);
}
}
}), /*!
* jQuery UI Tabs fadf2b312a05040436451c64bbfaf4814bc62c56
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/tabs/
*
* Depends:
* jquery.ui.core.js
* jquery.ui.widget.js
*/ function($, undefined) {
var tabId = 0, rhash = /#.*$/;
function isLocal(anchor) {
return anchor.hash.length > 1 && decodeURIComponent(anchor.href.replace(rhash, "")) === decodeURIComponent(location.href.replace(rhash, ""));
}
$.widget("ui.tabs", {
version: "fadf2b312a05040436451c64bbfaf4814bc62c56",
delay: 300,
options: {
active: null,
collapsible: !1,
event: "click",
heightStyle: "content",
hide: null,
show: null,
// callbacks
activate: null,
beforeActivate: null,
beforeLoad: null,
load: null
},
_create: function() {
var that = this, options = this.options;
this.running = !1, this.element.addClass("ui-tabs ui-widget ui-widget-content ui-corner-all").toggleClass("ui-tabs-collapsible", options.collapsible)// Prevent users from focusing disabled tabs via click
.delegate(".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function(event1) {
$(this).is(".ui-state-disabled") && event1.preventDefault();
})// support: IE <9
// Preventing the default action in mousedown doesn't prevent IE
// from focusing the element, so if the anchor gets focused, blur.
// We don't have to worry about focusing the previously focused
// element since clicking on a non-focusable element should focus
// the body anyway.
.delegate(".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
$(this).closest("li").is(".ui-state-disabled") && this.blur();
}), this._processTabs(), options.active = this._initialActive(), $.isArray(options.disabled) && (options.disabled = $.unique(options.disabled.concat($.map(this.tabs.filter(".ui-state-disabled"), function(li) {
return that.tabs.index(li);
}))).sort()), !1 !== this.options.active && this.anchors.length ? this.active = this._findActive(options.active) : this.active = $(), this._refresh(), this.active.length && this.load(options.active);
},
_initialActive: function() {
var active = this.options.active, collapsible = this.options.collapsible, locationHash = location.hash.substring(1);
return null === active && (locationHash && this.tabs.each(function(i, tab) {
if ($(tab).attr("aria-controls") === locationHash) return active = i, !1;
}), null === active && (active = this.tabs.index(this.tabs.filter(".ui-tabs-active"))), (null === active || -1 === active) && (active = !!this.tabs.length && 0)), !1 !== active && -1 === (active = this.tabs.index(this.tabs.eq(active))) && (active = !collapsible && 0), !collapsible && !1 === active && this.anchors.length && (active = 0), active;
},
_getCreateEventData: function() {
return {
tab: this.active,
panel: this.active.length ? this._getPanelForTab(this.active) : $()
};
},
_tabKeydown: function(event1) {
var focusedTab = $(this.document[0].activeElement).closest("li"), selectedIndex = this.tabs.index(focusedTab), goingForward = !0;
if (!this._handlePageNav(event1)) {
switch(event1.keyCode){
case $.ui.keyCode.RIGHT:
case $.ui.keyCode.DOWN:
selectedIndex++;
break;
case $.ui.keyCode.UP:
case $.ui.keyCode.LEFT:
goingForward = !1, selectedIndex--;
break;
case $.ui.keyCode.END:
selectedIndex = this.anchors.length - 1;
break;
case $.ui.keyCode.HOME:
selectedIndex = 0;
break;
case $.ui.keyCode.SPACE:
// Activate only, no collapsing
event1.preventDefault(), clearTimeout(this.activating), this._activate(selectedIndex);
return;
case $.ui.keyCode.ENTER:
// Toggle (cancel delayed activation, allow collapsing)
event1.preventDefault(), clearTimeout(this.activating), // Determine if we should collapse or activate
this._activate(selectedIndex !== this.options.active && selectedIndex);
return;
default:
return;
}
// Focus the appropriate tab, based on which key was pressed
event1.preventDefault(), clearTimeout(this.activating), selectedIndex = this._focusNextTab(selectedIndex, goingForward), event1.ctrlKey || (// Update aria-selected immediately so that AT think the tab is already selected.
// Otherwise AT may confuse the user by stating that they need to activate the tab,
// but the tab will already be activated by the time the announcement finishes.
focusedTab.attr("aria-selected", "false"), this.tabs.eq(selectedIndex).attr("aria-selected", "true"), this.activating = this._delay(function() {
this.option("active", selectedIndex);
}, this.delay));
}
},
_panelKeydown: function(event1) {
!this._handlePageNav(event1) && event1.ctrlKey && event1.keyCode === $.ui.keyCode.UP && (event1.preventDefault(), this.active.focus());
},
// Alt+page up/down moves focus to the previous/next tab (and activates)
_handlePageNav: function(event1) {
return event1.altKey && event1.keyCode === $.ui.keyCode.PAGE_UP ? (this._activate(this._focusNextTab(this.options.active - 1, !1)), !0) : event1.altKey && event1.keyCode === $.ui.keyCode.PAGE_DOWN ? (this._activate(this._focusNextTab(this.options.active + 1, !0)), !0) : void 0;
},
_findNextTab: function(index, goingForward) {
for(var lastTabIndex = this.tabs.length - 1; -1 !== $.inArray((index > lastTabIndex && (index = 0), index < 0 && (index = lastTabIndex), index), this.options.disabled);)index = goingForward ? index + 1 : index - 1;
return index;
},
_focusNextTab: function(index, goingForward) {
return index = this._findNextTab(index, goingForward), this.tabs.eq(index).focus(), index;
},
_setOption: function(key, value) {
if ("active" === key) {
// _activate() will handle invalid values and update this.options
this._activate(value);
return;
}
if ("disabled" === key) {
// don't use the widget factory's disabled handling
this._setupDisabled(value);
return;
}
this._super(key, value), "collapsible" !== key || (this.element.toggleClass("ui-tabs-collapsible", value), value || !1 !== this.options.active || this._activate(0)), "event" === key && this._setupEvents(value), "heightStyle" === key && this._setupHeightStyle(value);
},
_tabId: function(tab) {
return tab.attr("aria-controls") || "ui-tabs-" + ++tabId;
},
_sanitizeSelector: function(hash) {
return hash ? hash.replace(/[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&") : "";
},
refresh: function() {
var options = this.options, lis = this.tablist.children(":has(a[href])");
// get disabled tabs from class attribute from HTML
// this will get converted to a boolean if needed in _refresh()
options.disabled = $.map(lis.filter(".ui-state-disabled"), function(tab) {
return lis.index(tab);
}), this._processTabs(), !1 !== options.active && this.anchors.length ? this.active.length && !$.contains(this.tablist[0], this.active[0]) ? this.tabs.length === options.disabled.length ? (options.active = !1, this.active = $()) : this._activate(this._findNextTab(Math.max(0, options.active - 1), !1)) : // make sure active index is correct
options.active = this.tabs.index(this.active) : (options.active = !1, this.active = $()), this._refresh();
},
_refresh: function() {
this._setupDisabled(this.options.disabled), this._setupEvents(this.options.event), this._setupHeightStyle(this.options.heightStyle), this.tabs.not(this.active).attr({
"aria-selected": "false",
tabIndex: -1
}), this.panels.not(this._getPanelForTab(this.active)).hide().attr({
"aria-expanded": "false",
"aria-hidden": "true"
}), this.active.length ? (this.active.addClass("ui-tabs-active ui-state-active").attr({
"aria-selected": "true",
tabIndex: 0
}), this._getPanelForTab(this.active).show().attr({
"aria-expanded": "true",
"aria-hidden": "false"
})) : this.tabs.eq(0).attr("tabIndex", 0);
},
_processTabs: function() {
var that = this;
this.tablist = this._getList().addClass("ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all").attr("role", "tablist"), this.tabs = this.tablist.find("> li:has(a[href])").addClass("ui-state-default ui-corner-top").attr({
role: "tab",
tabIndex: -1
}), this.anchors = this.tabs.map(function() {
return $("a", this)[0];
}).addClass("ui-tabs-anchor").attr({
role: "presentation",
tabIndex: -1
}), this.panels = $(), this.anchors.each(function(i, anchor) {
var selector, panel, panelId, anchorId = $(anchor).uniqueId().attr("id"), tab = $(anchor).closest("li"), originalAriaControls = tab.attr("aria-controls");
isLocal(anchor) ? (selector = anchor.hash, panel = that.element.find(that._sanitizeSelector(selector))) : (selector = "#" + (panelId = that._tabId(tab)), (panel = that.element.find(selector)).length || (panel = that._createPanel(panelId)).insertAfter(that.panels[i - 1] || that.tablist), panel.attr("aria-live", "polite")), panel.length && (that.panels = that.panels.add(panel)), originalAriaControls && tab.data("ui-tabs-aria-controls", originalAriaControls), tab.attr({
"aria-controls": selector.substring(1),
"aria-labelledby": anchorId
}), panel.attr("aria-labelledby", anchorId);
}), this.panels.addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").attr("role", "tabpanel");
},
// allow overriding how to find the list for rare usage scenarios (#7715)
_getList: function() {
return this.element.find("ol,ul").eq(0);
},
_createPanel: function(id) {
return $("<div>").attr("id", id).addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").data("ui-tabs-destroy", !0);
},
_setupDisabled: function(disabled) {
$.isArray(disabled) && (disabled.length ? disabled.length === this.anchors.length && (disabled = !0) : disabled = !1);
// disable tabs
for(var li, i = 0; li = this.tabs[i]; i++)!0 === disabled || -1 !== $.inArray(i, disabled) ? $(li).addClass("ui-state-disabled").attr("aria-disabled", "true") : $(li).removeClass("ui-state-disabled").removeAttr("aria-disabled");
this.options.disabled = disabled;
},
_setupEvents: function(event1) {
var events = {
click: function(event1) {
event1.preventDefault();
}
};
event1 && $.each(event1.split(" "), function(index, eventName) {
events[eventName] = "_eventHandler";
}), this._off(this.anchors.add(this.tabs).add(this.panels)), this._on(this.anchors, events), this._on(this.tabs, {
keydown: "_tabKeydown"
}), this._on(this.panels, {
keydown: "_panelKeydown"
}), this._focusable(this.tabs), this._hoverable(this.tabs);
},
_setupHeightStyle: function(heightStyle) {
var maxHeight, parent = this.element.parent();
"fill" === heightStyle ? (maxHeight = parent.height() - (this.element.outerHeight() - this.element.height()), this.element.siblings(":visible").each(function() {
var elem = $(this), position = elem.css("position");
"absolute" !== position && "fixed" !== position && (maxHeight -= elem.outerHeight(!0));
}), this.element.children().not(this.panels).each(function() {
maxHeight -= $(this).outerHeight(!0);
}), this.panels.each(function() {
$(this).height(Math.max(0, maxHeight - $(this).innerHeight() + $(this).height()));
}).css("overflow", "auto")) : "auto" === heightStyle && (maxHeight = 0, this.panels.each(function() {
maxHeight = Math.max(maxHeight, $(this).height("").height());
}).height(maxHeight));
},
_eventHandler: function(event1) {
var options = this.options, active = this.active, tab = $(event1.currentTarget).closest("li"), clickedIsActive = tab[0] === active[0], collapsing = clickedIsActive && options.collapsible, toShow = collapsing ? $() : this._getPanelForTab(tab), toHide = active.length ? this._getPanelForTab(active) : $(), eventData = {
oldTab: active,
oldPanel: toHide,
newTab: collapsing ? $() : tab,
newPanel: toShow
};
event1.preventDefault(), !(tab.hasClass("ui-state-disabled") || // tab is already loading
tab.hasClass("ui-tabs-loading")) && !// can't switch durning an animation
this.running && // click on active header, but not collapsible
(!clickedIsActive || options.collapsible) && // allow canceling activation
!1 !== this._trigger("beforeActivate", event1, eventData) && (options.active = !collapsing && this.tabs.index(tab), this.active = clickedIsActive ? $() : tab, this.xhr && this.xhr.abort(), toHide.length || toShow.length || $.error("jQuery UI Tabs: Mismatching fragment identifier."), toShow.length && this.load(this.tabs.index(tab), event1), this._toggle(event1, eventData));
},
// handles show/hide for selecting tabs
_toggle: function(event1, eventData) {
var that = this, toShow = eventData.newPanel, toHide = eventData.oldPanel;
function complete() {
that.running = !1, that._trigger("activate", event1, eventData);
}
function show() {
eventData.newTab.closest("li").addClass("ui-tabs-active ui-state-active"), toShow.length && that.options.show ? that._show(toShow, that.options.show, complete) : (toShow.show(), complete());
}
this.running = !0, toHide.length && this.options.hide ? this._hide(toHide, this.options.hide, function() {
eventData.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"), show();
}) : (eventData.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"), toHide.hide(), show()), toHide.attr({
"aria-expanded": "false",
"aria-hidden": "true"
}), eventData.oldTab.attr("aria-selected", "false"), toShow.length && toHide.length ? eventData.oldTab.attr("tabIndex", -1) : toShow.length && this.tabs.filter(function() {
return 0 === $(this).attr("tabIndex");
}).attr("tabIndex", -1), toShow.attr({
"aria-expanded": "true",
"aria-hidden": "false"
}), eventData.newTab.attr({
"aria-selected": "true",
tabIndex: 0
});
},
_activate: function(index) {
var anchor, active = this._findActive(index);
// trying to activate the already active panel
active[0] !== this.active[0] && (active.length || (active = this.active), anchor = active.find(".ui-tabs-anchor")[0], this._eventHandler({
target: anchor,
currentTarget: anchor,
preventDefault: $.noop
}));
},
_findActive: function(index) {
return !1 === index ? $() : this.tabs.eq(index);
},
_getIndex: function(index) {
return "string" == typeof index && (index = this.anchors.index(this.anchors.filter("[href$='" + index + "']"))), index;
},
_destroy: function() {
this.xhr && this.xhr.abort(), this.element.removeClass("ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible"), this.tablist.removeClass("ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all").removeAttr("role"), this.anchors.removeClass("ui-tabs-anchor").removeAttr("role").removeAttr("tabIndex").removeUniqueId(), this.tabs.add(this.panels).each(function() {
$.data(this, "ui-tabs-destroy") ? $(this).remove() : $(this).removeClass("ui-state-default ui-state-active ui-state-disabled ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel").removeAttr("tabIndex").removeAttr("aria-live").removeAttr("aria-busy").removeAttr("aria-selected").removeAttr("aria-labelledby").removeAttr("aria-hidden").removeAttr("aria-expanded").removeAttr("role");
}), this.tabs.each(function() {
var li = $(this), prev = li.data("ui-tabs-aria-controls");
prev ? li.attr("aria-controls", prev).removeData("ui-tabs-aria-controls") : li.removeAttr("aria-controls");
}), this.panels.show(), "content" !== this.options.heightStyle && this.panels.css("height", "");
},
enable: function(index) {
var disabled = this.options.disabled;
!1 !== disabled && (void 0 === index ? disabled = !1 : (index = this._getIndex(index), disabled = $.isArray(disabled) ? $.map(disabled, function(num) {
return num !== index ? num : null;
}) : $.map(this.tabs, function(li, num) {
return num !== index ? num : null;
})), this._setupDisabled(disabled));
},
disable: function(index) {
var disabled = this.options.disabled;
if (!0 !== disabled) {
if (void 0 === index) disabled = !0;
else {
if (index = this._getIndex(index), -1 !== $.inArray(index, disabled)) return;
disabled = $.isArray(disabled) ? $.merge([
index
], disabled).sort() : [
index
];
}
this._setupDisabled(disabled);
}
},
load: function(index, event1) {
index = this._getIndex(index);
var that = this, tab = this.tabs.eq(index), anchor = tab.find(".ui-tabs-anchor"), panel = this._getPanelForTab(tab), eventData = {
tab: tab,
panel: panel
};
// not remote
!isLocal(anchor[0]) && (this.xhr = $.ajax(this._ajaxSettings(anchor, event1, eventData)), this.xhr && "canceled" !== this.xhr.statusText && (tab.addClass("ui-tabs-loading"), panel.attr("aria-busy", "true"), this.xhr.success(function(response) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
panel.html(response), that._trigger("load", event1, eventData);
}, 1);
}).complete(function(jqXHR, status) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
"abort" === status && that.panels.stop(!1, !0), tab.removeClass("ui-tabs-loading"), panel.removeAttr("aria-busy"), jqXHR === that.xhr && delete that.xhr;
}, 1);
})));
},
_ajaxSettings: function(anchor, event1, eventData) {
var that = this;
return {
url: anchor.attr("href"),
beforeSend: function(jqXHR, settings) {
return that._trigger("beforeLoad", event1, $.extend({
jqXHR: jqXHR,
ajaxSettings: settings
}, eventData));
}
};
},
_getPanelForTab: function(tab) {
var id = $(tab).attr("aria-controls");
return this.element.find(this._sanitizeSelector("#" + id));
}
});
}(jQuery), function($, window) {
$.mobile.iosorientationfixEnabled = !0;
// This fix addresses an iOS bug, so return early if the UA claims it's something else.
var zoom, x, y, z, aig, ua = navigator.userAgent;
if (!(/iPhone|iPad|iPod/.test(navigator.platform) && /OS [1-5]_[0-9_]* like Mac OS X/i.test(ua) && ua.indexOf("AppleWebKit") > -1)) {
$.mobile.iosorientationfixEnabled = !1;
return;
}
function checkTilt(e) {
x = Math.abs((aig = e.originalEvent.accelerationIncludingGravity).x), y = Math.abs(aig.y), z = Math.abs(aig.z), !window.orientation && (x > 7 || (z > 6 && y < 8 || z < 8 && y > 6) && x > 5) ? zoom.enabled && zoom.disable() : zoom.enabled || zoom.enable();
}
zoom = $.mobile.zoom, $.mobile.document.on("mobileinit", function() {
$.mobile.iosorientationfixEnabled && $.mobile.window.bind("orientationchange.iosorientationfix", zoom.enable).bind("devicemotion.iosorientationfix", checkTilt);
});
}(jQuery, this), function($, window, undefined) {
var $html = $("html"), $window = $.mobile.window;
//remove initial build class (only present on first pageshow)
function hideRenderingClass() {
$html.removeClass("ui-mobile-rendering");
}
// support conditions
// if device support condition(s) aren't met, leave things as they are -> a basic, usable experience,
// otherwise, proceed with the enhancements
// trigger mobileinit event - useful hook for configuring $.mobile settings before they're used
$(window.document).trigger("mobileinit"), $.mobile.gradeA() && ($.mobile.ajaxBlacklist && ($.mobile.ajaxEnabled = !1), // Add mobile, initial load "rendering" classes to docEl
$html.addClass("ui-mobile ui-mobile-rendering"), // This is a fallback. If anything goes wrong (JS errors, etc), or events don't fire,
// this ensures the rendering class is removed after 5 seconds, so content is visible and accessible
setTimeout(hideRenderingClass, 5000), $.extend($.mobile, {
// find and enhance the pages in the dom and transition to the first page.
initializePage: function() {
// find present pages
var path = $.mobile.path, $pages = $(":jqmData(role='page'), :jqmData(role='dialog')"), hash = path.stripHash(path.stripQueryParams(path.parseLocation().hash)), hashPage = document1.getElementById(hash);
$pages.length || ($pages = $("body").wrapInner("<div data-" + $.mobile.ns + "role='page'></div>").children(0)), // add dialogs, set data-url attrs
$pages.each(function() {
var $this = $(this);
// unless the data url is already set set it to the pathname
$this[0].getAttribute("data-" + $.mobile.ns + "url") || $this.attr("data-" + $.mobile.ns + "url", $this.attr("id") || location.pathname + location.search);
}), // define first page in dom case one backs out to the directory root (not always the first page visited, but defined as fallback)
$.mobile.firstPage = $pages.first(), // define page container
$.mobile.pageContainer = $.mobile.firstPage.parent().addClass("ui-mobile-viewport").pagecontainer(), // initialize navigation events now, after mobileinit has occurred and the page container
// has been created but before the rest of the library is alerted to that fact
$.mobile.navreadyDeferred.resolve(), // alert listeners that the pagecontainer has been determined for binding
// to events triggered on it
$window.trigger("pagecontainercreate"), // cue page loading message
$.mobile.loading("show"), //remove initial build class (only present on first pageshow)
hideRenderingClass(), $.mobile.hashListeningEnabled && $.mobile.path.isHashValid(location.hash) && ($(hashPage).is(":jqmData(role='page')") || $.mobile.path.isPath(hash) || hash === $.mobile.dialogHashKey) ? $.event.special.navigate.isPushStateEnabled() ? (// TODO figure out how to simplify this interaction with the initial history entry
// at the bottom js/navigate/navigate.js
$.mobile.navigate.history.stack = [], $.mobile.navigate($.mobile.path.isPath(location.hash) ? location.hash : location.href)) : $window.trigger("hashchange", [
!0
]) : ($.mobile.path.isHashValid(location.hash) && ($.mobile.navigate.history.initialDst = hash.replace("#", "")), $.event.special.navigate.isPushStateEnabled() && $.mobile.navigate.navigator.squash(path.parseLocation().href), $.mobile.changePage($.mobile.firstPage, {
transition: "none",
reverse: !0,
changeHash: !1,
fromHashChange: !0
}));
}
}), $(function() {
//Run inlineSVG support test
$.support.inlineSVG(), $.mobile.hideUrlBar && window.scrollTo(0, 1), // if defaultHomeScroll hasn't been set yet, see if scrollTop is 1
// it should be 1 in most browsers, but android treats 1 as 0 (for hiding addr bar)
// so if it's 1, use 0 from now on
$.mobile.defaultHomeScroll = $.support.scrollTop && 1 !== $.mobile.window.scrollTop() ? 1 : 0, $.mobile.autoInitializePage && $.mobile.initializePage(), $.mobile.hideUrlBar && $window.load($.mobile.silentScroll), $.support.cssPointerEvents || // IE and Opera don't support CSS pointer-events: none that we use to disable link-based buttons
// by adding the 'ui-disabled' class to them. Using a JavaScript workaround for those browser.
// https://github.com/jquery/jquery-mobile/issues/3558
// DEPRECATED as of 1.4.0 - remove ui-disabled after 1.4.0 release
// only ui-state-disabled should be present thereafter
$.mobile.document.delegate(".ui-state-disabled,.ui-disabled", "vclick", function(e) {
e.preventDefault(), e.stopImmediatePropagation();
});
}));
}(jQuery, this);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/mootools-1.4.5.js | JavaScript | !/*
---
MooTools: the javascript framework
web build:
- http://mootools.net/core/76bf47062d6c1983d66ce47ad66aa0e0
packager build:
- packager build Core/Core Core/Array Core/String Core/Number Core/Function Core/Object Core/Event Core/Browser Core/Class Core/Class.Extras Core/Slick.Parser Core/Slick.Finder Core/Element Core/Element.Style Core/Element.Event Core/Element.Delegation Core/Element.Dimensions Core/Fx Core/Fx.CSS Core/Fx.Tween Core/Fx.Morph Core/Fx.Transitions Core/Request Core/Request.HTML Core/Request.JSON Core/Cookie Core/JSON Core/DOMReady Core/Swiff
...
*/ /*
---
name: Core
description: The heart of MooTools.
license: MIT-style license.
copyright: Copyright (c) 2006-2012 [Valerio Proietti](http://mad4milk.net/).
authors: The MooTools production team (http://mootools.net/developers/)
inspiration:
- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
- Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)
provides: [Core, MooTools, Type, typeOf, instanceOf, Native]
...
*/ function() {
this.MooTools = {
version: "1.4.5",
build: "ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0"
};
// typeOf, instanceOf
var typeOf1 = this.typeOf = function(item) {
if (null == item) return "null";
if (null != item.$family) return item.$family();
if (item.nodeName) {
if (1 == item.nodeType) return "element";
if (3 == item.nodeType) return /\S/.test(item.nodeValue) ? "textnode" : "whitespace";
} else if ("number" == typeof item.length) {
if (item.callee) return "arguments";
if ("item" in item) return "collection";
}
return typeof item;
}, instanceOf1 = this.instanceOf = function(item, object) {
if (null == item) return !1;
for(var constructor = item.$constructor || item.constructor; constructor;){
if (constructor === object) return !0;
constructor = constructor.parent;
}
return /*<ltIE8>*/ !!item.hasOwnProperty && item instanceof object;
}, Function1 = this.Function, enumerables = !0;
for(var i in {
toString: 1
})enumerables = null;
enumerables && (enumerables = [
"hasOwnProperty",
"valueOf",
"isPrototypeOf",
"propertyIsEnumerable",
"toLocaleString",
"toString",
"constructor"
]), Function1.prototype.overloadSetter = function(usePlural) {
var self = this;
return function(a, b) {
if (null == a) return this;
if (usePlural || "string" != typeof a) {
for(var k in a)self.call(this, k, a[k]);
if (enumerables) for(var i = enumerables.length; i--;)k = enumerables[i], a.hasOwnProperty(k) && self.call(this, k, a[k]);
} else self.call(this, a, b);
return this;
};
}, Function1.prototype.overloadGetter = function(usePlural) {
var self = this;
return function(a) {
var args, result;
if ("string" != typeof a ? args = a : arguments.length > 1 ? args = arguments : usePlural && (args = [
a
]), args) {
result = {};
for(var i = 0; i < args.length; i++)result[args[i]] = self.call(this, args[i]);
} else result = self.call(this, a);
return result;
};
}, Function1.prototype.extend = (function(key, value) {
this[key] = value;
}).overloadSetter(), Function1.prototype.implement = (function(key, value) {
this.prototype[key] = value;
}).overloadSetter();
// From
var slice = Array.prototype.slice;
Function1.from = function(item) {
return "function" == typeOf1(item) ? item : function() {
return item;
};
}, Array.from = function(item) {
return null == item ? [] : Type1.isEnumerable(item) && "string" != typeof item ? "array" == typeOf1(item) ? item : slice.call(item) : [
item
];
}, Number.from = function(item) {
var number = parseFloat(item);
return isFinite(number) ? number : null;
}, String.from = function(item) {
return item + "";
}, // hide, protect
Function1.implement({
hide: function() {
return this.$hidden = !0, this;
},
protect: function() {
return this.$protected = !0, this;
}
});
// Type
var Type1 = this.Type = function(name, object) {
if (name) {
var lower = name.toLowerCase(), typeCheck = function(item) {
return typeOf1(item) == lower;
};
Type1["is" + name] = typeCheck, null != object && (object.prototype.$family = (function() {
return lower;
}).hide(), //<1.2compat>
object.type = typeCheck);
}
return null == object ? null : (object.extend(this), object.$constructor = Type1, object.prototype.$constructor = object, object);
}, toString = Object.prototype.toString;
Type1.isEnumerable = function(item) {
return null != item && "number" == typeof item.length && "[object Function]" != toString.call(item);
};
var hooks = {}, hooksOf = function(object) {
var type = typeOf1(object.prototype);
return hooks[type] || (hooks[type] = []);
}, implement = function(name, method) {
if (!method || !method.$hidden) {
for(var hooks = hooksOf(this), i = 0; i < hooks.length; i++){
var hook = hooks[i];
"type" == typeOf1(hook) ? implement.call(hook, name, method) : hook.call(this, name, method);
}
var previous = this.prototype[name];
null != previous && previous.$protected || (this.prototype[name] = method), null == this[name] && "function" == typeOf1(method) && extend.call(this, name, function(item) {
return method.apply(item, slice.call(arguments, 1));
});
}
}, extend = function(name, method) {
if (!method || !method.$hidden) {
var previous = this[name];
null != previous && previous.$protected || (this[name] = method);
}
};
Type1.implement({
implement: implement.overloadSetter(),
extend: extend.overloadSetter(),
alias: (function(name, existing) {
implement.call(this, name, this.prototype[existing]);
}).overloadSetter(),
mirror: function(hook) {
return hooksOf(this).push(hook), this;
}
}), new Type1("Type", Type1);
// Default Types
var force = function(name, object, methods) {
var isType = object != Object, prototype = object.prototype;
isType && (object = new Type1(name, object));
for(var i = 0, l = methods.length; i < l; i++){
var key = methods[i], generic = object[key], proto = prototype[key];
generic && generic.protect(), isType && proto && object.implement(key, proto.protect());
}
if (isType) {
var methodsEnumerable = prototype.propertyIsEnumerable(methods[0]);
object.forEachMethod = function(fn) {
if (!methodsEnumerable) for(var i = 0, l = methods.length; i < l; i++)fn.call(prototype, prototype[methods[i]], methods[i]);
for(var key in prototype)fn.call(prototype, prototype[key], key);
};
}
return force;
};
force("String", String, [
"charAt",
"charCodeAt",
"concat",
"indexOf",
"lastIndexOf",
"match",
"quote",
"replace",
"search",
"slice",
"split",
"substr",
"substring",
"trim",
"toLowerCase",
"toUpperCase"
])("Array", Array, [
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift",
"concat",
"join",
"slice",
"indexOf",
"lastIndexOf",
"filter",
"forEach",
"every",
"map",
"some",
"reduce",
"reduceRight"
])("Number", Number, [
"toExponential",
"toFixed",
"toLocaleString",
"toPrecision"
])("Function", Function1, [
"apply",
"call",
"bind"
])("RegExp", RegExp, [
"exec",
"test"
])("Object", Object, [
"create",
"defineProperty",
"defineProperties",
"keys",
"getPrototypeOf",
"getOwnPropertyDescriptor",
"getOwnPropertyNames",
"preventExtensions",
"isExtensible",
"seal",
"isSealed",
"freeze",
"isFrozen"
])("Date", Date, [
"now"
]), Object.extend = extend.overloadSetter(), Date.extend("now", function() {
return +new Date();
}), new Type1("Boolean", Boolean), // fixes NaN returning as Number
Number.prototype.$family = (function() {
return isFinite(this) ? "number" : "null";
}).hide(), // Number.random
Number.extend("random", function(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
});
// forEach, each
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend("forEach", function(object, fn, bind) {
for(var key in object)hasOwnProperty.call(object, key) && fn.call(bind, object[key], key, object);
}), Object.each = Object.forEach, Array.implement({
forEach: function(fn, bind) {
for(var i = 0, l = this.length; i < l; i++)i in this && fn.call(bind, this[i], i, this);
},
each: function(fn, bind) {
return Array.forEach(this, fn, bind), this;
}
});
// Array & Object cloning, Object merging and appending
var cloneOf = function(item) {
switch(typeOf1(item)){
case "array":
return item.clone();
case "object":
return Object.clone(item);
default:
return item;
}
};
Array.implement("clone", function() {
for(var i = this.length, clone = Array(i); i--;)clone[i] = cloneOf(this[i]);
return clone;
});
var mergeOne = function(source, key, current) {
switch(typeOf1(current)){
case "object":
"object" == typeOf1(source[key]) ? Object.merge(source[key], current) : source[key] = Object.clone(current);
break;
case "array":
source[key] = current.clone();
break;
default:
source[key] = current;
}
return source;
};
Object.extend({
merge: function(source, k, v) {
if ("string" == typeOf1(k)) return mergeOne(source, k, v);
for(var i = 1, l = arguments.length; i < l; i++){
var object = arguments[i];
for(var key in object)mergeOne(source, key, object[key]);
}
return source;
},
clone: function(object) {
var clone = {};
for(var key in object)clone[key] = cloneOf(object[key]);
return clone;
},
append: function(original) {
for(var i = 1, l = arguments.length; i < l; i++){
var extended = arguments[i] || {};
for(var key in extended)original[key] = extended[key];
}
return original;
}
}), // Object-less types
[
"Object",
"WhiteSpace",
"TextNode",
"Collection",
"Arguments"
].each(function(name) {
new Type1(name);
});
// Unique ID
var UID = Date.now();
String.extend("uniqueID", function() {
return (UID++).toString(36);
});
//<1.2compat>
var Hash1 = this.Hash = new Type1("Hash", function(object) {
for(var key in "hash" == typeOf1(object) && (object = Object.clone(object.getClean())), object)this[key] = object[key];
return this;
});
Hash1.implement({
forEach: function(fn, bind) {
Object.forEach(this, fn, bind);
},
getClean: function() {
var clean = {};
for(var key in this)this.hasOwnProperty(key) && (clean[key] = this[key]);
return clean;
},
getLength: function() {
var length = 0;
for(var key in this)this.hasOwnProperty(key) && length++;
return length;
}
}), Hash1.alias("each", "forEach"), Object.type = Type1.isObject;
var Native = this.Native = function(properties) {
return new Type1(properties.name, properties.initialize);
};
Native.type = Type1.type, Native.implement = function(objects, methods) {
for(var i = 0; i < objects.length; i++)objects[i].implement(methods);
return Native;
};
var arrayType = Array.type;
Array.type = function(item) {
return instanceOf1(item, Array) || arrayType(item);
}, this.$A = function(item) {
return Array.from(item).slice();
}, this.$arguments = function(i) {
return function() {
return arguments[i];
};
}, this.$chk = function(obj) {
return !!(obj || 0 === obj);
}, this.$clear = function(timer) {
return clearTimeout(timer), clearInterval(timer), null;
}, this.$defined = function(obj) {
return null != obj;
}, this.$each = function(iterable, fn, bind) {
var type = typeOf1(iterable);
("arguments" == type || "collection" == type || "array" == type || "elements" == type ? Array : Object).each(iterable, fn, bind);
}, this.$empty = function() {}, this.$extend = function(original, extended) {
return Object.append(original, extended);
}, this.$H = function(object) {
return new Hash1(object);
}, this.$merge = function() {
var args = Array.slice(arguments);
return args.unshift({}), Object.merge.apply(null, args);
}, this.$lambda = Function1.from, this.$mixin = Object.merge, this.$random = Number.random, this.$splat = Array.from, this.$time = Date.now, this.$type = function(object) {
var type = typeOf1(object);
return "elements" == type ? "array" : "null" != type && type;
}, this.$unlink = function(object) {
switch(typeOf1(object)){
case "object":
return Object.clone(object);
case "array":
return Array.clone(object);
case "hash":
return new Hash1(object);
default:
return object;
}
};
//</1.2compat>
}(), /*
---
name: Array
description: Contains Array Prototypes like each, contains, and erase.
license: MIT-style license.
requires: Type
provides: Array
...
*/ Array.implement({
/*<!ES5>*/ every: function(fn, bind) {
for(var i = 0, l = this.length >>> 0; i < l; i++)if (i in this && !fn.call(bind, this[i], i, this)) return !1;
return !0;
},
filter: function(fn, bind) {
for(var value, results = [], i = 0, l = this.length >>> 0; i < l; i++)i in this && (value = this[i], fn.call(bind, value, i, this) && results.push(value));
return results;
},
indexOf: function(item, from) {
for(var length = this.length >>> 0, i = from < 0 ? Math.max(0, length + from) : from || 0; i < length; i++)if (this[i] === item) return i;
return -1;
},
map: function(fn, bind) {
for(var length = this.length >>> 0, results = Array(length), i = 0; i < length; i++)i in this && (results[i] = fn.call(bind, this[i], i, this));
return results;
},
some: function(fn, bind) {
for(var i = 0, l = this.length >>> 0; i < l; i++)if (i in this && fn.call(bind, this[i], i, this)) return !0;
return !1;
},
/*</!ES5>*/ clean: function() {
return this.filter(function(item) {
return null != item;
});
},
invoke: function(methodName) {
var args = Array.slice(arguments, 1);
return this.map(function(item) {
return item[methodName].apply(item, args);
});
},
associate: function(keys) {
for(var obj = {}, length = Math.min(this.length, keys.length), i = 0; i < length; i++)obj[keys[i]] = this[i];
return obj;
},
link: function(object) {
for(var result = {}, i = 0, l = this.length; i < l; i++)for(var key in object)if (object[key](this[i])) {
result[key] = this[i], delete object[key];
break;
}
return result;
},
contains: function(item, from) {
return -1 != this.indexOf(item, from);
},
append: function(array) {
return this.push.apply(this, array), this;
},
getLast: function() {
return this.length ? this[this.length - 1] : null;
},
getRandom: function() {
return this.length ? this[Number.random(0, this.length - 1)] : null;
},
include: function(item) {
return this.contains(item) || this.push(item), this;
},
combine: function(array) {
for(var i = 0, l = array.length; i < l; i++)this.include(array[i]);
return this;
},
erase: function(item) {
for(var i = this.length; i--;)this[i] === item && this.splice(i, 1);
return this;
},
empty: function() {
return this.length = 0, this;
},
flatten: function() {
for(var array = [], i = 0, l = this.length; i < l; i++){
var type = typeOf(this[i]);
"null" != type && (array = array.concat("array" == type || "collection" == type || "arguments" == type || instanceOf(this[i], Array) ? Array.flatten(this[i]) : this[i]));
}
return array;
},
pick: function() {
for(var i = 0, l = this.length; i < l; i++)if (null != this[i]) return this[i];
return null;
},
hexToRgb: function(array) {
if (3 != this.length) return null;
var rgb = this.map(function(value) {
return 1 == value.length && (value += value), value.toInt(16);
});
return array ? rgb : "rgb(" + rgb + ")";
},
rgbToHex: function(array) {
if (this.length < 3) return null;
if (4 == this.length && 0 == this[3] && !array) return "transparent";
for(var hex = [], i = 0; i < 3; i++){
var bit = (this[i] - 0).toString(16);
hex.push(1 == bit.length ? "0" + bit : bit);
}
return array ? hex : "#" + hex.join("");
}
}), //<1.2compat>
Array.alias("extend", "append");
var $pick = function() {
return Array.from(arguments).pick();
};
//</1.2compat>
/*
---
name: String
description: Contains String Prototypes like camelCase, capitalize, test, and toInt.
license: MIT-style license.
requires: Type
provides: String
...
*/ String.implement({
test: function(regex, params) {
return ("regexp" == typeOf(regex) ? regex : RegExp("" + regex, params)).test(this);
},
contains: function(string, separator) {
return separator ? (separator + this + separator).indexOf(separator + string + separator) > -1 : String(this).indexOf(string) > -1;
},
trim: function() {
return String(this).replace(/^\s+|\s+$/g, "");
},
clean: function() {
return String(this).replace(/\s+/g, " ").trim();
},
camelCase: function() {
return String(this).replace(/-\D/g, function(match) {
return match.charAt(1).toUpperCase();
});
},
hyphenate: function() {
return String(this).replace(/[A-Z]/g, function(match) {
return "-" + match.charAt(0).toLowerCase();
});
},
capitalize: function() {
return String(this).replace(/\b[a-z]/g, function(match) {
return match.toUpperCase();
});
},
escapeRegExp: function() {
return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
},
toInt: function(base) {
return parseInt(this, base || 10);
},
toFloat: function() {
return parseFloat(this);
},
hexToRgb: function(array) {
var hex = String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
return hex ? hex.slice(1).hexToRgb(array) : null;
},
rgbToHex: function(array) {
var rgb = String(this).match(/\d{1,3}/g);
return rgb ? rgb.rgbToHex(array) : null;
},
substitute: function(object, regexp) {
return String(this).replace(regexp || /\\?\{([^{}]+)\}/g, function(match, name) {
return "\\" == match.charAt(0) ? match.slice(1) : null != object[name] ? object[name] : "";
});
}
}), /*
---
name: Number
description: Contains Number Prototypes like limit, round, times, and ceil.
license: MIT-style license.
requires: Type
provides: Number
...
*/ Number.implement({
limit: function(min, max) {
return Math.min(max, Math.max(min, this));
},
round: function(precision) {
return Math.round(this * (precision = Math.pow(10, precision || 0).toFixed(precision < 0 ? -precision : 0))) / precision;
},
times: function(fn, bind) {
for(var i = 0; i < this; i++)fn.call(bind, i, this);
},
toFloat: function() {
return parseFloat(this);
},
toInt: function(base) {
return parseInt(this, base || 10);
}
}), Number.alias("each", "times"), function(math) {
var methods = {};
math.each(function(name) {
Number[name] || (methods[name] = function() {
return Math[name].apply(null, [
this
].concat(Array.from(arguments)));
});
}), Number.implement(methods);
}([
"abs",
"acos",
"asin",
"atan",
"atan2",
"ceil",
"cos",
"exp",
"floor",
"log",
"max",
"min",
"pow",
"sin",
"sqrt",
"tan"
]), /*
---
name: Function
description: Contains Function Prototypes like create, bind, pass, and delay.
license: MIT-style license.
requires: Type
provides: Function
...
*/ Function.extend({
attempt: function() {
for(var i = 0, l = arguments.length; i < l; i++)try {
return arguments[i]();
} catch (e) {}
return null;
}
}), Function.implement({
attempt: function(args, bind) {
try {
return this.apply(bind, Array.from(args));
} catch (e) {}
return null;
},
/*<!ES5-bind>*/ bind: function(that) {
var self = this, args = arguments.length > 1 ? Array.slice(arguments, 1) : null, F = function() {}, bound = function() {
var context = that, length = arguments.length;
this instanceof bound && (F.prototype = self.prototype, context = new F());
var result = args || length ? self.apply(context, args && length ? args.concat(Array.slice(arguments)) : args || arguments) : self.call(context);
return context == that ? result : context;
};
return bound;
},
/*</!ES5-bind>*/ pass: function(args, bind) {
var self = this;
return null != args && (args = Array.from(args)), function() {
return self.apply(bind, args || arguments);
};
},
delay: function(delay, bind, args) {
return setTimeout(this.pass(null == args ? [] : args, bind), delay);
},
periodical: function(periodical, bind, args) {
return setInterval(this.pass(null == args ? [] : args, bind), periodical);
}
}), //<1.2compat>
delete Function.prototype.bind, Function.implement({
create: function(options) {
var self = this;
return options = options || {}, function(event) {
var args = options.arguments;
args = null != args ? Array.from(args) : Array.slice(arguments, +!!options.event), options.event && (args = [
event || window.event
].extend(args));
var returns = function() {
return self.apply(options.bind || null, args);
};
return options.delay ? setTimeout(returns, options.delay) : options.periodical ? setInterval(returns, options.periodical) : options.attempt ? Function.attempt(returns) : returns();
};
},
bind: function(bind, args) {
var self = this;
return null != args && (args = Array.from(args)), function() {
return self.apply(bind, args || arguments);
};
},
bindWithEvent: function(bind, args) {
var self = this;
return null != args && (args = Array.from(args)), function(event) {
return self.apply(bind, null == args ? arguments : [
event
].concat(args));
};
},
run: function(args, bind) {
return this.apply(bind, Array.from(args));
}
}), Object.create == Function.prototype.create && (Object.create = null);
var $try = Function.attempt;
!//</1.2compat>
/*
---
name: Object
description: Object generic methods
license: MIT-style license.
requires: Type
provides: [Object, Hash]
...
*/ function() {
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend({
subset: function(object, keys) {
for(var results = {}, i = 0, l = keys.length; i < l; i++){
var k = keys[i];
k in object && (results[k] = object[k]);
}
return results;
},
map: function(object, fn, bind) {
var results = {};
for(var key in object)hasOwnProperty.call(object, key) && (results[key] = fn.call(bind, object[key], key, object));
return results;
},
filter: function(object, fn, bind) {
var results = {};
for(var key in object){
var value = object[key];
hasOwnProperty.call(object, key) && fn.call(bind, value, key, object) && (results[key] = value);
}
return results;
},
every: function(object, fn, bind) {
for(var key in object)if (hasOwnProperty.call(object, key) && !fn.call(bind, object[key], key)) return !1;
return !0;
},
some: function(object, fn, bind) {
for(var key in object)if (hasOwnProperty.call(object, key) && fn.call(bind, object[key], key)) return !0;
return !1;
},
keys: function(object) {
var keys = [];
for(var key in object)hasOwnProperty.call(object, key) && keys.push(key);
return keys;
},
values: function(object) {
var values = [];
for(var key in object)hasOwnProperty.call(object, key) && values.push(object[key]);
return values;
},
getLength: function(object) {
return Object.keys(object).length;
},
keyOf: function(object, value) {
for(var key in object)if (hasOwnProperty.call(object, key) && object[key] === value) return key;
return null;
},
contains: function(object, value) {
return null != Object.keyOf(object, value);
},
toQueryString: function(object, base) {
var queryString = [];
return Object.each(object, function(value, key) {
switch(base && (key = base + "[" + key + "]"), typeOf(value)){
case "object":
result = Object.toQueryString(value, key);
break;
case "array":
var result, qs = {};
value.each(function(val, i) {
qs[i] = val;
}), result = Object.toQueryString(qs, key);
break;
default:
result = key + "=" + encodeURIComponent(value);
}
null != value && queryString.push(result);
}), queryString.join("&");
}
});
}(), //<1.2compat>
Hash.implement({
has: Object.prototype.hasOwnProperty,
keyOf: function(value) {
return Object.keyOf(this, value);
},
hasValue: function(value) {
return Object.contains(this, value);
},
extend: function(properties) {
return Hash.each(properties || {}, function(value, key) {
Hash.set(this, key, value);
}, this), this;
},
combine: function(properties) {
return Hash.each(properties || {}, function(value, key) {
Hash.include(this, key, value);
}, this), this;
},
erase: function(key) {
return this.hasOwnProperty(key) && delete this[key], this;
},
get: function(key) {
return this.hasOwnProperty(key) ? this[key] : null;
},
set: function(key, value) {
return (!this[key] || this.hasOwnProperty(key)) && (this[key] = value), this;
},
empty: function() {
return Hash.each(this, function(value, key) {
delete this[key];
}, this), this;
},
include: function(key, value) {
return null == this[key] && (this[key] = value), this;
},
map: function(fn, bind) {
return new Hash(Object.map(this, fn, bind));
},
filter: function(fn, bind) {
return new Hash(Object.filter(this, fn, bind));
},
every: function(fn, bind) {
return Object.every(this, fn, bind);
},
some: function(fn, bind) {
return Object.some(this, fn, bind);
},
getKeys: function() {
return Object.keys(this);
},
getValues: function() {
return Object.values(this);
},
toQueryString: function(base) {
return Object.toQueryString(this, base);
}
}), Hash.extend = Object.append, Hash.alias({
indexOf: "keyOf",
contains: "hasValue"
}), //</1.2compat>
/*
---
name: Browser
description: The Browser Object. Contains Browser initialization, Window and Document, and the Browser Hash.
license: MIT-style license.
requires: [Array, Function, Number, String]
provides: [Browser, Window, Document]
...
*/ function() {
var document1 = this.document, window1 = document1.window = this, ua = navigator.userAgent.toLowerCase(), platform = navigator.platform.toLowerCase(), UA = ua.match(/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/) || [
null,
"unknown",
0
], mode = "ie" == UA[1] && document1.documentMode, Browser1 = this.Browser = {
extend: Function.prototype.extend,
name: "version" == UA[1] ? UA[3] : UA[1],
version: mode || parseFloat("opera" == UA[1] && UA[4] ? UA[4] : UA[2]),
Platform: {
name: ua.match(/ip(?:ad|od|hone)/) ? "ios" : (ua.match(/(?:webos|android)/) || platform.match(/mac|win|linux/) || [
"other"
])[0]
},
Features: {
xpath: !!document1.evaluate,
air: !!window1.runtime,
query: !!document1.querySelector,
json: !!window1.JSON
},
Plugins: {}
};
Browser1[Browser1.name] = !0, Browser1[Browser1.name + parseInt(Browser1.version, 10)] = !0, Browser1.Platform[Browser1.Platform.name] = !0, // Request
Browser1.Request = function() {
var XMLHTTP = function() {
return new XMLHttpRequest();
}, MSXML2 = function() {
return new ActiveXObject("MSXML2.XMLHTTP");
}, MSXML = function() {
return new ActiveXObject("Microsoft.XMLHTTP");
};
return Function.attempt(function() {
return XMLHTTP(), XMLHTTP;
}, function() {
return MSXML2(), MSXML2;
}, function() {
return MSXML(), MSXML;
});
}(), Browser1.Features.xhr = !!Browser1.Request;
// Flash detection
var version = (Function.attempt(function() {
return navigator.plugins["Shockwave Flash"].description;
}, function() {
return new ActiveXObject("ShockwaveFlash.ShockwaveFlash").GetVariable("$version");
}) || "0 r0").match(/\d+/g);
if (Browser1.Plugins.Flash = {
version: Number(version[0] || "0." + version[1]) || 0,
build: Number(version[2]) || 0
}, // String scripts
Browser1.exec = function(text) {
if (!text) return text;
if (window1.execScript) window1.execScript(text);
else {
var script = document1.createElement("script");
script.setAttribute("type", "text/javascript"), script.text = text, document1.head.appendChild(script), document1.head.removeChild(script);
}
return text;
}, String.implement("stripScripts", function(exec) {
var scripts = "", text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, function(all, code) {
return scripts += code + "\n", "";
});
return !0 === exec ? Browser1.exec(scripts) : "function" == typeOf(exec) && exec(scripts, text), text;
}), // Window, Document
Browser1.extend({
Document: this.Document,
Window: this.Window,
Element: this.Element,
Event: this.Event
}), this.Window = this.$constructor = new Type("Window", function() {}), this.$family = Function.from("window").hide(), Window.mirror(function(name, method) {
window1[name] = method;
}), this.Document = document1.$constructor = new Type("Document", function() {}), document1.$family = Function.from("document").hide(), Document.mirror(function(name, method) {
document1[name] = method;
}), document1.html = document1.documentElement, document1.head || (document1.head = document1.getElementsByTagName("head")[0]), document1.execCommand) try {
document1.execCommand("BackgroundImageCache", !1, !0);
} catch (e) {}
/*<ltIE9>*/ if (this.attachEvent && !this.addEventListener) {
var unloadEvent = function() {
this.detachEvent("onunload", unloadEvent), document1.head = document1.html = document1.window = null;
};
this.attachEvent("onunload", unloadEvent);
}
// IE fails on collections and <select>.options (refers to <select>)
var arrayFrom = Array.from;
try {
arrayFrom(document1.html.childNodes);
} catch (e) {
Array.from = function(item) {
if ("string" != typeof item && Type.isEnumerable(item) && "array" != typeOf(item)) {
for(var i = item.length, array = Array(i); i--;)array[i] = item[i];
return array;
}
return arrayFrom(item);
};
var prototype = Array.prototype, slice = prototype.slice;
[
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift",
"concat",
"join",
"slice"
].each(function(name) {
var method = prototype[name];
Array[name] = function(item) {
return method.apply(Array.from(item), slice.call(arguments, 1));
};
});
}
Browser1.Platform.ios && (Browser1.Platform.ipod = !0), Browser1.Engine = {};
var setEngine = function(name, version) {
Browser1.Engine.name = name, Browser1.Engine[name + version] = !0, Browser1.Engine.version = version;
};
if (Browser1.ie) switch(Browser1.Engine.trident = !0, Browser1.version){
case 6:
setEngine("trident", 4);
break;
case 7:
setEngine("trident", 5);
break;
case 8:
setEngine("trident", 6);
}
if (Browser1.firefox && (Browser1.Engine.gecko = !0, setEngine("gecko", Browser1.version >= 3 ? 19 : 18)), Browser1.safari || Browser1.chrome) switch(Browser1.Engine.webkit = !0, Browser1.version){
case 2:
setEngine("webkit", 419);
break;
case 3:
setEngine("webkit", 420);
break;
case 4:
setEngine("webkit", 525);
}
if (Browser1.opera && (Browser1.Engine.presto = !0, setEngine("presto", Browser1.version >= 9.6 ? 960 : Browser1.version >= 9.5 ? 950 : 925)), "unknown" == Browser1.name) switch((ua.match(/(?:webkit|khtml|gecko)/) || [])[0]){
case "webkit":
case "khtml":
Browser1.Engine.webkit = !0;
break;
case "gecko":
Browser1.Engine.gecko = !0;
}
this.$exec = Browser1.exec;
//</1.2compat>
}(), /*
---
name: Event
description: Contains the Event Type, to make the event object cross-browser.
license: MIT-style license.
requires: [Window, Document, Array, Function, String, Object]
provides: Event
...
*/ function() {
var _keys = {}, DOMEvent1 = this.DOMEvent = new Type("DOMEvent", function(event, win) {
if (win || (win = window), (event = event || win.event).$extended) return event;
this.event = event, this.$extended = !0, this.shift = event.shiftKey, this.control = event.ctrlKey, this.alt = event.altKey, this.meta = event.metaKey;
for(var type = this.type = event.type, target = event.target || event.srcElement; target && 3 == target.nodeType;)target = target.parentNode;
if (this.target = document.id(target), 0 == type.indexOf("key")) {
var code = this.code = event.which || event.keyCode;
this.key = _keys[code] || Object.keyOf(Event.Keys, code) /*</1.3compat>*/ , "keydown" == type && (code > 111 && code < 124 ? this.key = "f" + (code - 111) : code > 95 && code < 106 && (this.key = code - 96)), null == this.key && (this.key = String.fromCharCode(code).toLowerCase());
} else if ("click" == type || "dblclick" == type || "contextmenu" == type || "DOMMouseScroll" == type || 0 == type.indexOf("mouse")) {
var doc = win.document;
if (doc = doc.compatMode && "CSS1Compat" != doc.compatMode ? doc.body : doc.html, this.page = {
x: null != event.pageX ? event.pageX : event.clientX + doc.scrollLeft,
y: null != event.pageY ? event.pageY : event.clientY + doc.scrollTop
}, this.client = {
x: null != event.pageX ? event.pageX - win.pageXOffset : event.clientX,
y: null != event.pageY ? event.pageY - win.pageYOffset : event.clientY
}, ("DOMMouseScroll" == type || "mousewheel" == type) && (this.wheel = event.wheelDelta ? event.wheelDelta / 120 : -(event.detail || 0) / 3), this.rightClick = 3 == event.which || 2 == event.button, "mouseover" == type || "mouseout" == type) {
for(var related = event.relatedTarget || event[("mouseover" == type ? "from" : "to") + "Element"]; related && 3 == related.nodeType;)related = related.parentNode;
this.relatedTarget = document.id(related);
}
} else if (0 == type.indexOf("touch") || 0 == type.indexOf("gesture")) {
this.rotation = event.rotation, this.scale = event.scale, this.targetTouches = event.targetTouches, this.changedTouches = event.changedTouches;
var touches = this.touches = event.touches;
if (touches && touches[0]) {
var touch = touches[0];
this.page = {
x: touch.pageX,
y: touch.pageY
}, this.client = {
x: touch.clientX,
y: touch.clientY
};
}
}
this.client || (this.client = {}), this.page || (this.page = {});
});
DOMEvent1.implement({
stop: function() {
return this.preventDefault().stopPropagation();
},
stopPropagation: function() {
return this.event.stopPropagation ? this.event.stopPropagation() : this.event.cancelBubble = !0, this;
},
preventDefault: function() {
return this.event.preventDefault ? this.event.preventDefault() : this.event.returnValue = !1, this;
}
}), DOMEvent1.defineKey = function(code, key) {
return _keys[code] = key, this;
}, DOMEvent1.defineKeys = DOMEvent1.defineKey.overloadSetter(!0), DOMEvent1.defineKeys({
38: "up",
40: "down",
37: "left",
39: "right",
27: "esc",
32: "space",
8: "backspace",
9: "tab",
46: "delete",
13: "enter"
});
}();
/*<1.3compat>*/ var Event = DOMEvent;
Event.Keys = {}, /*</1.3compat>*/ /*<1.2compat>*/ Event.Keys = new Hash(Event.Keys), /*</1.2compat>*/ /*
---
name: Class
description: Contains the Class Function for easily creating, extending, and implementing reusable Classes.
license: MIT-style license.
requires: [Array, String, Function, Number]
provides: Class
...
*/ function() {
var Class1 = this.Class = new Type("Class", function(params) {
instanceOf(params, Function) && (params = {
initialize: params
});
var newClass = (function() {
if (reset(this), newClass.$prototyping) return this;
this.$caller = null;
var value = this.initialize ? this.initialize.apply(this, arguments) : this;
return this.$caller = this.caller = null, value;
}).extend(this).implement(params);
return newClass.$constructor = Class1, newClass.prototype.$constructor = newClass, newClass.prototype.parent = parent, newClass;
}), parent = function() {
if (!this.$caller) throw Error('The method "parent" cannot be called.');
var name = this.$caller.$name, parent = this.$caller.$owner.parent, previous = parent ? parent.prototype[name] : null;
if (!previous) throw Error('The method "' + name + '" has no parent.');
return previous.apply(this, arguments);
}, reset = function(object) {
for(var key in object){
var value = object[key];
switch(typeOf(value)){
case "object":
var F = function() {};
F.prototype = value, object[key] = reset(new F());
break;
case "array":
object[key] = value.clone();
}
}
return object;
}, wrap = function(self, key, method) {
method.$origin && (method = method.$origin);
var wrapper = (function() {
if (method.$protected && null == this.$caller) throw Error('The method "' + key + '" cannot be called.');
var caller = this.caller, current = this.$caller;
this.caller = current, this.$caller = wrapper;
var result = method.apply(this, arguments);
return this.$caller = current, this.caller = caller, result;
}).extend({
$owner: self,
$origin: method,
$name: key
});
return wrapper;
}, implement = function(key, value, retain) {
if (Class1.Mutators.hasOwnProperty(key) && null == (value = Class1.Mutators[key].call(this, value))) return this;
if ("function" == typeOf(value)) {
if (value.$hidden) return this;
this.prototype[key] = retain ? value : wrap(this, key, value);
} else Object.merge(this.prototype, key, value);
return this;
}, getInstance = function(klass) {
klass.$prototyping = !0;
var proto = new klass();
return delete klass.$prototyping, proto;
};
Class1.implement("implement", implement.overloadSetter()), Class1.Mutators = {
Extends: function(parent) {
this.parent = parent, this.prototype = getInstance(parent);
},
Implements: function(items) {
Array.from(items).each(function(item) {
var instance = new item();
for(var key in instance)implement.call(this, key, instance[key], !0);
}, this);
}
};
}(), /*
---
name: Class.Extras
description: Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
license: MIT-style license.
requires: Class
provides: [Class.Extras, Chain, Events, Options]
...
*/ function() {
this.Chain = new Class({
$chain: [],
chain: function() {
return this.$chain.append(Array.flatten(arguments)), this;
},
callChain: function() {
return !!this.$chain.length && this.$chain.shift().apply(this, arguments);
},
clearChain: function() {
return this.$chain.empty(), this;
}
});
var removeOn = function(string) {
return string.replace(/^on([A-Z])/, function(full, first) {
return first.toLowerCase();
});
};
this.Events = new Class({
$events: {},
addEvent: function(type, fn, internal) {
return type = removeOn(type), fn == $empty || (/*</1.2compat>*/ this.$events[type] = (this.$events[type] || []).include(fn), internal && (fn.internal = !0)), this;
},
addEvents: function(events) {
for(var type in events)this.addEvent(type, events[type]);
return this;
},
fireEvent: function(type, args, delay) {
type = removeOn(type);
var events = this.$events[type];
return events && (args = Array.from(args), events.each(function(fn) {
delay ? fn.delay(delay, this, args) : fn.apply(this, args);
}, this)), this;
},
removeEvent: function(type, fn) {
type = removeOn(type);
var events = this.$events[type];
if (events && !fn.internal) {
var index = events.indexOf(fn);
-1 != index && delete events[index];
}
return this;
},
removeEvents: function(events) {
var type;
if ("object" == typeOf(events)) {
for(type in events)this.removeEvent(type, events[type]);
return this;
}
for(type in events && (events = removeOn(events)), this.$events)if (!events || events == type) for(var fns = this.$events[type], i = fns.length; i--;)i in fns && this.removeEvent(type, fns[i]);
return this;
}
}), this.Options = new Class({
setOptions: function() {
var options = this.options = Object.merge.apply(null, [
{},
this.options
].append(arguments));
if (this.addEvent) for(var option in options)"function" == typeOf(options[option]) && /^on[A-Z]/.test(option) && (this.addEvent(option, options[option]), delete options[option]);
return this;
}
});
}(), /*
---
name: Slick.Parser
description: Standalone CSS3 Selector parser
provides: Slick.Parser
...
*/ (function() {
var parsed, separatorIndex, combinatorIndex, reversed, cache = {}, reverseCache = {}, reUnescape = /\\/g, parse = function(expression, isReversed) {
if (null == expression) return null;
if (!0 === expression.Slick) return expression;
expression = ("" + expression).replace(/^\s+|\s+$/g, "");
var currentCache = (reversed = !!isReversed) ? reverseCache : cache;
if (currentCache[expression]) return currentCache[expression];
for(parsed = {
Slick: !0,
expressions: [],
raw: expression,
reverse: function() {
return parse(this.raw, !0);
}
}, separatorIndex = -1; expression != (expression = expression.replace(regexp, parser)););
return parsed.length = parsed.expressions.length, currentCache[parsed.raw] = reversed ? reverse(parsed) : parsed;
}, reverseCombinator = function(combinator) {
return "!" === combinator ? " " : " " === combinator ? "!" : /^!/.test(combinator) ? combinator.replace(/^!/, "") : "!" + combinator;
}, reverse = function(expression) {
for(var expressions = expression.expressions, i = 0; i < expressions.length; i++){
for(var exp = expressions[i], last = {
parts: [],
tag: "*",
combinator: reverseCombinator(exp[0].combinator)
}, j = 0; j < exp.length; j++){
var cexp = exp[j];
cexp.reverseCombinator || (cexp.reverseCombinator = " "), cexp.combinator = cexp.reverseCombinator, delete cexp.reverseCombinator;
}
exp.reverse().push(last);
}
return expression;
}, escapeRegExp = function(string) {
// Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License
return string.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, function(match) {
return "\\" + match;
});
}, regexp = new RegExp(/*
#!/usr/bin/env ruby
puts "\t\t" + DATA.read.gsub(/\(\?x\)|\s+#.*$|\s+|\\$|\\n/,'')
__END__
"(?x)^(?:\
\\s* ( , ) \\s* # Separator \n\
| \\s* ( <combinator>+ ) \\s* # Combinator \n\
| ( \\s+ ) # CombinatorChildren \n\
| ( <unicode>+ | \\* ) # Tag \n\
| \\# ( <unicode>+ ) # ID \n\
| \\. ( <unicode>+ ) # ClassName \n\
| # Attribute \n\
\\[ \
\\s* (<unicode1>+) (?: \
\\s* ([*^$!~|]?=) (?: \
\\s* (?:\
([\"']?)(.*?)\\9 \
)\
) \
)? \\s* \
\\](?!\\]) \n\
| :+ ( <unicode>+ )(?:\
\\( (?:\
(?:([\"'])([^\\12]*)\\12)|((?:\\([^)]+\\)|[^()]*)+)\
) \\)\
)?\
)"
*/ "^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)".replace(/<combinator>/, "[" + escapeRegExp(">+~`!@$%^&={}\\;</") + "]").replace(/<unicode>/g, "(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])").replace(/<unicode1>/g, "(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])"));
function parser(rawMatch, separator, combinator, combinatorChildren, tagName, id, className1, attributeKey, attributeOperator, attributeQuote, attributeValue, pseudoMarker, pseudoClass, pseudoQuote, pseudoClassQuotedValue, pseudoClassValue) {
if ((separator || -1 === separatorIndex) && (parsed.expressions[++separatorIndex] = [], combinatorIndex = -1, separator)) return "";
if (combinator || combinatorChildren || -1 === combinatorIndex) {
combinator = combinator || " ";
var test, regexp, currentSeparator = parsed.expressions[separatorIndex];
reversed && currentSeparator[combinatorIndex] && (currentSeparator[combinatorIndex].reverseCombinator = reverseCombinator(combinator)), currentSeparator[++combinatorIndex] = {
combinator: combinator,
tag: "*"
};
}
var currentParsed = parsed.expressions[separatorIndex][combinatorIndex];
if (tagName) currentParsed.tag = tagName.replace(reUnescape, "");
else if (id) currentParsed.id = id.replace(reUnescape, "");
else if (className1) className1 = className1.replace(reUnescape, ""), currentParsed.classList || (currentParsed.classList = []), currentParsed.classes || (currentParsed.classes = []), currentParsed.classList.push(className1), currentParsed.classes.push({
value: className1,
regexp: RegExp("(^|\\s)" + escapeRegExp(className1) + "(\\s|$)")
});
else if (pseudoClass) pseudoClassValue = (pseudoClassValue = pseudoClassValue || pseudoClassQuotedValue) ? pseudoClassValue.replace(reUnescape, "") : null, currentParsed.pseudos || (currentParsed.pseudos = []), currentParsed.pseudos.push({
key: pseudoClass.replace(reUnescape, ""),
value: pseudoClassValue,
type: 1 == pseudoMarker.length ? "class" : "element"
});
else if (attributeKey) {
switch(attributeKey = attributeKey.replace(reUnescape, ""), attributeValue = (attributeValue || "").replace(reUnescape, ""), attributeOperator){
case "^=":
regexp = RegExp("^" + escapeRegExp(attributeValue));
break;
case "$=":
regexp = RegExp(escapeRegExp(attributeValue) + "$");
break;
case "~=":
regexp = RegExp("(^|\\s)" + escapeRegExp(attributeValue) + "(\\s|$)");
break;
case "|=":
regexp = RegExp("^" + escapeRegExp(attributeValue) + "(-|$)");
break;
case "=":
test = function(value) {
return attributeValue == value;
};
break;
case "*=":
test = function(value) {
return value && value.indexOf(attributeValue) > -1;
};
break;
case "!=":
test = function(value) {
return attributeValue != value;
};
break;
default:
test = function(value) {
return !!value;
};
}
"" == attributeValue && /^[*$^]=$/.test(attributeOperator) && (test = function() {
return !1;
}), test || (test = function(value) {
return value && regexp.test(value);
}), currentParsed.attributes || (currentParsed.attributes = []), currentParsed.attributes.push({
key: attributeKey,
operator: attributeOperator,
value: attributeValue,
test: test
});
}
return "";
}
// Slick NS
var Slick1 = this.Slick || {};
Slick1.parse = function(expression) {
return parse(expression);
}, Slick1.escapeRegExp = escapeRegExp, this.Slick || (this.Slick = Slick1);
}).apply(/*<CommonJS>*/ "undefined" != typeof exports ? exports : /*</CommonJS>*/ this), /*
---
name: Slick.Finder
description: The new, superfast css selector engine.
provides: Slick.Finder
requires: Slick.Parser
...
*/ (function() {
var local = {}, featuresCache = {}, toString = Object.prototype.toString;
// Feature / Bug detection
local.isNativeCode = function(fn) {
return /\{\s*\[native code\]\s*\}/.test("" + fn);
}, local.isXML = function(document1) {
return !!document1.xmlVersion || !!document1.xml || "[object XMLDocument]" == toString.call(document1) || 9 == document1.nodeType && "HTML" != document1.documentElement.nodeName;
}, local.setDocument = function(document1) {
// convert elements / window arguments to document. if document cannot be extrapolated, the function returns.
var nodeType = document1.nodeType;
if (9 == nodeType) ;
else if (nodeType) // document
document1 = document1.ownerDocument; // node
else {
if (!document1.navigator) return;
document1 = document1.document; // window
}
// check if it's the old document
if (this.document !== document1) {
this.document = document1;
// check if we have done feature detection on this document before
var feature, root = document1.documentElement, rootUid = this.getUIDXML(root), features = featuresCache[rootUid];
if (features) {
for(feature in features)this[feature] = features[feature];
return;
}
features = featuresCache[rootUid] = {}, features.root = root, features.isXMLDocument = this.isXML(document1), features.brokenStarGEBTN = features.starSelectsClosedQSA = features.idGetsName = features.brokenMixedCaseQSA = features.brokenGEBCN = features.brokenCheckedQSA = features.brokenEmptyAttributeQSA = features.isHTMLDocument = features.nativeMatchesSelector = !1;
var starSelectsClosed, starSelectsComments, brokenSecondClassNameGEBCN, cachedGetElementsByClassName, brokenFormAttributeGetter, selected, id = "slick_uniqueid", testNode = document1.createElement("div"), testRoot = document1.body || document1.getElementsByTagName("body")[0] || root;
testRoot.appendChild(testNode);
// on non-HTML documents innerHTML and getElementsById doesnt work properly
try {
testNode.innerHTML = '<a id="' + id + '"></a>', features.isHTMLDocument = !!document1.getElementById(id);
} catch (e) {}
if (features.isHTMLDocument) {
testNode.style.display = "none", // IE returns comment nodes for getElementsByTagName('*') for some documents
testNode.appendChild(document1.createComment("")), starSelectsComments = testNode.getElementsByTagName("*").length > 1;
// IE returns closed nodes (EG:"</foo>") for getElementsByTagName('*') for some documents
try {
testNode.innerHTML = "foo</foo>", starSelectsClosed = (selected = testNode.getElementsByTagName("*")) && !!selected.length && "/" == selected[0].nodeName.charAt(0);
} catch (e) {}
features.brokenStarGEBTN = starSelectsComments || starSelectsClosed;
// IE returns elements with the name instead of just id for getElementsById for some documents
try {
testNode.innerHTML = '<a name="' + id + '"></a><b id="' + id + '"></b>', features.idGetsName = document1.getElementById(id) === testNode.firstChild;
} catch (e) {}
if (testNode.getElementsByClassName) {
// Safari 3.2 getElementsByClassName caches results
try {
testNode.innerHTML = '<a class="f"></a><a class="b"></a>', testNode.getElementsByClassName("b").length, testNode.firstChild.className = "b", cachedGetElementsByClassName = 2 != testNode.getElementsByClassName("b").length;
} catch (e) {}
// Opera 9.6 getElementsByClassName doesnt detects the class if its not the first one
try {
testNode.innerHTML = '<a class="a"></a><a class="f b a"></a>', brokenSecondClassNameGEBCN = 2 != testNode.getElementsByClassName("a").length;
} catch (e) {}
features.brokenGEBCN = cachedGetElementsByClassName || brokenSecondClassNameGEBCN;
}
if (testNode.querySelectorAll) {
// IE 8 returns closed nodes (EG:"</foo>") for querySelectorAll('*') for some documents
try {
testNode.innerHTML = "foo</foo>", selected = testNode.querySelectorAll("*"), features.starSelectsClosedQSA = selected && !!selected.length && "/" == selected[0].nodeName.charAt(0);
} catch (e) {}
// Safari 3.2 querySelectorAll doesnt work with mixedcase on quirksmode
try {
testNode.innerHTML = '<a class="MiX"></a>', features.brokenMixedCaseQSA = !testNode.querySelectorAll(".MiX").length;
} catch (e) {}
// Webkit and Opera dont return selected options on querySelectorAll
try {
testNode.innerHTML = '<select><option selected="selected">a</option></select>', features.brokenCheckedQSA = 0 == testNode.querySelectorAll(":checked").length;
} catch (e) {}
// IE returns incorrect results for attr[*^$]="" selectors on querySelectorAll
try {
testNode.innerHTML = '<a class=""></a>', features.brokenEmptyAttributeQSA = 0 != testNode.querySelectorAll('[class*=""]').length;
} catch (e) {}
}
// IE6-7, if a form has an input of id x, form.getAttribute(x) returns a reference to the input
try {
testNode.innerHTML = '<form action="s"><input id="action"/></form>', brokenFormAttributeGetter = "s" != testNode.firstChild.getAttribute("action");
} catch (e) {}
if (// native matchesSelector function
features.nativeMatchesSelector = root.matchesSelector || /*root.msMatchesSelector ||*/ root.mozMatchesSelector || root.webkitMatchesSelector, features.nativeMatchesSelector) try {
// if matchesSelector trows errors on incorrect sintaxes we can use it
features.nativeMatchesSelector.call(root, ":slick"), features.nativeMatchesSelector = null;
} catch (e) {}
}
try {
root.slick_expando = 1, delete root.slick_expando, features.getUID = this.getUIDHTML;
} catch (e) {
features.getUID = this.getUIDXML;
}
testRoot.removeChild(testNode), testNode = selected = testRoot = null, // getAttribute
features.getAttribute = features.isHTMLDocument && brokenFormAttributeGetter ? function(node, name) {
var method = this.attributeGetters[name];
if (method) return method.call(node);
var attributeNode = node.getAttributeNode(name);
return attributeNode ? attributeNode.nodeValue : null;
} : function(node, name) {
var method = this.attributeGetters[name];
return method ? method.call(node) : node.getAttribute(name);
}, // hasAttribute
features.hasAttribute = root && this.isNativeCode(root.hasAttribute) ? function(node, attribute) {
return node.hasAttribute(attribute);
} : function(node, attribute) {
return !!((node = node.getAttributeNode(attribute)) && (node.specified || node.nodeValue));
};
// contains
// FIXME: Add specs: local.contains should be different for xml and html documents?
var nativeRootContains = root && this.isNativeCode(root.contains), nativeDocumentContains = document1 && this.isNativeCode(document1.contains);
for(feature in features.contains = nativeRootContains && nativeDocumentContains ? function(context, node) {
return context.contains(node);
} : nativeRootContains && !nativeDocumentContains ? function(context, node) {
// IE8 does not have .contains on document.
return context === node || (context === document1 ? document1.documentElement : context).contains(node);
} : root && root.compareDocumentPosition ? function(context, node) {
return context === node || !!(16 & context.compareDocumentPosition(node));
} : function(context, node) {
if (node) do if (node === context) return !0;
while (node = node.parentNode)
return !1;
}, // document order sorting
// credits to Sizzle (http://sizzlejs.com/)
features.documentSorter = root.compareDocumentPosition ? function(a, b) {
return a.compareDocumentPosition && b.compareDocumentPosition ? 4 & a.compareDocumentPosition(b) ? -1 : +(a !== b) : 0;
} : "sourceIndex" in root ? function(a, b) {
return a.sourceIndex && b.sourceIndex ? a.sourceIndex - b.sourceIndex : 0;
} : document1.createRange ? function(a, b) {
if (!a.ownerDocument || !b.ownerDocument) return 0;
var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
return aRange.setStart(a, 0), aRange.setEnd(a, 0), bRange.setStart(b, 0), bRange.setEnd(b, 0), aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
} : null, root = null, features)this[feature] = features[feature];
}
};
// Main Method
var reSimpleSelector = /^([#.]?)((?:[\w-]+|\*))$/, reEmptyAttribute = /\[.+[*$^]=(?:""|'')?\]/, qsaFailExpCache = {};
local.search = function(context, expression, append, first) {
var found = this.found = first ? null : append || [];
if (!context) return found;
if (context.navigator) context = context.document;
else if (!context.nodeType) return found;
// setup
var parsed, i, uniques = this.uniques = {}, hasOthers = !!(append && append.length), contextIsDocument = 9 == context.nodeType;
// avoid duplicating items already in the append array
if (this.document !== (contextIsDocument ? context : context.ownerDocument) && this.setDocument(context), hasOthers) for(i = found.length; i--;)uniques[this.getUID(found[i])] = !0;
// expression checks
if ("string" == typeof expression) {
// expression is a string
/*<simple-selectors-override>*/ var simpleSelector = expression.match(reSimpleSelector);
simpleSelectors: if (simpleSelector) {
var node, nodes, symbol = simpleSelector[1], name = simpleSelector[2];
if (symbol) {
if ("#" == symbol) {
if (!this.isHTMLDocument || !contextIsDocument) break simpleSelectors;
if (!(node = context.getElementById(name))) return found;
if (this.idGetsName && node.getAttributeNode("id").nodeValue != name) break simpleSelectors;
if (first) return node || null;
hasOthers && uniques[this.getUID(node)] || found.push(node);
} else if ("." == symbol) {
if (!this.isHTMLDocument || (!context.getElementsByClassName || this.brokenGEBCN) && context.querySelectorAll) break simpleSelectors;
if (context.getElementsByClassName && !this.brokenGEBCN) {
if (nodes = context.getElementsByClassName(name), first) return nodes[0] || null;
for(i = 0; node = nodes[i++];)hasOthers && uniques[this.getUID(node)] || found.push(node);
} else {
var matchClass = RegExp("(^|\\s)" + Slick1.escapeRegExp(name) + "(\\s|$)");
for(i = 0, nodes = context.getElementsByTagName("*"); node = nodes[i++];)if ((className = node.className) && matchClass.test(className)) {
if (first) return node;
hasOthers && uniques[this.getUID(node)] || found.push(node);
}
}
}
} else {
if ("*" == name && this.brokenStarGEBTN) break simpleSelectors;
if (nodes = context.getElementsByTagName(name), first) return nodes[0] || null;
for(i = 0; node = nodes[i++];)hasOthers && uniques[this.getUID(node)] || found.push(node);
}
return hasOthers && this.sort(found), first ? null : found;
}
/*</simple-selectors-override>*/ /*<query-selector-override>*/ querySelector: if (context.querySelectorAll) {
if (!this.isHTMLDocument || qsaFailExpCache[expression] || //TODO: only skip when expression is actually mixed case
this.brokenMixedCaseQSA || this.brokenCheckedQSA && expression.indexOf(":checked") > -1 || this.brokenEmptyAttributeQSA && reEmptyAttribute.test(expression) || !contextIsDocument && //Abort when !contextIsDocument and...
// there are multiple expressions in the selector
// since we currently only fix non-document rooted QSA for single expression selectors
expression.indexOf(",") > -1 || Slick1.disableQSA) break querySelector;
var _expression = expression, _context = context;
if (!contextIsDocument) {
// non-document rooted QSA
// credits to Andrew Dupont
var currentId = _context.getAttribute("id"), slickid = "slickid__";
_context.setAttribute("id", slickid), _expression = "#" + slickid + " " + _expression, context = _context.parentNode;
}
try {
if (first) return context.querySelector(_expression) || null;
nodes = context.querySelectorAll(_expression);
} catch (e) {
qsaFailExpCache[expression] = 1;
break querySelector;
} finally{
contextIsDocument || (currentId ? _context.setAttribute("id", currentId) : _context.removeAttribute("id"), context = _context);
}
if (this.starSelectsClosedQSA) for(i = 0; node = nodes[i++];)node.nodeName > "@" && !(hasOthers && uniques[this.getUID(node)]) && found.push(node);
else for(i = 0; node = nodes[i++];)hasOthers && uniques[this.getUID(node)] || found.push(node);
return hasOthers && this.sort(found), found;
}
if (!/*</query-selector-override>*/ (parsed = this.Slick.parse(expression)).length) return found;
} else if (null == expression) // there is no expression
return found;
else if (expression.Slick) // expression is a parsed Slick object
parsed = expression;
else if (this.contains(context.documentElement || context, expression)) return(// expression is a node
found ? found.push(expression) : found = expression, found);
else // other junk
return found;
/*<pseudo-selectors>*/ /*<nth-pseudo-selectors>*/ // cache elements for the nth selectors
this.posNTH = {}, this.posNTHLast = {}, this.posNTHType = {}, this.posNTHTypeLast = {}, /*</nth-pseudo-selectors>*/ /*</pseudo-selectors>*/ // if append is null and there is only a single selector with one expression use pushArray, else use pushUID
this.push = !hasOthers && (first || 1 == parsed.length && 1 == parsed.expressions[0].length) ? this.pushArray : this.pushUID, null == found && (found = []);
var j, m, n, combinator, tag, id, classList, classes, attributes, pseudos, currentItems, currentExpression1, currentBit, lastBit, expressions = parsed.expressions;
search: for(i = 0; currentExpression1 = expressions[i]; i++)for(j = 0; currentBit = currentExpression1[j]; j++){
if (!this[combinator = "combinator:" + currentBit.combinator]) continue search;
if (tag = this.isXMLDocument ? currentBit.tag : currentBit.tag.toUpperCase(), id = currentBit.id, classList = currentBit.classList, classes = currentBit.classes, attributes = currentBit.attributes, pseudos = currentBit.pseudos, lastBit = j === currentExpression1.length - 1, this.bitUniques = {}, lastBit ? (this.uniques = uniques, this.found = found) : (this.uniques = {}, this.found = []), 0 === j) {
if (this[combinator](context, tag, id, classes, attributes, pseudos, classList), first && lastBit && found.length) break search;
} else if (first && lastBit) {
for(m = 0, n = currentItems.length; m < n; m++)if (this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList), found.length) break search;
} else for(m = 0, n = currentItems.length; m < n; m++)this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList);
currentItems = this.found;
}
return (hasOthers || parsed.expressions.length > 1) && this.sort(found), first ? found[0] || null : found;
}, // Utils
local.uidx = 1, local.uidk = "slick-uniqueid", local.getUIDXML = function(node) {
var uid = node.getAttribute(this.uidk);
return uid || (uid = this.uidx++, node.setAttribute(this.uidk, uid)), uid;
}, local.getUIDHTML = function(node) {
return node.uniqueNumber || (node.uniqueNumber = this.uidx++);
}, // sort based on the setDocument documentSorter method.
local.sort = function(results) {
return this.documentSorter && results.sort(this.documentSorter), results;
}, /*<pseudo-selectors>*/ /*<nth-pseudo-selectors>*/ local.cacheNTH = {}, local.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/, local.parseNTHArgument = function(argument) {
var parsed = argument.match(this.matchNTH);
if (!parsed) return !1;
var special = parsed[2] || !1, a = parsed[1] || 1;
"-" == a && (a = -1);
var b = +parsed[3] || 0;
return parsed = "n" == special ? {
a: a,
b: b
} : "odd" == special ? {
a: 2,
b: 1
} : "even" == special ? {
a: 2,
b: 0
} : {
a: 0,
b: a
}, this.cacheNTH[argument] = parsed;
}, local.createNTHPseudo = function(child, sibling, positions, ofType) {
return function(node, argument) {
var uid = this.getUID(node);
if (!this[positions][uid]) {
var parent = node.parentNode;
if (!parent) return !1;
var el = parent[child], count = 1;
if (ofType) {
var nodeName = node.nodeName;
do {
if (el.nodeName != nodeName) continue;
this[positions][this.getUID(el)] = count++;
}while (el = el[sibling])
} else do {
if (1 != el.nodeType) continue;
this[positions][this.getUID(el)] = count++;
}while (el = el[sibling])
}
argument = argument || "n";
var parsed = this.cacheNTH[argument] || this.parseNTHArgument(argument);
if (!parsed) return !1;
var a = parsed.a, b = parsed.b, pos = this[positions][uid];
if (0 == a) return b == pos;
if (a > 0) {
if (pos < b) return !1;
} else if (b < pos) return !1;
return (pos - b) % a == 0;
};
}, /*</nth-pseudo-selectors>*/ /*</pseudo-selectors>*/ local.pushArray = function(node, tag, id, classes, attributes, pseudos) {
this.matchSelector(node, tag, id, classes, attributes, pseudos) && this.found.push(node);
}, local.pushUID = function(node, tag, id, classes, attributes, pseudos) {
var uid = this.getUID(node);
!this.uniques[uid] && this.matchSelector(node, tag, id, classes, attributes, pseudos) && (this.uniques[uid] = !0, this.found.push(node));
}, local.matchNode = function(node, selector) {
if (this.isHTMLDocument && this.nativeMatchesSelector) try {
return this.nativeMatchesSelector.call(node, selector.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g, '[$1="$2"]'));
} catch (matchError) {}
var parsed = this.Slick.parse(selector);
if (!parsed) return !0;
// simple (single) selectors
var i, expressions = parsed.expressions, simpleExpCounter = 0;
for(i = 0; currentExpression = expressions[i]; i++)if (1 == currentExpression.length) {
var exp = currentExpression[0];
if (this.matchSelector(node, this.isXMLDocument ? exp.tag : exp.tag.toUpperCase(), exp.id, exp.classes, exp.attributes, exp.pseudos)) return !0;
simpleExpCounter++;
}
if (simpleExpCounter == parsed.length) return !1;
var item, nodes = this.search(this.document, parsed);
for(i = 0; item = nodes[i++];)if (item === node) return !0;
return !1;
}, local.matchPseudo = function(node, name, argument) {
var pseudoName = "pseudo:" + name;
if (this[pseudoName]) return this[pseudoName](node, argument);
var attribute = this.getAttribute(node, name);
return argument ? argument == attribute : !!attribute;
}, local.matchSelector = function(node, tag, id, classes, attributes, pseudos) {
if (tag) {
var i, part, cls, nodeName = this.isXMLDocument ? node.nodeName : node.nodeName.toUpperCase();
if ("*" == tag) {
if (nodeName < "@") return !1; // Fix for comment nodes and closed nodes
} else if (nodeName != tag) return !1;
}
if (id && node.getAttribute("id") != id) return !1;
if (classes) {
for(i = classes.length; i--;)if (!((cls = this.getAttribute(node, "class")) && classes[i].regexp.test(cls))) return !1;
}
if (attributes) {
for(i = attributes.length; i--;)if ((part = attributes[i]).operator ? !part.test(this.getAttribute(node, part.key)) : !this.hasAttribute(node, part.key)) return !1;
}
if (pseudos) {
for(i = pseudos.length; i--;)if (part = pseudos[i], !this.matchPseudo(node, part.key, part.value)) return !1;
}
return !0;
};
var combinators = {
" ": function(node, tag, id, classes, attributes, pseudos, classList) {
// all child nodes, any level
var i, item, children;
if (this.isHTMLDocument) {
getById: if (id) {
if (!(item = this.document.getElementById(id)) && node.all || this.idGetsName && item && item.getAttributeNode("id").nodeValue != id) {
if (!// all[id] returns all the elements with that name or id inside node
// if theres just one it will return the element, else it will be a collection
(children = node.all[id])) return;
for(children[0] || (children = [
children
]), i = 0; item = children[i++];){
var idNode = item.getAttributeNode("id");
if (idNode && idNode.nodeValue == id) {
this.push(item, tag, null, classes, attributes, pseudos);
break;
}
}
return;
}
if (item) {
if (this.document !== node && !this.contains(node, item)) return;
} else {
// if the context is in the dom we return, else we will try GEBTN, breaking the getById label
if (this.contains(this.root, node)) return;
break getById;
}
this.push(item, tag, null, classes, attributes, pseudos);
return;
}
getByClass: if (classes && node.getElementsByClassName && !this.brokenGEBCN) {
if (!((children = node.getElementsByClassName(classList.join(" "))) && children.length)) break getByClass;
for(i = 0; item = children[i++];)this.push(item, tag, id, null, attributes, pseudos);
return;
}
}
if ((children = node.getElementsByTagName(tag)) && children.length) for(this.brokenStarGEBTN || (tag = null), i = 0; item = children[i++];)this.push(item, tag, id, classes, attributes, pseudos);
},
">": function(node, tag, id, classes, attributes, pseudos) {
// direct children
if (node = node.firstChild) do 1 == node.nodeType && this.push(node, tag, id, classes, attributes, pseudos);
while (node = node.nextSibling)
},
"+": function(node, tag, id, classes, attributes, pseudos) {
// next sibling
for(; node = node.nextSibling;)if (1 == node.nodeType) {
this.push(node, tag, id, classes, attributes, pseudos);
break;
}
},
"^": function(node, tag, id, classes, attributes, pseudos) {
// first child
(node = node.firstChild) && (1 == node.nodeType ? this.push(node, tag, id, classes, attributes, pseudos) : this["combinator:+"](node, tag, id, classes, attributes, pseudos));
},
"~": function(node, tag, id, classes, attributes, pseudos) {
// next siblings
for(; node = node.nextSibling;)if (1 == node.nodeType) {
var uid = this.getUID(node);
if (this.bitUniques[uid]) break;
this.bitUniques[uid] = !0, this.push(node, tag, id, classes, attributes, pseudos);
}
},
"++": function(node, tag, id, classes, attributes, pseudos) {
// next sibling and previous sibling
this["combinator:+"](node, tag, id, classes, attributes, pseudos), this["combinator:!+"](node, tag, id, classes, attributes, pseudos);
},
"~~": function(node, tag, id, classes, attributes, pseudos) {
// next siblings and previous siblings
this["combinator:~"](node, tag, id, classes, attributes, pseudos), this["combinator:!~"](node, tag, id, classes, attributes, pseudos);
},
"!": function(node, tag, id, classes, attributes, pseudos) {
// all parent nodes up to document
for(; node = node.parentNode;)node !== this.document && this.push(node, tag, id, classes, attributes, pseudos);
},
"!>": function(node, tag, id, classes, attributes, pseudos) {
// direct parent (one level)
(node = node.parentNode) !== this.document && this.push(node, tag, id, classes, attributes, pseudos);
},
"!+": function(node, tag, id, classes, attributes, pseudos) {
// previous sibling
for(; node = node.previousSibling;)if (1 == node.nodeType) {
this.push(node, tag, id, classes, attributes, pseudos);
break;
}
},
"!^": function(node, tag, id, classes, attributes, pseudos) {
// last child
(node = node.lastChild) && (1 == node.nodeType ? this.push(node, tag, id, classes, attributes, pseudos) : this["combinator:!+"](node, tag, id, classes, attributes, pseudos));
},
"!~": function(node, tag, id, classes, attributes, pseudos) {
// previous siblings
for(; node = node.previousSibling;)if (1 == node.nodeType) {
var uid = this.getUID(node);
if (this.bitUniques[uid]) break;
this.bitUniques[uid] = !0, this.push(node, tag, id, classes, attributes, pseudos);
}
}
};
for(var c in combinators)local["combinator:" + c] = combinators[c];
var pseudos = {
/*<pseudo-selectors>*/ empty: function(node) {
var child = node.firstChild;
return !(child && 1 == child.nodeType) && !(node.innerText || node.textContent || "").length;
},
not: function(node, expression) {
return !this.matchNode(node, expression);
},
contains: function(node, text) {
return (node.innerText || node.textContent || "").indexOf(text) > -1;
},
"first-child": function(node) {
for(; node = node.previousSibling;)if (1 == node.nodeType) return !1;
return !0;
},
"last-child": function(node) {
for(; node = node.nextSibling;)if (1 == node.nodeType) return !1;
return !0;
},
"only-child": function(node) {
for(var prev = node; prev = prev.previousSibling;)if (1 == prev.nodeType) return !1;
for(var next = node; next = next.nextSibling;)if (1 == next.nodeType) return !1;
return !0;
},
/*<nth-pseudo-selectors>*/ "nth-child": local.createNTHPseudo("firstChild", "nextSibling", "posNTH"),
"nth-last-child": local.createNTHPseudo("lastChild", "previousSibling", "posNTHLast"),
"nth-of-type": local.createNTHPseudo("firstChild", "nextSibling", "posNTHType", !0),
"nth-last-of-type": local.createNTHPseudo("lastChild", "previousSibling", "posNTHTypeLast", !0),
index: function(node, index) {
return this["pseudo:nth-child"](node, "" + (index + 1));
},
even: function(node) {
return this["pseudo:nth-child"](node, "2n");
},
odd: function(node) {
return this["pseudo:nth-child"](node, "2n+1");
},
/*</nth-pseudo-selectors>*/ /*<of-type-pseudo-selectors>*/ "first-of-type": function(node) {
for(var nodeName = node.nodeName; node = node.previousSibling;)if (node.nodeName == nodeName) return !1;
return !0;
},
"last-of-type": function(node) {
for(var nodeName = node.nodeName; node = node.nextSibling;)if (node.nodeName == nodeName) return !1;
return !0;
},
"only-of-type": function(node) {
for(var prev = node, nodeName = node.nodeName; prev = prev.previousSibling;)if (prev.nodeName == nodeName) return !1;
for(var next = node; next = next.nextSibling;)if (next.nodeName == nodeName) return !1;
return !0;
},
/*</of-type-pseudo-selectors>*/ // custom pseudos
enabled: function(node) {
return !node.disabled;
},
disabled: function(node) {
return node.disabled;
},
checked: function(node) {
return node.checked || node.selected;
},
focus: function(node) {
return this.isHTMLDocument && this.document.activeElement === node && (node.href || node.type || this.hasAttribute(node, "tabindex"));
},
root: function(node) {
return node === this.root;
},
selected: function(node) {
return node.selected;
}
};
for(var p in pseudos)local["pseudo:" + p] = pseudos[p];
// attributes methods
var attributeGetters = local.attributeGetters = {
for: function() {
return "htmlFor" in this ? this.htmlFor : this.getAttribute("for");
},
href: function() {
return "href" in this ? this.getAttribute("href", 2) : this.getAttribute("href");
},
style: function() {
return this.style ? this.style.cssText : this.getAttribute("style");
},
tabindex: function() {
var attributeNode = this.getAttributeNode("tabindex");
return attributeNode && attributeNode.specified ? attributeNode.nodeValue : null;
},
type: function() {
return this.getAttribute("type");
},
maxlength: function() {
var attributeNode = this.getAttributeNode("maxLength");
return attributeNode && attributeNode.specified ? attributeNode.nodeValue : null;
}
};
attributeGetters.MAXLENGTH = attributeGetters.maxLength = attributeGetters.maxlength;
// Slick
var Slick1 = local.Slick = this.Slick || {};
Slick1.version = "1.1.7", // Slick finder
Slick1.search = function(context, expression, append) {
return local.search(context, expression, append);
}, Slick1.find = function(context, expression) {
return local.search(context, expression, null, !0);
}, // Slick containment checker
Slick1.contains = function(container, node) {
return local.setDocument(container), local.contains(container, node);
}, // Slick attribute getter
Slick1.getAttribute = function(node, name) {
return local.setDocument(node), local.getAttribute(node, name);
}, Slick1.hasAttribute = function(node, name) {
return local.setDocument(node), local.hasAttribute(node, name);
}, // Slick matcher
Slick1.match = function(node, selector) {
return !!node && !!selector && (!selector || selector === node || (local.setDocument(node), local.matchNode(node, selector)));
}, // Slick attribute accessor
Slick1.defineAttributeGetter = function(name, fn) {
return local.attributeGetters[name] = fn, this;
}, Slick1.lookupAttributeGetter = function(name) {
return local.attributeGetters[name];
}, // Slick pseudo accessor
Slick1.definePseudo = function(name, fn) {
return local["pseudo:" + name] = function(node, argument) {
return fn.call(node, argument);
}, this;
}, Slick1.lookupPseudo = function(name) {
var pseudo = local["pseudo:" + name];
return pseudo ? function(argument) {
return pseudo.call(this, argument);
} : null;
}, // Slick overrides accessor
Slick1.override = function(regexp, fn) {
return local.override(regexp, fn), this;
}, Slick1.isXML = local.isXML, Slick1.uidOf = function(node) {
return local.getUIDHTML(node);
}, this.Slick || (this.Slick = Slick1);
}).apply(/*<CommonJS>*/ "undefined" != typeof exports ? exports : /*</CommonJS>*/ this);
/*
---
name: Element
description: One of the most important items in MooTools. Contains the dollar function, the dollars function, and an handful of cross-browser, time-saver methods to let you easily work with HTML Elements.
license: MIT-style license.
requires: [Window, Document, Array, String, Function, Object, Number, Slick.Parser, Slick.Finder]
provides: [Element, Elements, $, $$, Iframe, Selectors]
...
*/ var Element = function(tag, props) {
var konstructor = Element.Constructors[tag];
if (konstructor) return konstructor(props);
if ("string" != typeof tag) return document.id(tag).set(props);
if (props || (props = {}), !/^[\w-]+$/.test(tag)) {
var parsed = Slick.parse(tag).expressions[0][0];
tag = "*" == parsed.tag ? "div" : parsed.tag, parsed.id && null == props.id && (props.id = parsed.id);
var attributes = parsed.attributes;
if (attributes) for(var attr, i = 0, l = attributes.length; i < l; i++)null != props[(attr = attributes[i]).key] || (null != attr.value && "=" == attr.operator ? props[attr.key] = attr.value : attr.value || attr.operator || (props[attr.key] = !0));
parsed.classList && null == props.class && (props.class = parsed.classList.join(" "));
}
return document.newElement(tag, props);
};
Browser.Element && (Element.prototype = Browser.Element.prototype, // IE8 and IE9 require the wrapping.
Element.prototype._fireEvent = function(fireEvent) {
return function(type, event) {
return fireEvent.call(this, type, event);
};
}(Element.prototype.fireEvent)), new Type("Element", Element).mirror(function(name) {
if (!Array.prototype[name]) {
var obj = {};
obj[name] = function() {
for(var results = [], args = arguments, elements = !0, i = 0, l = this.length; i < l; i++){
var element = this[i], result = results[i] = element[name].apply(element, args);
elements = elements && "element" == typeOf(result);
}
return elements ? new Elements(results) : results;
}, Elements.implement(obj);
}
}), Browser.Element || (Element.parent = Object, Element.Prototype = {
$constructor: Element,
$family: Function.from("element").hide()
}, Element.mirror(function(name, method) {
Element.Prototype[name] = method;
})), Element.Constructors = {}, //<1.2compat>
Element.Constructors = new Hash();
//</1.2compat>
var IFrame = new Type("IFrame", function() {
var iframe, params = Array.link(arguments, {
properties: Type.isObject,
iframe: function(obj) {
return null != obj;
}
}), props = params.properties || {};
params.iframe && (iframe = document.id(params.iframe));
var onload = props.onload || function() {};
delete props.onload, props.id = props.name = [
props.id,
props.name,
iframe ? iframe.id || iframe.name : "IFrame_" + String.uniqueID()
].pick(), iframe = new Element(iframe || "iframe", props);
var onLoad = function() {
onload.call(iframe.contentWindow);
};
return window.frames[props.id] ? onLoad() : iframe.addListener("load", onLoad), iframe;
}), Elements = this.Elements = function(nodes) {
if (nodes && nodes.length) for(var node, uniques = {}, i = 0; node = nodes[i++];){
var uid = Slick.uidOf(node);
uniques[uid] || (uniques[uid] = !0, this.push(node));
}
};
Elements.prototype = {
length: 0
}, Elements.parent = Array, new Type("Elements", Elements).implement({
filter: (function(filter, bind) {
return filter ? new Elements(Array.filter(this, "string" == typeOf(filter) ? function(item) {
return item.match(filter);
} : filter, bind)) : this;
}).protect(),
push: (function() {
for(var length = this.length, i = 0, l = arguments.length; i < l; i++){
var item = document.id(arguments[i]);
item && (this[length++] = item);
}
return this.length = length;
}).protect(),
unshift: (function() {
for(var items = [], i = 0, l = arguments.length; i < l; i++){
var item = document.id(arguments[i]);
item && items.push(item);
}
return Array.prototype.unshift.apply(this, items);
}).protect(),
concat: (function() {
for(var newElements = new Elements(this), i = 0, l = arguments.length; i < l; i++){
var item = arguments[i];
Type.isEnumerable(item) ? newElements.append(item) : newElements.push(item);
}
return newElements;
}).protect(),
append: (function(collection) {
for(var i = 0, l = collection.length; i < l; i++)this.push(collection[i]);
return this;
}).protect(),
empty: (function() {
for(; this.length;)delete this[--this.length];
return this;
}).protect()
}), //<1.2compat>
Elements.alias("extend", "append"), //</1.2compat>
function() {
// FF, IE
var createElementAcceptsHTML, splice = Array.prototype.splice, object = {
0: 0,
1: 1,
length: 2
};
splice.call(object, 1, 1), 1 == object[1] && Elements.implement("splice", (function() {
for(var length = this.length, result = splice.apply(this, arguments); length >= this.length;)delete this[length--];
return result;
}).protect()), Array.forEachMethod(function(method, name) {
Elements.implement(name, method);
}), Array.mirror(Elements);
try {
createElementAcceptsHTML = "x" == document.createElement("<input name=x>").name;
} catch (e) {}
var escapeQuotes = function(html) {
return ("" + html).replace(/&/g, "&").replace(/"/g, """);
};
/*</ltIE8>*/ Document.implement({
newElement: function(tag, props) {
/*</ltIE8>*/ return props && null != props.checked && (props.defaultChecked = props.checked), createElementAcceptsHTML && props && (tag = "<" + tag, props.name && (tag += ' name="' + escapeQuotes(props.name) + '"'), props.type && (tag += ' type="' + escapeQuotes(props.type) + '"'), tag += ">", delete props.name, delete props.type), this.id(this.createElement(tag)).set(props);
}
});
}(), function() {
Slick.uidOf(window), Slick.uidOf(document), Document.implement({
newTextNode: function(text) {
return this.createTextNode(text);
},
getDocument: function() {
return this;
},
getWindow: function() {
return this.window;
},
id: function() {
var types = {
string: function(id, nocash, doc) {
return (id = Slick.find(doc, "#" + id.replace(/(\W)/g, "\\$1"))) ? types.element(id, nocash) : null;
},
element: function(el, nocash) {
if (Slick.uidOf(el), !nocash && !el.$family && !/^(?:object|embed)$/i.test(el.tagName)) {
var fireEvent = el.fireEvent;
// wrapping needed in IE7, or else crash
el._fireEvent = function(type, event) {
return fireEvent(type, event);
}, Object.append(el, Element.Prototype);
}
return el;
},
object: function(obj, nocash, doc) {
return obj.toElement ? types.element(obj.toElement(doc), nocash) : null;
}
};
return types.textnode = types.whitespace = types.window = types.document = function(zero) {
return zero;
}, function(el, nocash, doc) {
if (el && el.$family && el.uniqueNumber) return el;
var type = typeOf(el);
return types[type] ? types[type](el, nocash, doc || document) : null;
};
}()
}), null == window.$ && Window.implement("$", function(el, nc) {
return document.id(el, nc, this.document);
}), Window.implement({
getDocument: function() {
return this.document;
},
getWindow: function() {
return this;
}
}), [
Document,
Element
].invoke("implement", {
getElements: function(expression) {
return Slick.search(this, expression, new Elements());
},
getElement: function(expression) {
return document.id(Slick.find(this, expression));
}
});
var contains = {
contains: function(element) {
return Slick.contains(this, element);
}
};
document.contains || Document.implement(contains), document.createElement("div").contains || Element.implement(contains), //<1.2compat>
Element.implement("hasChild", function(element) {
return this !== element && this.contains(element);
}), function(search, find, match) {
this.Selectors = {};
var pseudos = this.Selectors.Pseudo = new Hash(), addSlickPseudos = function() {
for(var name in pseudos)pseudos.hasOwnProperty(name) && (Slick.definePseudo(name, pseudos[name]), delete pseudos[name]);
};
Slick.search = function(context, expression, append) {
return addSlickPseudos(), search.call(this, context, expression, append);
}, Slick.find = function(context, expression) {
return addSlickPseudos(), find.call(this, context, expression);
}, Slick.match = function(node, selector) {
return addSlickPseudos(), match.call(this, node, selector);
};
}(Slick.search, Slick.find, Slick.match);
//</1.2compat>
// tree walking
var injectCombinator = function(expression, combinator) {
if (!expression) return combinator;
for(var expressions = (expression = Object.clone(Slick.parse(expression))).expressions, i = expressions.length; i--;)expressions[i][0].combinator = combinator;
return expression;
};
Object.forEach({
getNext: "~",
getPrevious: "!~",
getParent: "!"
}, function(combinator, method) {
Element.implement(method, function(expression) {
return this.getElement(injectCombinator(expression, combinator));
});
}), Object.forEach({
getAllNext: "~",
getAllPrevious: "!~",
getSiblings: "~~",
getChildren: ">",
getParents: "!"
}, function(combinator, method) {
Element.implement(method, function(expression) {
return this.getElements(injectCombinator(expression, combinator));
});
}), Element.implement({
getFirst: function(expression) {
return document.id(Slick.search(this, injectCombinator(expression, ">"))[0]);
},
getLast: function(expression) {
return document.id(Slick.search(this, injectCombinator(expression, ">")).getLast());
},
getWindow: function() {
return this.ownerDocument.window;
},
getDocument: function() {
return this.ownerDocument;
},
getElementById: function(id) {
return document.id(Slick.find(this, "#" + ("" + id).replace(/(\W)/g, "\\$1")));
},
match: function(expression) {
return !expression || Slick.match(this, expression);
}
}), null == window.$$ && Window.implement("$$", function(selector) {
var elements = new Elements();
if (1 == arguments.length && "string" == typeof selector) return Slick.search(this.document, selector, elements);
for(var args = Array.flatten(arguments), i = 0, l = args.length; i < l; i++){
var item = args[i];
switch(typeOf(item)){
case "element":
elements.push(item);
break;
case "string":
Slick.search(this.document, item, elements);
}
}
return elements;
}), null == window.$$ && Window.implement("$$", function(selector) {
if (1 == arguments.length) {
if ("string" == typeof selector) return Slick.search(this.document, selector, new Elements());
if (Type.isEnumerable(selector)) return new Elements(selector);
}
return new Elements(arguments);
});
// Inserters
var inserters = {
before: function(context, element) {
var parent = element.parentNode;
parent && parent.insertBefore(context, element);
},
after: function(context, element) {
var parent = element.parentNode;
parent && parent.insertBefore(context, element.nextSibling);
},
bottom: function(context, element) {
element.appendChild(context);
},
top: function(context, element) {
element.insertBefore(context, element.firstChild);
}
};
inserters.inside = inserters.bottom, //<1.2compat>
Object.each(inserters, function(inserter, where) {
where = where.capitalize();
var methods = {};
methods["inject" + where] = function(el) {
return inserter(this, document.id(el, !0)), this;
}, methods["grab" + where] = function(el) {
return inserter(document.id(el, !0), this), this;
}, Element.implement(methods);
});
//</1.2compat>
// getProperty / setProperty
var propertyGetters = {}, propertySetters = {}, properties = {};
Array.forEach([
"type",
"value",
"defaultValue",
"accessKey",
"cellPadding",
"cellSpacing",
"colSpan",
"frameBorder",
"rowSpan",
"tabIndex",
"useMap"
], function(property) {
properties[property.toLowerCase()] = property;
}), properties.html = "innerHTML", properties.text = null == document.createElement("div").textContent ? "innerText" : "textContent", Object.forEach(properties, function(real, key) {
propertySetters[key] = function(node, value) {
node[real] = value;
}, propertyGetters[key] = function(node) {
return node[real];
};
});
var booleans = {};
Array.forEach([
"compact",
"nowrap",
"ismap",
"declare",
"noshade",
"checked",
"disabled",
"readOnly",
"multiple",
"selected",
"noresize",
"defer",
"defaultChecked",
"autofocus",
"controls",
"autoplay",
"loop"
], function(bool) {
var lower = bool.toLowerCase();
booleans[lower] = bool, propertySetters[lower] = function(node, value) {
node[bool] = !!value;
}, propertyGetters[lower] = function(node) {
return !!node[bool];
};
}), // Special cases
Object.append(propertySetters, {
class: function(node, value) {
"className" in node ? node.className = value || "" : node.setAttribute("class", value);
},
for: function(node, value) {
"htmlFor" in node ? node.htmlFor = value : node.setAttribute("for", value);
},
style: function(node, value) {
node.style ? node.style.cssText = value : node.setAttribute("style", value);
},
value: function(node, value) {
node.value = null != value ? value : "";
}
}), propertyGetters.class = function(node) {
return "className" in node ? node.className || null : node.getAttribute("class");
};
/* <webkit> */ var el = document.createElement("button");
// IE sets type as readonly and throws
try {
el.type = "button";
} catch (e) {}
"button" != el.type && (propertySetters.type = function(node, value) {
node.setAttribute("type", value);
}), el = null;
/* </webkit> */ /*<IE>*/ var input = document.createElement("input");
input.value = "t", input.type = "submit", "t" != input.value && (propertySetters.type = function(node, type) {
var value = node.value;
node.type = type, node.value = value;
}), input = null;
/*</IE>*/ /* getProperty, setProperty */ /* <ltIE9> */ var pollutesGetAttribute = function(div) {
return div.random = "attribute", "attribute" == div.getAttribute("random");
}(document.createElement("div"));
/* <ltIE9> */ Element.implement({
setProperty: function(name, value) {
var setter = propertySetters[name.toLowerCase()];
if (setter) setter(this, value);
else {
/* <ltIE9> */ if (pollutesGetAttribute) var attributeWhiteList = this.retrieve("$attributeWhiteList", {});
/* </ltIE9> */ null == value ? (this.removeAttribute(name), pollutesGetAttribute && delete attributeWhiteList[name]) : (this.setAttribute(name, "" + value), pollutesGetAttribute && (attributeWhiteList[name] = !0));
}
return this;
},
setProperties: function(attributes) {
for(var attribute in attributes)this.setProperty(attribute, attributes[attribute]);
return this;
},
getProperty: function(name) {
var getter = propertyGetters[name.toLowerCase()];
if (getter) return getter(this);
/* <ltIE9> */ if (pollutesGetAttribute) {
var attr = this.getAttributeNode(name), attributeWhiteList = this.retrieve("$attributeWhiteList", {});
if (!attr) return null;
if (attr.expando && !attributeWhiteList[name]) {
var outer = this.outerHTML;
// segment by the opening tag and find mention of attribute name
if (0 > outer.substr(0, outer.search(/\/?['"]?>(?![^<]*<['"])/)).indexOf(name)) return null;
attributeWhiteList[name] = !0;
}
}
/* </ltIE9> */ var result = Slick.getAttribute(this, name);
return result || Slick.hasAttribute(this, name) ? result : null;
},
getProperties: function() {
var args = Array.from(arguments);
return args.map(this.getProperty, this).associate(args);
},
removeProperty: function(name) {
return this.setProperty(name, null);
},
removeProperties: function() {
return Array.each(arguments, this.removeProperty, this), this;
},
set: (function(prop, value) {
var property = Element.Properties[prop];
property && property.set ? property.set.call(this, value) : this.setProperty(prop, value);
}).overloadSetter(),
get: (function(prop) {
var property = Element.Properties[prop];
return property && property.get ? property.get.apply(this) : this.getProperty(prop);
}).overloadGetter(),
erase: function(prop) {
var property = Element.Properties[prop];
return property && property.erase ? property.erase.apply(this) : this.removeProperty(prop), this;
},
hasClass: function(className1) {
return this.className.clean().contains(className1, " ");
},
addClass: function(className1) {
return this.hasClass(className1) || (this.className = (this.className + " " + className1).clean()), this;
},
removeClass: function(className1) {
return this.className = this.className.replace(RegExp("(^|\\s)" + className1 + "(?:\\s|$)"), "$1"), this;
},
toggleClass: function(className1, force) {
return null == force && (force = !this.hasClass(className1)), force ? this.addClass(className1) : this.removeClass(className1);
},
adopt: function() {
var fragment, parent = this, elements = Array.flatten(arguments), length = elements.length;
length > 1 && (parent = fragment = document.createDocumentFragment());
for(var i = 0; i < length; i++){
var element = document.id(elements[i], !0);
element && parent.appendChild(element);
}
return fragment && this.appendChild(fragment), this;
},
appendText: function(text, where) {
return this.grab(this.getDocument().newTextNode(text), where);
},
grab: function(el, where) {
return inserters[where || "bottom"](document.id(el, !0), this), this;
},
inject: function(el, where) {
return inserters[where || "bottom"](this, document.id(el, !0)), this;
},
replaces: function(el) {
return (el = document.id(el, !0)).parentNode.replaceChild(this, el), this;
},
wraps: function(el, where) {
return el = document.id(el, !0), this.replaces(el).grab(el, where);
},
getSelected: function() {
return this.selectedIndex, new Elements(Array.from(this.options).filter(function(option) {
return option.selected;
}));
},
toQueryString: function() {
var queryString = [];
return this.getElements("input, select, textarea").each(function(el) {
var type = el.type;
if (el.name && !el.disabled && "submit" != type && "reset" != type && "file" != type && "image" != type) {
var value = "select" == el.get("tag") ? el.getSelected().map(function(opt) {
// IE
return document.id(opt).get("value");
}) : "radio" != type && "checkbox" != type || el.checked ? el.get("value") : null;
Array.from(value).each(function(val) {
void 0 !== val && queryString.push(encodeURIComponent(el.name) + "=" + encodeURIComponent(val));
});
}
}), queryString.join("&");
}
});
var collected = {}, storage = {}, get = function(uid) {
return storage[uid] || (storage[uid] = {});
}, clean = function(item) {
var uid = item.uniqueNumber;
return item.removeEvents && item.removeEvents(), item.clearAttributes && item.clearAttributes(), null != uid && (delete collected[uid], delete storage[uid]), item;
}, formProps = {
input: "checked",
option: "selected",
textarea: "value"
};
Element.implement({
destroy: function() {
return Array.each(clean(this).getElementsByTagName("*"), clean), Element.dispose(this), null;
},
empty: function() {
return Array.from(this.childNodes).each(Element.dispose), this;
},
dispose: function() {
return this.parentNode ? this.parentNode.removeChild(this) : this;
},
clone: function(contents, keepid) {
contents = !1 !== contents;
var i, clone = this.cloneNode(contents), ce = [
clone
], te = [
this
];
for(contents && (ce.append(Array.from(clone.getElementsByTagName("*"))), te.append(Array.from(this.getElementsByTagName("*")))), i = ce.length; i--;){
var node = ce[i], element = te[i];
/*<ltIE9>*/ if (keepid || node.removeAttribute("id"), node.clearAttributes && (node.clearAttributes(), node.mergeAttributes(element), node.removeAttribute("uniqueNumber"), node.options)) for(var no = node.options, eo = element.options, j = no.length; j--;)no[j].selected = eo[j].selected;
/*</ltIE9>*/ var prop = formProps[element.tagName.toLowerCase()];
prop && element[prop] && (node[prop] = element[prop]);
}
/*<ltIE9>*/ if (Browser.ie) {
var co = clone.getElementsByTagName("object"), to = this.getElementsByTagName("object");
for(i = co.length; i--;)co[i].outerHTML = to[i].outerHTML;
}
/*</ltIE9>*/ return document.id(clone);
}
}), [
Element,
Window,
Document
].invoke("implement", {
addListener: function(type, fn) {
if ("unload" == type) {
var old = fn, self = this;
fn = function() {
self.removeListener("unload", fn), old();
};
} else collected[Slick.uidOf(this)] = this;
return this.addEventListener ? this.addEventListener(type, fn, !!arguments[2]) : this.attachEvent("on" + type, fn), this;
},
removeListener: function(type, fn) {
return this.removeEventListener ? this.removeEventListener(type, fn, !!arguments[2]) : this.detachEvent("on" + type, fn), this;
},
retrieve: function(property, dflt) {
var storage = get(Slick.uidOf(this)), prop = storage[property];
return null != dflt && null == prop && (prop = storage[property] = dflt), null != prop ? prop : null;
},
store: function(property, value) {
return get(Slick.uidOf(this))[property] = value, this;
},
eliminate: function(property) {
var storage = get(Slick.uidOf(this));
return delete storage[property], this;
}
}), window.attachEvent && !window.addEventListener && window.addListener("unload", function() {
Object.each(collected, clean), window.CollectGarbage && CollectGarbage();
}), /*</ltIE9>*/ Element.Properties = {}, //<1.2compat>
Element.Properties = new Hash(), //</1.2compat>
Element.Properties.style = {
set: function(style) {
this.style.cssText = style;
},
get: function() {
return this.style.cssText;
},
erase: function() {
this.style.cssText = "";
}
}, Element.Properties.tag = {
get: function() {
return this.tagName.toLowerCase();
}
}, Element.Properties.html = {
set: function(html) {
null == html ? html = "" : "array" == typeOf(html) && (html = html.join("")), this.innerHTML = html;
},
erase: function() {
this.innerHTML = "";
}
};
/*<ltIE9>*/ // technique by jdbarlett - http://jdbartlett.com/innershiv/
var div = document.createElement("div");
div.innerHTML = "<nav></nav>";
var supportsHTML5Elements = 1 == div.childNodes.length;
if (!supportsHTML5Elements) for(var tags = "abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video".split(" "), fragment = document.createDocumentFragment(), l = tags.length; l--;)fragment.createElement(tags[l]);
div = null;
/*</ltIE9>*/ /*<IE>*/ var supportsTableInnerHTML = Function.attempt(function() {
return document.createElement("table").innerHTML = "<tr><td></td></tr>", !0;
}), tr = document.createElement("tr"), html = "<td></td>";
tr.innerHTML = html;
var supportsTRInnerHTML = tr.innerHTML == html;
tr = null, supportsTableInnerHTML && supportsTRInnerHTML && supportsHTML5Elements || (Element.Properties.html.set = function(set) {
var translations = {
table: [
1,
"<table>",
"</table>"
],
select: [
1,
"<select>",
"</select>"
],
tbody: [
2,
"<table><tbody>",
"</tbody></table>"
],
tr: [
3,
"<table><tbody><tr>",
"</tr></tbody></table>"
]
};
return translations.thead = translations.tfoot = translations.tbody, function(html) {
var wrap = translations[this.get("tag")];
if (wrap || supportsHTML5Elements || (wrap = [
0,
"",
""
]), !wrap) return set.call(this, html);
var level = wrap[0], wrapper = document.createElement("div"), target = wrapper;
for(supportsHTML5Elements || fragment.appendChild(wrapper), wrapper.innerHTML = [
wrap[1],
html,
wrap[2]
].flatten().join(""); level--;)target = target.firstChild;
this.empty().adopt(target.childNodes), supportsHTML5Elements || fragment.removeChild(wrapper);
};
}(Element.Properties.html.set));
/*</IE>*/ /*<ltIE9>*/ var testForm = document.createElement("form");
testForm.innerHTML = "<select><option>s</option></select>", "s" != testForm.firstChild.value && (Element.Properties.value = {
set: function(value) {
if ("select" != this.get("tag")) return this.setProperty("value", value);
for(var options = this.getElements("option"), i = 0; i < options.length; i++){
var option = options[i], attr = option.getAttributeNode("value");
if ((attr && attr.specified ? option.value : option.get("text")) == value) return option.selected = !0;
}
},
get: function() {
var option = this, tag = option.get("tag");
if ("select" != tag && "option" != tag) return this.getProperty("value");
if ("select" == tag && !(option = option.getSelected()[0])) return "";
var attr = option.getAttributeNode("value");
return attr && attr.specified ? option.value : option.get("text");
}
}), testForm = null, document.createElement("div").getAttributeNode("id") && (Element.Properties.id = {
set: function(id) {
this.id = this.getAttributeNode("id").value = id;
},
get: function() {
return this.id || null;
},
erase: function() {
this.id = this.getAttributeNode("id").value = "";
}
});
/*</IE>*/ }(), /*
---
name: Element.Style
description: Contains methods for interacting with the styles of Elements in a fashionable way.
license: MIT-style license.
requires: Element
provides: Element.Style
...
*/ function() {
var html = document.html, el = document.createElement("div");
el.style.color = "red", el.style.color = null;
var doesNotRemoveStyles = "red" == el.style.color;
el = null, //</ltIE9>
Element.Properties.styles = {
set: function(styles) {
this.setStyles(styles);
}
};
var hasOpacity = null != html.style.opacity, hasFilter = null != html.style.filter, reAlpha = /alpha\(opacity=([\d.]+)\)/i, setVisibility = function(element, opacity) {
element.store("$opacity", opacity), element.style.visibility = opacity > 0 || null == opacity ? "visible" : "hidden";
}, setOpacity = hasOpacity ? function(element, opacity) {
element.style.opacity = opacity;
} : hasFilter ? function(element, opacity) {
var style = element.style;
element.currentStyle && element.currentStyle.hasLayout || (style.zoom = 1), opacity = null == opacity || 1 == opacity ? "" : "alpha(opacity=" + (100 * opacity).limit(0, 100).round() + ")";
var filter = style.filter || element.getComputedStyle("filter") || "";
style.filter = reAlpha.test(filter) ? filter.replace(reAlpha, opacity) : filter + opacity, style.filter || style.removeAttribute("filter");
} : setVisibility, getOpacity = hasOpacity ? function(element) {
var opacity = element.style.opacity || element.getComputedStyle("opacity");
return "" == opacity ? 1 : opacity.toFloat();
} : hasFilter ? function(element) {
var opacity, filter = element.style.filter || element.getComputedStyle("filter");
return filter && (opacity = filter.match(reAlpha)), null == opacity || null == filter ? 1 : opacity[1] / 100;
} : function(element) {
var opacity = element.retrieve("$opacity");
return null == opacity && (opacity = +("hidden" != element.style.visibility)), opacity;
}, floatName = null == html.style.cssFloat ? "styleFloat" : "cssFloat";
Element.implement({
getComputedStyle: function(property) {
if (this.currentStyle) return this.currentStyle[property.camelCase()];
var defaultView = Element.getDocument(this).defaultView, computed = defaultView ? defaultView.getComputedStyle(this, null) : null;
return computed ? computed.getPropertyValue(property == floatName ? "float" : property.hyphenate()) : null;
},
setStyle: function(property, value) {
if ("opacity" == property) return null != value && (value = parseFloat(value)), setOpacity(this, value), this;
if (property = ("float" == property ? floatName : property).camelCase(), "string" != typeOf(value)) {
var map = (Element.Styles[property] || "@").split(" ");
value = Array.from(value).map(function(val, i) {
return map[i] ? "number" == typeOf(val) ? map[i].replace("@", Math.round(val)) : val : "";
}).join(" ");
} else value == String(Number(value)) && (value = Math.round(value));
//</ltIE9>
return this.style[property] = value, ("" == value || null == value) && doesNotRemoveStyles && this.style.removeAttribute && this.style.removeAttribute(property), this;
},
getStyle: function(property) {
if ("opacity" == property) return getOpacity(this);
property = ("float" == property ? floatName : property).camelCase();
var result = this.style[property];
if (!result || "zIndex" == property) {
for(var style in result = [], Element.ShortStyles)if (property == style) {
for(var s in Element.ShortStyles[style])result.push(this.getStyle(s));
return result.join(" ");
}
result = this.getComputedStyle(property);
}
if (result) {
var color = (result = String(result)).match(/rgba?\([\d\s,]+\)/);
color && (result = result.replace(color[0], color[0].rgbToHex()));
}
if (Browser.opera || Browser.ie) {
if (/^(height|width)$/.test(property) && !/px$/.test(result)) {
var size = 0;
return ("width" == property ? [
"left",
"right"
] : [
"top",
"bottom"
]).each(function(value) {
size += this.getStyle("border-" + value + "-width").toInt() + this.getStyle("padding-" + value).toInt();
}, this), this["offset" + property.capitalize()] - size + "px";
}
if (Browser.ie && /^border(.+)Width|margin|padding/.test(property) && isNaN(parseFloat(result))) return "0px";
}
return result;
},
setStyles: function(styles) {
for(var style in styles)this.setStyle(style, styles[style]);
return this;
},
getStyles: function() {
var result = {};
return Array.flatten(arguments).each(function(key) {
result[key] = this.getStyle(key);
}, this), result;
}
}), Element.Styles = {
left: "@px",
top: "@px",
bottom: "@px",
right: "@px",
width: "@px",
height: "@px",
maxWidth: "@px",
maxHeight: "@px",
minWidth: "@px",
minHeight: "@px",
backgroundColor: "rgb(@, @, @)",
backgroundPosition: "@px @px",
color: "rgb(@, @, @)",
fontSize: "@px",
letterSpacing: "@px",
lineHeight: "@px",
clip: "rect(@px @px @px @px)",
margin: "@px @px @px @px",
padding: "@px @px @px @px",
border: "@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)",
borderWidth: "@px @px @px @px",
borderStyle: "@ @ @ @",
borderColor: "rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)",
zIndex: "@",
zoom: "@",
fontWeight: "@",
textIndent: "@px",
opacity: "@"
}, //<1.3compat>
Element.implement({
setOpacity: function(value) {
return setOpacity(this, value), this;
},
getOpacity: function() {
return getOpacity(this);
}
}), Element.Properties.opacity = {
set: function(opacity) {
setOpacity(this, opacity), setVisibility(this, opacity);
},
get: function() {
return getOpacity(this);
}
}, //</1.3compat>
//<1.2compat>
Element.Styles = new Hash(Element.Styles), //</1.2compat>
Element.ShortStyles = {
margin: {},
padding: {},
border: {},
borderWidth: {},
borderStyle: {},
borderColor: {}
}, [
"Top",
"Right",
"Bottom",
"Left"
].each(function(direction) {
var Short = Element.ShortStyles, All = Element.Styles;
[
"margin",
"padding"
].each(function(style) {
var sd = style + direction;
Short[style][sd] = All[sd] = "@px";
});
var bd = "border" + direction;
Short.border[bd] = All[bd] = "@px @ rgb(@, @, @)";
var bdw = bd + "Width", bds = bd + "Style", bdc = bd + "Color";
Short[bd] = {}, Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = "@px", Short.borderStyle[bds] = Short[bd][bds] = All[bds] = "@", Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = "rgb(@, @, @)";
});
}(), /*
---
name: Element.Event
description: Contains Element methods for dealing with events. This file also includes mouseenter and mouseleave custom Element Events, if necessary.
license: MIT-style license.
requires: [Element, Event]
provides: Element.Event
...
*/ function() {
if (Element.Properties.events = {
set: function(events) {
this.addEvents(events);
}
}, [
Element,
Window,
Document
].invoke("implement", {
addEvent: function(type, fn) {
var events = this.retrieve("events", {});
if (events[type] || (events[type] = {
keys: [],
values: []
}), events[type].keys.contains(fn)) return this;
events[type].keys.push(fn);
var realType = type, custom = Element.Events[type], condition = fn, self = this;
custom && (custom.onAdd && custom.onAdd.call(this, fn, type), custom.condition && (condition = function(event) {
return !custom.condition.call(this, event, type) || fn.call(this, event);
}), custom.base && (realType = Function.from(custom.base).call(this, type)));
var defn = function() {
return fn.call(self);
}, nativeEvent = Element.NativeEvents[realType];
return nativeEvent && (2 == nativeEvent && (defn = function(event) {
event = new DOMEvent(event, self.getWindow()), !1 === condition.call(self, event) && event.stop();
}), this.addListener(realType, defn, arguments[2])), events[type].values.push(defn), this;
},
removeEvent: function(type, fn) {
var events = this.retrieve("events");
if (!events || !events[type]) return this;
var list = events[type], index = list.keys.indexOf(fn);
if (-1 == index) return this;
var value = list.values[index];
delete list.keys[index], delete list.values[index];
var custom = Element.Events[type];
return custom && (custom.onRemove && custom.onRemove.call(this, fn, type), custom.base && (type = Function.from(custom.base).call(this, type))), Element.NativeEvents[type] ? this.removeListener(type, value, arguments[2]) : this;
},
addEvents: function(events) {
for(var event in events)this.addEvent(event, events[event]);
return this;
},
removeEvents: function(events) {
if ("object" == typeOf(events)) {
for(type in events)this.removeEvent(type, events[type]);
return this;
}
var type, attached = this.retrieve("events");
if (!attached) return this;
if (events) attached[events] && (attached[events].keys.each(function(fn) {
this.removeEvent(events, fn);
}, this), delete attached[events]);
else {
for(type in attached)this.removeEvents(type);
this.eliminate("events");
}
return this;
},
fireEvent: function(type, args, delay) {
var events = this.retrieve("events");
return events && events[type] && (args = Array.from(args), events[type].keys.each(function(fn) {
delay ? fn.delay(delay, this, args) : fn.apply(this, args);
}, this)), this;
},
cloneEvents: function(from, type) {
var events = (from = document.id(from)).retrieve("events");
if (!events) return this;
if (type) events[type] && events[type].keys.each(function(fn) {
this.addEvent(type, fn);
}, this);
else for(var eventType in events)this.cloneEvents(from, eventType);
return this;
}
}), Element.NativeEvents = {
click: 2,
dblclick: 2,
mouseup: 2,
mousedown: 2,
contextmenu: 2,
mousewheel: 2,
DOMMouseScroll: 2,
mouseover: 2,
mouseout: 2,
mousemove: 2,
selectstart: 2,
selectend: 2,
keydown: 2,
keypress: 2,
keyup: 2,
orientationchange: 2,
touchstart: 2,
touchmove: 2,
touchend: 2,
touchcancel: 2,
gesturestart: 2,
gesturechange: 2,
gestureend: 2,
focus: 2,
blur: 2,
change: 2,
reset: 2,
select: 2,
submit: 2,
paste: 2,
input: 2,
load: 2,
unload: 1,
beforeunload: 2,
resize: 1,
move: 1,
DOMContentLoaded: 1,
readystatechange: 1,
error: 1,
abort: 1,
scroll: 1
}, Element.Events = {
mousewheel: {
base: Browser.firefox ? "DOMMouseScroll" : "mousewheel"
}
}, "onmouseenter" in document.documentElement) Element.NativeEvents.mouseenter = Element.NativeEvents.mouseleave = 2;
else {
var check = function(event) {
var related = event.relatedTarget;
return null == related || !!related && related != this && "xul" != related.prefix && "document" != typeOf(this) && !this.contains(related);
};
Element.Events.mouseenter = {
base: "mouseover",
condition: check
}, Element.Events.mouseleave = {
base: "mouseout",
condition: check
};
}
window.addEventListener || (Element.NativeEvents.propertychange = 2, Element.Events.change = {
base: function() {
var type = this.type;
return "input" == this.get("tag") && ("radio" == type || "checkbox" == type) ? "propertychange" : "change";
},
condition: function(event) {
return "radio" != this.type || "checked" == event.event.propertyName && this.checked;
}
}), /*</ltIE9>*/ //<1.2compat>
Element.Events = new Hash(Element.Events);
//</1.2compat>
}(), /*
---
name: Element.Delegation
description: Extends the Element native object to include the delegate method for more efficient event management.
license: MIT-style license.
requires: [Element.Event]
provides: [Element.Delegation]
...
*/ function() {
var eventListenerSupport = !!window.addEventListener;
Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;
var bubbleUp = function(self, match, fn, event, target) {
for(; target && target != self;){
if (match(target, event)) return fn.call(target, event, target);
target = document.id(target.parentNode);
}
}, map = {
mouseenter: {
base: "mouseover"
},
mouseleave: {
base: "mouseout"
},
focus: {
base: "focus" + (eventListenerSupport ? "" : "in"),
capture: !0
},
blur: {
base: eventListenerSupport ? "blur" : "focusout",
capture: !0
}
}, _key = "$delegation:", formObserver = function(type) {
return {
base: "focusin",
remove: function(self, uid) {
var list = self.retrieve(_key + type + "listeners", {})[uid];
if (list && list.forms) for(var i = list.forms.length; i--;)list.forms[i].removeEvent(type, list.fns[i]);
},
listen: function(self, match, fn, event, target, uid) {
var form = "form" == target.get("tag") ? target : event.target.getParent("form");
if (form) {
var listeners = self.retrieve(_key + type + "listeners", {}), listener = listeners[uid] || {
forms: [],
fns: []
}, forms = listener.forms, fns = listener.fns;
if (-1 == forms.indexOf(form)) {
forms.push(form);
var _fn = function(event) {
bubbleUp(self, match, fn, event, target);
};
form.addEvent(type, _fn), fns.push(_fn), listeners[uid] = listener, self.store(_key + type + "listeners", listeners);
}
}
}
};
}, inputObserver = function(type) {
return {
base: "focusin",
listen: function(self, match, fn, event, target) {
var events = {
blur: function() {
this.removeEvents(events);
}
};
events[type] = function(event) {
bubbleUp(self, match, fn, event, target);
}, event.target.addEvents(events);
}
};
};
eventListenerSupport || Object.append(map, {
submit: formObserver("submit"),
reset: formObserver("reset"),
change: inputObserver("change"),
select: inputObserver("select")
});
/*</ltIE9>*/ var proto = Element.prototype, addEvent = proto.addEvent, removeEvent = proto.removeEvent, relay = function(old, method) {
return function(type, fn, useCapture) {
if (-1 == type.indexOf(":relay")) return old.call(this, type, fn, useCapture);
var parsed = Slick.parse(type).expressions[0][0];
if ("relay" != parsed.pseudos[0].key) return old.call(this, type, fn, useCapture);
var newType = parsed.tag;
return parsed.pseudos.slice(1).each(function(pseudo) {
newType += ":" + pseudo.key + (pseudo.value ? "(" + pseudo.value + ")" : "");
}), old.call(this, type, fn), method.call(this, newType, parsed.pseudos[0].value, fn);
};
}, delegation = {
addEvent: function(type, match, fn) {
var storage = this.retrieve("$delegates", {}), stored = storage[type];
if (stored) {
for(var _uid in stored)if (stored[_uid].fn == fn && stored[_uid].match == match) return this;
}
var _type = type, _match = match, _fn = fn, _map = map[type] || {};
type = _map.base || _type, match = function(target) {
return Slick.match(target, _match);
};
var elementEvent = Element.Events[_type];
if (elementEvent && elementEvent.condition) {
var __match = match, condition = elementEvent.condition;
match = function(target, event) {
return __match(target, event) && condition.call(target, event, type);
};
}
var self = this, uid = String.uniqueID(), delegator = _map.listen ? function(event, target) {
!target && event && event.target && (target = event.target), target && _map.listen(self, match, fn, event, target, uid);
} : function(event, target) {
!target && event && event.target && (target = event.target), target && bubbleUp(self, match, fn, event, target);
};
return stored || (stored = {}), stored[uid] = {
match: _match,
fn: _fn,
delegator: delegator
}, storage[_type] = stored, addEvent.call(this, type, delegator, _map.capture);
},
removeEvent: function(type, match, fn, _uid) {
var __uid, s, storage = this.retrieve("$delegates", {}), stored = storage[type];
if (!stored) return this;
if (_uid) {
var _type = type, delegator = stored[_uid].delegator, _map = map[type] || {};
return type = _map.base || _type, _map.remove && _map.remove(this, _uid), delete stored[_uid], storage[_type] = stored, removeEvent.call(this, type, delegator);
}
if (fn) {
for(__uid in stored)if ((s = stored[__uid]).match == match && s.fn == fn) return delegation.removeEvent.call(this, type, match, fn, __uid);
} else for(__uid in stored)(s = stored[__uid]).match == match && delegation.removeEvent.call(this, type, match, s.fn, __uid);
return this;
}
};
[
Element,
Window,
Document
].invoke("implement", {
addEvent: relay(addEvent, delegation.addEvent),
removeEvent: relay(removeEvent, delegation.removeEvent)
});
}(), /*
---
name: Element.Dimensions
description: Contains methods to work with size, scroll, or positioning of Elements and the window object.
license: MIT-style license.
credits:
- Element positioning based on the [qooxdoo](http://qooxdoo.org/) code and smart browser fixes, [LGPL License](http://www.gnu.org/licenses/lgpl.html).
- Viewport dimensions based on [YUI](http://developer.yahoo.com/yui/) code, [BSD License](http://developer.yahoo.com/yui/license.html).
requires: [Element, Element.Style]
provides: [Element.Dimensions]
...
*/ function() {
var element = document.createElement("div"), child = document.createElement("div");
element.style.height = "0", element.appendChild(child);
var brokenOffsetParent = child.offsetParent === element;
element = child = null;
var isOffset = function(el) {
return "static" != styleString(el, "position") || isBody(el);
}, isOffsetStatic = function(el) {
return isOffset(el) || /^(?:table|td|th)$/i.test(el.tagName);
};
Element.implement({
scrollTo: function(x, y) {
return isBody(this) ? this.getWindow().scrollTo(x, y) : (this.scrollLeft = x, this.scrollTop = y), this;
},
getSize: function() {
return isBody(this) ? this.getWindow().getSize() : {
x: this.offsetWidth,
y: this.offsetHeight
};
},
getScrollSize: function() {
return isBody(this) ? this.getWindow().getScrollSize() : {
x: this.scrollWidth,
y: this.scrollHeight
};
},
getScroll: function() {
return isBody(this) ? this.getWindow().getScroll() : {
x: this.scrollLeft,
y: this.scrollTop
};
},
getScrolls: function() {
for(var element = this.parentNode, position = {
x: 0,
y: 0
}; element && !isBody(element);)position.x += element.scrollLeft, position.y += element.scrollTop, element = element.parentNode;
return position;
},
getOffsetParent: brokenOffsetParent ? function() {
var element = this;
if (isBody(element) || "fixed" == styleString(element, "position")) return null;
for(var isOffsetCheck = "static" == styleString(element, "position") ? isOffsetStatic : isOffset; element = element.parentNode;)if (isOffsetCheck(element)) return element;
return null;
} : function() {
var element = this;
if (isBody(element) || "fixed" == styleString(element, "position")) return null;
try {
return element.offsetParent;
} catch (e) {}
return null;
},
getOffsets: function() {
if (this.getBoundingClientRect && !Browser.Platform.ios) {
var bound = this.getBoundingClientRect(), html = document.id(this.getDocument().documentElement), htmlScroll = html.getScroll(), elemScrolls = this.getScrolls(), isFixed = "fixed" == styleString(this, "position");
return {
x: bound.left.toInt() + elemScrolls.x + (isFixed ? 0 : htmlScroll.x) - html.clientLeft,
y: bound.top.toInt() + elemScrolls.y + (isFixed ? 0 : htmlScroll.y) - html.clientTop
};
}
var element = this, position = {
x: 0,
y: 0
};
if (isBody(this)) return position;
for(; element && !isBody(element);){
if (position.x += element.offsetLeft, position.y += element.offsetTop, Browser.firefox) {
borderBox(element) || (position.x += leftBorder(element), position.y += topBorder(element));
var parent = element.parentNode;
parent && "visible" != styleString(parent, "overflow") && (position.x += leftBorder(parent), position.y += topBorder(parent));
} else element != this && Browser.safari && (position.x += leftBorder(element), position.y += topBorder(element));
element = element.offsetParent;
}
return Browser.firefox && !borderBox(this) && (position.x -= leftBorder(this), position.y -= topBorder(this)), position;
},
getPosition: function(relative) {
var offset = this.getOffsets(), scroll = this.getScrolls(), position = {
x: offset.x - scroll.x,
y: offset.y - scroll.y
};
if (relative && (relative = document.id(relative))) {
var relativePosition = relative.getPosition();
return {
x: position.x - relativePosition.x - leftBorder(relative),
y: position.y - relativePosition.y - topBorder(relative)
};
}
return position;
},
getCoordinates: function(element) {
if (isBody(this)) return this.getWindow().getCoordinates();
var position = this.getPosition(element), size = this.getSize(), obj = {
left: position.x,
top: position.y,
width: size.x,
height: size.y
};
return obj.right = obj.left + obj.width, obj.bottom = obj.top + obj.height, obj;
},
computePosition: function(obj) {
return {
left: obj.x - styleNumber(this, "margin-left"),
top: obj.y - styleNumber(this, "margin-top")
};
},
setPosition: function(obj) {
return this.setStyles(this.computePosition(obj));
}
}), [
Document,
Window
].invoke("implement", {
getSize: function() {
var doc = getCompatElement(this);
return {
x: doc.clientWidth,
y: doc.clientHeight
};
},
getScroll: function() {
var win = this.getWindow(), doc = getCompatElement(this);
return {
x: win.pageXOffset || doc.scrollLeft,
y: win.pageYOffset || doc.scrollTop
};
},
getScrollSize: function() {
var doc = getCompatElement(this), min = this.getSize(), body = this.getDocument().body;
return {
x: Math.max(doc.scrollWidth, body.scrollWidth, min.x),
y: Math.max(doc.scrollHeight, body.scrollHeight, min.y)
};
},
getPosition: function() {
return {
x: 0,
y: 0
};
},
getCoordinates: function() {
var size = this.getSize();
return {
top: 0,
left: 0,
bottom: size.y,
right: size.x,
height: size.y,
width: size.x
};
}
});
// private methods
var styleString = Element.getComputedStyle;
function styleNumber(element, style) {
return styleString(element, style).toInt() || 0;
}
function borderBox(element) {
return "border-box" == styleString(element, "-moz-box-sizing");
}
function topBorder(element) {
return styleNumber(element, "border-top-width");
}
function leftBorder(element) {
return styleNumber(element, "border-left-width");
}
function isBody(element) {
return /^(?:body|html)$/i.test(element.tagName);
}
function getCompatElement(element) {
var doc = element.getDocument();
return doc.compatMode && "CSS1Compat" != doc.compatMode ? doc.body : doc.html;
}
}(), //aliases
Element.alias({
position: "setPosition"
}), [
Window,
Document,
Element
].invoke("implement", {
getHeight: function() {
return this.getSize().y;
},
getWidth: function() {
return this.getSize().x;
},
getScrollTop: function() {
return this.getScroll().y;
},
getScrollLeft: function() {
return this.getScroll().x;
},
getScrollHeight: function() {
return this.getScrollSize().y;
},
getScrollWidth: function() {
return this.getScrollSize().x;
},
getTop: function() {
return this.getPosition().y;
},
getLeft: function() {
return this.getPosition().x;
}
}), /*
---
name: Fx
description: Contains the basic animation logic to be extended by all other Fx Classes.
license: MIT-style license.
requires: [Chain, Events, Options]
provides: Fx
...
*/ function() {
var Fx1 = this.Fx = new Class({
Implements: [
Chain,
Events,
Options
],
options: {
/*
onStart: nil,
onCancel: nil,
onComplete: nil,
*/ fps: 60,
unit: !1,
duration: 500,
frames: null,
frameSkip: !0,
link: "ignore"
},
initialize: function(options) {
this.subject = this.subject || this, this.setOptions(options);
},
getTransition: function() {
return function(p) {
return -(Math.cos(Math.PI * p) - 1) / 2;
};
},
step: function(now) {
if (this.options.frameSkip) {
var frames = (null != this.time ? now - this.time : 0) / this.frameInterval;
this.time = now, this.frame += frames;
} else this.frame++;
if (this.frame < this.frames) {
var delta = this.transition(this.frame / this.frames);
this.set(this.compute(this.from, this.to, delta));
} else this.frame = this.frames, this.set(this.compute(this.from, this.to, 1)), this.stop();
},
set: function(now) {
return now;
},
compute: function(from, to, delta) {
return Fx1.compute(from, to, delta);
},
check: function() {
if (!this.isRunning()) return !0;
switch(this.options.link){
case "cancel":
return this.cancel(), !0;
case "chain":
this.chain(this.caller.pass(arguments, this));
}
return !1;
},
start: function(from, to) {
if (!this.check(from, to)) return this;
this.from = from, this.to = to, this.frame = this.options.frameSkip ? 0 : -1, this.time = null, this.transition = this.getTransition();
var frames = this.options.frames, fps = this.options.fps, duration = this.options.duration;
return this.duration = Fx1.Durations[duration] || duration.toInt(), this.frameInterval = 1000 / fps, this.frames = frames || Math.round(this.duration / this.frameInterval), this.fireEvent("start", this.subject), pushInstance.call(this, fps), this;
},
stop: function() {
return this.isRunning() && (this.time = null, pullInstance.call(this, this.options.fps), this.frames == this.frame ? (this.fireEvent("complete", this.subject), this.callChain() || this.fireEvent("chainComplete", this.subject)) : this.fireEvent("stop", this.subject)), this;
},
cancel: function() {
return this.isRunning() && (this.time = null, pullInstance.call(this, this.options.fps), this.frame = this.frames, this.fireEvent("cancel", this.subject).clearChain()), this;
},
pause: function() {
return this.isRunning() && (this.time = null, pullInstance.call(this, this.options.fps)), this;
},
resume: function() {
return this.frame < this.frames && !this.isRunning() && pushInstance.call(this, this.options.fps), this;
},
isRunning: function() {
var list = instances[this.options.fps];
return list && list.contains(this);
}
});
Fx1.compute = function(from, to, delta) {
return (to - from) * delta + from;
}, Fx1.Durations = {
short: 250,
normal: 500,
long: 1000
};
// global timers
var instances = {}, timers = {}, loop = function() {
for(var now = Date.now(), i = this.length; i--;){
var instance = this[i];
instance && instance.step(now);
}
}, pushInstance = function(fps) {
var list = instances[fps] || (instances[fps] = []);
list.push(this), timers[fps] || (timers[fps] = loop.periodical(Math.round(1000 / fps), list));
}, pullInstance = function(fps) {
var list = instances[fps];
list && (list.erase(this), !list.length && timers[fps] && (delete instances[fps], timers[fps] = clearInterval(timers[fps])));
};
}(), /*
---
name: Fx.CSS
description: Contains the CSS animation logic. Used by Fx.Tween, Fx.Morph, Fx.Elements.
license: MIT-style license.
requires: [Fx, Element.Style]
provides: Fx.CSS
...
*/ Fx.CSS = new Class({
Extends: Fx,
//prepares the base from/to object
prepare: function(element, property, values) {
var from = (values = Array.from(values))[0], to = values[1];
if (null == to) {
to = from, from = element.getStyle(property);
var unit = this.options.unit;
// adapted from: https://github.com/ryanmorr/fx/blob/master/fx.js#L299
if (unit && from.slice(-unit.length) != unit && 0 != parseFloat(from)) {
element.setStyle(property, to + unit);
var value = element.getComputedStyle(property);
// IE and Opera support pixelLeft or pixelWidth
if (!/px$/.test(value) && null == (value = element.style[("pixel-" + property).camelCase()])) {
// adapted from Dean Edwards' http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
var left = element.style.left;
element.style.left = to + unit, value = element.style.pixelLeft, element.style.left = left;
}
from = (to || 1) / (parseFloat(value) || 1) * (parseFloat(from) || 0), element.setStyle(property, from + unit);
}
}
return {
from: this.parse(from),
to: this.parse(to)
};
},
//parses a value into an array
parse: function(value) {
return (value = "string" == typeof (value = Function.from(value)()) ? value.split(" ") : Array.from(value)).map(function(val) {
val = String(val);
var found = !1;
return Object.each(Fx.CSS.Parsers, function(parser, key) {
if (!found) {
var parsed = parser.parse(val);
(parsed || 0 === parsed) && (found = {
value: parsed,
parser: parser
});
}
}), found = found || {
value: val,
parser: Fx.CSS.Parsers.String
};
});
},
//computes by a from and to prepared objects, using their parsers.
compute: function(from, to, delta) {
var computed = [];
return Math.min(from.length, to.length).times(function(i) {
computed.push({
value: from[i].parser.compute(from[i].value, to[i].value, delta),
parser: from[i].parser
});
}), computed.$family = Function.from("fx:css:value"), computed;
},
//serves the value as settable
serve: function(value, unit) {
"fx:css:value" != typeOf(value) && (value = this.parse(value));
var returned = [];
return value.each(function(bit) {
returned = returned.concat(bit.parser.serve(bit.value, unit));
}), returned;
},
//renders the change to an element
render: function(element, property, value, unit) {
element.setStyle(property, this.serve(value, unit));
},
//searches inside the page css to find the values for a selector
search: function(selector) {
if (Fx.CSS.Cache[selector]) return Fx.CSS.Cache[selector];
var to = {}, selectorTest = RegExp("^" + selector.escapeRegExp() + "$");
return Array.each(document.styleSheets, function(sheet, j) {
var href = sheet.href;
if (!(href && href.contains("://")) || href.contains(document.domain)) {
var rules = sheet.rules || sheet.cssRules;
Array.each(rules, function(rule, i) {
if (rule.style) {
var selectorText = rule.selectorText ? rule.selectorText.replace(/^\w+/, function(m) {
return m.toLowerCase();
}) : null;
selectorText && selectorTest.test(selectorText) && Object.each(Element.Styles, function(value, style) {
rule.style[style] && !Element.ShortStyles[style] && (value = String(rule.style[style]), to[style] = /^rgb/.test(value) ? value.rgbToHex() : value);
});
}
});
}
}), Fx.CSS.Cache[selector] = to;
}
}), Fx.CSS.Cache = {}, Fx.CSS.Parsers = {
Color: {
parse: function(value) {
return value.match(/^#[0-9a-f]{3,6}$/i) ? value.hexToRgb(!0) : !!(value = value.match(/(\d+),\s*(\d+),\s*(\d+)/)) && [
value[1],
value[2],
value[3]
];
},
compute: function(from, to, delta) {
return from.map(function(value, i) {
return Math.round(Fx.compute(from[i], to[i], delta));
});
},
serve: function(value) {
return value.map(Number);
}
},
Number: {
parse: parseFloat,
compute: Fx.compute,
serve: function(value, unit) {
return unit ? value + unit : value;
}
},
String: {
parse: Function.from(!1),
compute: function(zero, one) {
return one;
},
serve: function(zero) {
return zero;
}
}
}, //<1.2compat>
Fx.CSS.Parsers = new Hash(Fx.CSS.Parsers), //</1.2compat>
/*
---
name: Fx.Tween
description: Formerly Fx.Style, effect to transition any CSS property for an element.
license: MIT-style license.
requires: Fx.CSS
provides: [Fx.Tween, Element.fade, Element.highlight]
...
*/ Fx.Tween = new Class({
Extends: Fx.CSS,
initialize: function(element, options) {
this.element = this.subject = document.id(element), this.parent(options);
},
set: function(property, now) {
return 1 == arguments.length && (now = property, property = this.property || this.options.property), this.render(this.element, property, now, this.options.unit), this;
},
start: function(property, from, to) {
if (!this.check(property, from, to)) return this;
var args = Array.flatten(arguments);
this.property = this.options.property || args.shift();
var parsed = this.prepare(this.element, this.property, args);
return this.parent(parsed.from, parsed.to);
}
}), Element.Properties.tween = {
set: function(options) {
return this.get("tween").cancel().setOptions(options), this;
},
get: function() {
var tween = this.retrieve("tween");
return tween || (tween = new Fx.Tween(this, {
link: "cancel"
}), this.store("tween", tween)), tween;
}
}, Element.implement({
tween: function(property, from, to) {
return this.get("tween").start(property, from, to), this;
},
fade: function(how) {
var method, toggle, fade = this.get("tween"), args = [
"opacity"
].append(arguments);
switch(null == args[1] && (args[1] = "toggle"), args[1]){
case "in":
method = "start", args[1] = 1;
break;
case "out":
method = "start", args[1] = 0;
break;
case "show":
method = "set", args[1] = 1;
break;
case "hide":
method = "set", args[1] = 0;
break;
case "toggle":
var flag = this.retrieve("fade:flag", 1 == this.getStyle("opacity"));
method = "start", args[1] = +!flag, this.store("fade:flag", !flag), toggle = !0;
break;
default:
method = "start";
}
toggle || this.eliminate("fade:flag"), fade[method].apply(fade, args);
var to = args[args.length - 1];
return "set" == method || 0 != to ? this.setStyle("visibility", 0 == to ? "hidden" : "visible") : fade.chain(function() {
this.element.setStyle("visibility", "hidden"), this.callChain();
}), this;
},
highlight: function(start, end) {
end || (end = "transparent" == (end = this.retrieve("highlight:original", this.getStyle("background-color"))) ? "#fff" : end);
var tween = this.get("tween");
return tween.start("background-color", start || "#ffff88", end).chain((function() {
this.setStyle("background-color", this.retrieve("highlight:original")), tween.callChain();
}).bind(this)), this;
}
}), /*
---
name: Fx.Morph
description: Formerly Fx.Styles, effect to transition any number of CSS properties for an element using an object of rules, or CSS based selector rules.
license: MIT-style license.
requires: Fx.CSS
provides: Fx.Morph
...
*/ Fx.Morph = new Class({
Extends: Fx.CSS,
initialize: function(element, options) {
this.element = this.subject = document.id(element), this.parent(options);
},
set: function(now) {
for(var p in "string" == typeof now && (now = this.search(now)), now)this.render(this.element, p, now[p], this.options.unit);
return this;
},
compute: function(from, to, delta) {
var now = {};
for(var p in from)now[p] = this.parent(from[p], to[p], delta);
return now;
},
start: function(properties) {
if (!this.check(properties)) return this;
"string" == typeof properties && (properties = this.search(properties));
var from = {}, to = {};
for(var p in properties){
var parsed = this.prepare(this.element, p, properties[p]);
from[p] = parsed.from, to[p] = parsed.to;
}
return this.parent(from, to);
}
}), Element.Properties.morph = {
set: function(options) {
return this.get("morph").cancel().setOptions(options), this;
},
get: function() {
var morph = this.retrieve("morph");
return morph || (morph = new Fx.Morph(this, {
link: "cancel"
}), this.store("morph", morph)), morph;
}
}, Element.implement({
morph: function(props) {
return this.get("morph").start(props), this;
}
}), /*
---
name: Fx.Transitions
description: Contains a set of advanced transitions to be used with any of the Fx Classes.
license: MIT-style license.
credits:
- Easing Equations by Robert Penner, <http://www.robertpenner.com/easing/>, modified and optimized to be used with MooTools.
requires: Fx
provides: Fx.Transitions
...
*/ Fx.implement({
getTransition: function() {
var trans = this.options.transition || Fx.Transitions.Sine.easeInOut;
if ("string" == typeof trans) {
var data = trans.split(":");
trans = (trans = Fx.Transitions)[data[0]] || trans[data[0].capitalize()], data[1] && (trans = trans["ease" + data[1].capitalize() + (data[2] ? data[2].capitalize() : "")]);
}
return trans;
}
}), Fx.Transition = function(transition, params) {
params = Array.from(params);
var easeIn = function(pos) {
return transition(pos, params);
};
return Object.append(easeIn, {
easeIn: easeIn,
easeOut: function(pos) {
return 1 - transition(1 - pos, params);
},
easeInOut: function(pos) {
return (pos <= 0.5 ? transition(2 * pos, params) : 2 - transition(2 * (1 - pos), params)) / 2;
}
});
}, Fx.Transitions = {
linear: function(zero) {
return zero;
}
}, //<1.2compat>
Fx.Transitions = new Hash(Fx.Transitions), //</1.2compat>
Fx.Transitions.extend = function(transitions) {
for(var transition in transitions)Fx.Transitions[transition] = new Fx.Transition(transitions[transition]);
}, Fx.Transitions.extend({
Pow: function(p, x) {
return Math.pow(p, x && x[0] || 6);
},
Expo: function(p) {
return Math.pow(2, 8 * (p - 1));
},
Circ: function(p) {
return 1 - Math.sin(Math.acos(p));
},
Sine: function(p) {
return 1 - Math.cos(p * Math.PI / 2);
},
Back: function(p, x) {
return Math.pow(p, 2) * (((x = x && x[0] || 1.618) + 1) * p - x);
},
Bounce: function(p) {
for(var value, a = 0, b = 1;; a += b, b /= 2)if (p >= (7 - 4 * a) / 11) {
value = b * b - Math.pow((11 - 6 * a - 11 * p) / 4, 2);
break;
}
return value;
},
Elastic: function(p, x) {
return Math.pow(2, 10 * --p) * Math.cos(20 * p * Math.PI * (x && x[0] || 1) / 3);
}
}), [
"Quad",
"Cubic",
"Quart",
"Quint"
].each(function(transition, i) {
Fx.Transitions[transition] = new Fx.Transition(function(p) {
return Math.pow(p, i + 2);
});
}), /*
---
name: Request
description: Powerful all purpose Request Class. Uses XMLHTTPRequest.
license: MIT-style license.
requires: [Object, Element, Chain, Events, Options, Browser]
provides: Request
...
*/ function() {
var empty = function() {}, progressSupport = "onprogress" in new Browser.Request(), Request1 = this.Request = new Class({
Implements: [
Chain,
Events,
Options
],
options: {
/*
onRequest: function(){},
onLoadstart: function(event, xhr){},
onProgress: function(event, xhr){},
onComplete: function(){},
onCancel: function(){},
onSuccess: function(responseText, responseXML){},
onFailure: function(xhr){},
onException: function(headerName, value){},
onTimeout: function(){},
user: '',
password: '',*/ url: "",
data: "",
headers: {
"X-Requested-With": "XMLHttpRequest",
Accept: "text/javascript, text/html, application/xml, text/xml, */*"
},
async: !0,
format: !1,
method: "post",
link: "ignore",
isSuccess: null,
emulation: !0,
urlEncoded: !0,
encoding: "utf-8",
evalScripts: !1,
evalResponse: !1,
timeout: 0,
noCache: !1
},
initialize: function(options) {
this.xhr = new Browser.Request(), this.setOptions(options), this.headers = this.options.headers;
},
onStateChange: function() {
var xhr = this.xhr;
4 == xhr.readyState && this.running && (this.running = !1, this.status = 0, Function.attempt((function() {
var status = xhr.status;
this.status = 1223 == status ? 204 : status;
}).bind(this)), xhr.onreadystatechange = empty, progressSupport && (xhr.onprogress = xhr.onloadstart = empty), clearTimeout(this.timer), this.response = {
text: this.xhr.responseText || "",
xml: this.xhr.responseXML
}, this.options.isSuccess.call(this, this.status) ? this.success(this.response.text, this.response.xml) : this.failure());
},
isSuccess: function() {
var status = this.status;
return status >= 200 && status < 300;
},
isRunning: function() {
return !!this.running;
},
processScripts: function(text) {
return this.options.evalResponse || /(ecma|java)script/.test(this.getHeader("Content-type")) ? Browser.exec(text) : text.stripScripts(this.options.evalScripts);
},
success: function(text, xml) {
this.onSuccess(this.processScripts(text), xml);
},
onSuccess: function() {
this.fireEvent("complete", arguments).fireEvent("success", arguments).callChain();
},
failure: function() {
this.onFailure();
},
onFailure: function() {
this.fireEvent("complete").fireEvent("failure", this.xhr);
},
loadstart: function(event) {
this.fireEvent("loadstart", [
event,
this.xhr
]);
},
progress: function(event) {
this.fireEvent("progress", [
event,
this.xhr
]);
},
timeout: function() {
this.fireEvent("timeout", this.xhr);
},
setHeader: function(name, value) {
return this.headers[name] = value, this;
},
getHeader: function(name) {
return Function.attempt((function() {
return this.xhr.getResponseHeader(name);
}).bind(this));
},
check: function() {
if (!this.running) return !0;
switch(this.options.link){
case "cancel":
return this.cancel(), !0;
case "chain":
this.chain(this.caller.pass(arguments, this));
}
return !1;
},
send: function(options) {
if (!this.check(options)) return this;
this.options.isSuccess = this.options.isSuccess || this.isSuccess, this.running = !0;
var type = typeOf(options);
("string" == type || "element" == type) && (options = {
data: options
});
var old = this.options, data = (options = Object.append({
data: old.data,
url: old.url,
method: old.method
}, options)).data, url = String(options.url), method = options.method.toLowerCase();
switch(typeOf(data)){
case "element":
data = document.id(data).toQueryString();
break;
case "object":
case "hash":
data = Object.toQueryString(data);
}
if (this.options.format) {
var format = "format=" + this.options.format;
data = data ? format + "&" + data : format;
}
if (this.options.emulation && ![
"get",
"post"
].contains(method)) {
var _method = "_method=" + method;
data = data ? _method + "&" + data : _method, method = "post";
}
if (this.options.urlEncoded && [
"post",
"put"
].contains(method)) {
var encoding = this.options.encoding ? "; charset=" + this.options.encoding : "";
this.headers["Content-type"] = "application/x-www-form-urlencoded" + encoding;
}
url || (url = document.location.pathname);
var trimPosition = url.lastIndexOf("/");
trimPosition > -1 && (trimPosition = url.indexOf("#")) > -1 && (url = url.substr(0, trimPosition)), this.options.noCache && (url += (url.contains("?") ? "&" : "?") + String.uniqueID()), data && "get" == method && (url += (url.contains("?") ? "&" : "?") + data, data = null);
var xhr = this.xhr;
return progressSupport && (xhr.onloadstart = this.loadstart.bind(this), xhr.onprogress = this.progress.bind(this)), xhr.open(method.toUpperCase(), url, this.options.async, this.options.user, this.options.password), this.options.user && "withCredentials" in xhr && (xhr.withCredentials = !0), xhr.onreadystatechange = this.onStateChange.bind(this), Object.each(this.headers, function(value, key) {
try {
xhr.setRequestHeader(key, value);
} catch (e) {
this.fireEvent("exception", [
key,
value
]);
}
}, this), this.fireEvent("request"), xhr.send(data), this.options.async ? this.options.timeout && (this.timer = this.timeout.delay(this.options.timeout, this)) : this.onStateChange(), this;
},
cancel: function() {
if (!this.running) return this;
this.running = !1;
var xhr = this.xhr;
return xhr.abort(), clearTimeout(this.timer), xhr.onreadystatechange = empty, progressSupport && (xhr.onprogress = xhr.onloadstart = empty), this.xhr = new Browser.Request(), this.fireEvent("cancel"), this;
}
}), methods = {};
[
"get",
"post",
"put",
"delete",
"GET",
"POST",
"PUT",
"DELETE"
].each(function(method) {
methods[method] = function(data) {
var object = {
method: method
};
return null != data && (object.data = data), this.send(object);
};
}), Request1.implement(methods), Element.Properties.send = {
set: function(options) {
return this.get("send").cancel().setOptions(options), this;
},
get: function() {
var send = this.retrieve("send");
return send || (send = new Request1({
data: this,
link: "cancel",
method: this.get("method") || "post",
url: this.get("action")
}), this.store("send", send)), send;
}
}, Element.implement({
send: function(url) {
var sender = this.get("send");
return sender.send({
data: this,
url: url || sender.options.url
}), this;
}
});
}(), /*
---
name: Request.HTML
description: Extends the basic Request Class with additional methods for interacting with HTML responses.
license: MIT-style license.
requires: [Element, Request]
provides: Request.HTML
...
*/ Request.HTML = new Class({
Extends: Request,
options: {
update: !1,
append: !1,
evalScripts: !0,
filter: !1,
headers: {
Accept: "text/html, application/xml, text/xml, */*"
}
},
success: function(text) {
var options = this.options, response = this.response;
response.html = text.stripScripts(function(script) {
response.javascript = script;
});
var match = response.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
match && (response.html = match[1]);
var temp = new Element("div").set("html", response.html);
if (response.tree = temp.childNodes, response.elements = temp.getElements(options.filter || "*"), options.filter && (response.tree = response.elements), options.update) {
var update = document.id(options.update).empty();
options.filter ? update.adopt(response.elements) : update.set("html", response.html);
} else if (options.append) {
var append = document.id(options.append);
options.filter ? response.elements.reverse().inject(append) : append.adopt(temp.getChildren());
}
options.evalScripts && Browser.exec(response.javascript), this.onSuccess(response.tree, response.elements, response.html, response.javascript);
}
}), Element.Properties.load = {
set: function(options) {
return this.get("load").cancel().setOptions(options), this;
},
get: function() {
var load = this.retrieve("load");
return load || (load = new Request.HTML({
data: this,
link: "cancel",
update: this,
method: "get"
}), this.store("load", load)), load;
}
}, Element.implement({
load: function() {
return this.get("load").send(Array.link(arguments, {
data: Type.isObject,
url: Type.isString
})), this;
}
}), "undefined" == typeof JSON && (this.JSON = {}), //<1.2compat>
JSON = new Hash({
stringify: JSON.stringify,
parse: JSON.parse
}), //</1.2compat>
function() {
var special = {
"\b": "\\b",
"\t": "\\t",
"\n": "\\n",
"\f": "\\f",
"\r": "\\r",
'"': '\\"',
"\\": "\\\\"
}, escape = function(chr) {
return special[chr] || "\\u" + ("0000" + chr.charCodeAt(0).toString(16)).slice(-4);
};
JSON.validate = function(string) {
return string = string.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""), /^[\],:{}\s]*$/.test(string);
}, JSON.encode = JSON.stringify ? function(obj) {
return JSON.stringify(obj);
} : function(obj) {
switch(obj && obj.toJSON && (obj = obj.toJSON()), typeOf(obj)){
case "string":
return '"' + obj.replace(/[\x00-\x1f\\"]/g, escape) + '"';
case "array":
return "[" + obj.map(JSON.encode).clean() + "]";
case "object":
case "hash":
var string = [];
return Object.each(obj, function(value, key) {
var json = JSON.encode(value);
json && string.push(JSON.encode(key) + ":" + json);
}), "{" + string + "}";
case "number":
case "boolean":
return "" + obj;
case "null":
return "null";
}
return null;
}, JSON.decode = function(string, secure) {
if (!string || "string" != typeOf(string)) return null;
if (secure || JSON.secure) {
if (JSON.parse) return JSON.parse(string);
if (!JSON.validate(string)) throw Error("JSON could not decode the input; security is enabled and the value is not secure.");
}
return eval("(" + string + ")");
};
}(), /*
---
name: Request.JSON
description: Extends the basic Request Class with additional methods for sending and receiving JSON data.
license: MIT-style license.
requires: [Request, JSON]
provides: Request.JSON
...
*/ Request.JSON = new Class({
Extends: Request,
options: {
/*onError: function(text, error){},*/ secure: !0
},
initialize: function(options) {
this.parent(options), Object.append(this.headers, {
Accept: "application/json",
"X-Request": "JSON"
});
},
success: function(text) {
var json;
try {
json = this.response.json = JSON.decode(text, this.options.secure);
} catch (error) {
this.fireEvent("error", [
text,
error
]);
return;
}
null == json ? this.onFailure() : this.onSuccess(json, text);
}
});
/*
---
name: Cookie
description: Class for creating, reading, and deleting browser Cookies.
license: MIT-style license.
credits:
- Based on the functions by Peter-Paul Koch (http://quirksmode.org).
requires: [Options, Browser]
provides: Cookie
...
*/ var Cookie = new Class({
Implements: Options,
options: {
path: "/",
domain: !1,
duration: !1,
secure: !1,
document: document,
encode: !0
},
initialize: function(key, options) {
this.key = key, this.setOptions(options);
},
write: function(value) {
if (this.options.encode && (value = encodeURIComponent(value)), this.options.domain && (value += "; domain=" + this.options.domain), this.options.path && (value += "; path=" + this.options.path), this.options.duration) {
var date = new Date();
date.setTime(date.getTime() + 86400000 * this.options.duration), value += "; expires=" + date.toGMTString();
}
return this.options.secure && (value += "; secure"), this.options.document.cookie = this.key + "=" + value, this;
},
read: function() {
var value = this.options.document.cookie.match("(?:^|;)\\s*" + this.key.escapeRegExp() + "=([^;]*)");
return value ? decodeURIComponent(value[1]) : null;
},
dispose: function() {
return new Cookie(this.key, Object.merge({}, this.options, {
duration: -1
})).write(""), this;
}
});
Cookie.write = function(key, value, options) {
return new Cookie(key, options).write(value);
}, Cookie.read = function(key) {
return new Cookie(key).read();
}, Cookie.dispose = function(key, options) {
return new Cookie(key, options).dispose();
}, /*
---
name: DOMReady
description: Contains the custom event domready.
license: MIT-style license.
requires: [Browser, Element, Element.Event]
provides: [DOMReady, DomReady]
...
*/ function(window1, document1) {
var ready, loaded, shouldPoll, timer, checks = [], testElement = document1.createElement("div"), domready = function() {
clearTimeout(timer), ready || (Browser.loaded = ready = !0, document1.removeListener("DOMContentLoaded", domready).removeListener("readystatechange", check), document1.fireEvent("domready"), window1.fireEvent("domready"));
}, check = function() {
for(var i = checks.length; i--;)if (checks[i]()) return domready(), !0;
return !1;
}, poll = function() {
clearTimeout(timer), check() || (timer = setTimeout(poll, 10));
};
document1.addListener("DOMContentLoaded", domready);
/*<ltIE8>*/ // doScroll technique by Diego Perini http://javascript.nwbox.com/IEContentLoaded/
// testElement.doScroll() throws when the DOM is not ready, only in the top window
var doScrollWorks = function() {
try {
return testElement.doScroll(), !0;
} catch (e) {}
return !1;
};
testElement.doScroll && !doScrollWorks() && (checks.push(doScrollWorks), shouldPoll = !0), document1.readyState && checks.push(function() {
var state = document1.readyState;
return "loaded" == state || "complete" == state;
}), "onreadystatechange" in document1 ? document1.addListener("readystatechange", check) : shouldPoll = !0, shouldPoll && poll(), Element.Events.domready = {
onAdd: function(fn) {
ready && fn.call(this);
}
}, // Make sure that domready fires before load
Element.Events.load = {
base: "load",
onAdd: function(fn) {
loaded && this == window1 && fn.call(this);
},
condition: function() {
return this == window1 && (domready(), delete Element.Events.load), !0;
}
}, // This is based on the custom load event
window1.addEvent("load", function() {
loaded = !0;
});
}(window, document), /*
---
name: Swiff
description: Wrapper for embedding SWF movies. Supports External Interface Communication.
license: MIT-style license.
credits:
- Flash detection & Internet Explorer + Flash Player 9 fix inspired by SWFObject.
requires: [Options, Object, Element]
provides: Swiff
...
*/ function() {
var Swiff = this.Swiff = new Class({
Implements: Options,
options: {
id: null,
height: 1,
width: 1,
container: null,
properties: {},
params: {
quality: "high",
allowScriptAccess: "always",
wMode: "window",
swLiveConnect: !0
},
callBacks: {},
vars: {}
},
toElement: function() {
return this.object;
},
initialize: function(path, options) {
this.instance = "Swiff_" + String.uniqueID(), this.setOptions(options), options = this.options;
var id = this.id = options.id || this.instance, container = document.id(options.container);
Swiff.CallBacks[this.instance] = {};
var params = options.params, vars = options.vars, callBacks = options.callBacks, properties = Object.append({
height: options.height,
width: options.width
}, options.properties), self = this;
for(var callBack in callBacks)Swiff.CallBacks[this.instance][callBack] = function(option) {
return function() {
return option.apply(self.object, arguments);
};
}(callBacks[callBack]), vars[callBack] = "Swiff.CallBacks." + this.instance + "." + callBack;
params.flashVars = Object.toQueryString(vars), Browser.ie ? (properties.classid = "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", params.movie = path) : properties.type = "application/x-shockwave-flash", properties.data = path;
var build = '<object id="' + id + '"';
for(var property in properties)build += " " + property + '="' + properties[property] + '"';
for(var param in build += ">", params)params[param] && (build += '<param name="' + param + '" value="' + params[param] + '" />');
build += "</object>", this.object = (container ? container.empty() : new Element("div")).set("html", build).firstChild;
},
replaces: function(element) {
return (element = document.id(element, !0)).parentNode.replaceChild(this.toElement(), element), this;
},
inject: function(element) {
return document.id(element, !0).appendChild(this.toElement()), this;
},
remote: function() {
return Swiff.remote.apply(Swiff, [
this.toElement()
].append(arguments));
}
});
Swiff.CallBacks = {}, Swiff.remote = function(obj, fn) {
var rs = obj.CallFunction('<invoke name="' + fn + '" returntype="javascript">' + __flash__argumentsToXML(arguments, 2) + "</invoke>");
return eval(rs);
};
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/react-17.0.1.js | JavaScript | /** @license React v17.0.1
* react.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/ "use strict";
"production" !== process.env.NODE_ENV && function() {
var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs, prevLog, prevInfo, prevWarn, prevError, prevGroup, prevGroupCollapsed, prevGroupEnd, prefix, componentFrameCache, propTypesMisspellWarningShown, _assign = require("object-assign"), REACT_ELEMENT_TYPE = 0xeac7, REACT_PORTAL_TYPE = 0xeaca;
exports.Fragment = 0xeacb, exports.StrictMode = 0xeacc, exports.Profiler = 0xead2;
var REACT_PROVIDER_TYPE = 0xeacd, REACT_CONTEXT_TYPE = 0xeace, REACT_FORWARD_REF_TYPE = 0xead0;
exports.Suspense = 0xead1;
var REACT_SUSPENSE_LIST_TYPE = 0xead8, REACT_MEMO_TYPE = 0xead3, REACT_LAZY_TYPE = 0xead4, REACT_BLOCK_TYPE = 0xead9, REACT_SERVER_BLOCK_TYPE = 0xeada, REACT_FUNDAMENTAL_TYPE = 0xead5, REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1, REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
if ("function" == typeof Symbol && Symbol.for) {
var symbolFor = Symbol.for;
REACT_ELEMENT_TYPE = symbolFor("react.element"), REACT_PORTAL_TYPE = symbolFor("react.portal"), exports.Fragment = symbolFor("react.fragment"), exports.StrictMode = symbolFor("react.strict_mode"), exports.Profiler = symbolFor("react.profiler"), REACT_PROVIDER_TYPE = symbolFor("react.provider"), REACT_CONTEXT_TYPE = symbolFor("react.context"), REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref"), exports.Suspense = symbolFor("react.suspense"), REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list"), REACT_MEMO_TYPE = symbolFor("react.memo"), REACT_LAZY_TYPE = symbolFor("react.lazy"), REACT_BLOCK_TYPE = symbolFor("react.block"), REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block"), REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental"), symbolFor("react.scope"), symbolFor("react.opaque.id"), REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode"), symbolFor("react.offscreen"), REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
}
var MAYBE_ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator;
function getIteratorFn(maybeIterable) {
if (null === maybeIterable || "object" != typeof maybeIterable) return null;
var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
return "function" == typeof maybeIterator ? maybeIterator : null;
}
/**
* Keeps track of the current dispatcher.
*/ var ReactCurrentDispatcher = {
/**
* @internal
* @type {ReactComponent}
*/ current: null
}, ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/ current: null
}, ReactDebugCurrentFrame = {}, currentExtraStackFrame = null;
ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
currentExtraStackFrame = stack;
}, ReactDebugCurrentFrame.getCurrentStack = null, ReactDebugCurrentFrame.getStackAddendum = function() {
var stack = ""; // Add an extra top frame while an element is being validated
currentExtraStackFrame && (stack += currentExtraStackFrame);
var impl = ReactDebugCurrentFrame.getCurrentStack;
return impl && (stack += impl() || ""), stack;
};
var ReactSharedInternals = {
ReactCurrentDispatcher: ReactCurrentDispatcher,
ReactCurrentBatchConfig: {
transition: 0
},
ReactCurrentOwner: ReactCurrentOwner,
IsSomeRendererActing: {
current: !1
},
// Used by renderers to avoid bundling object-assign twice in UMD bundles:
assign: _assign
};
// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
function warn(format) {
for(var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++)args[_key - 1] = arguments[_key];
printWarning("warn", format, args);
}
function error(format) {
for(var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++)args[_key2 - 1] = arguments[_key2];
printWarning("error", format, args);
}
function printWarning(level, format, args) {
var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
"" !== stack && (format += "%s", args = args.concat([
stack
]));
var argsWithFormat = args.map(function(item) {
return "" + item;
}); // Careful: RN currently depends on this prefix
argsWithFormat.unshift("Warning: " + format), // breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
var didWarnStateUpdateForUnmountedComponent = {};
function warnNoop(publicInstance, callerName) {
var _constructor = publicInstance.constructor, componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass", warningKey = componentName + "." + callerName;
!didWarnStateUpdateForUnmountedComponent[warningKey] && (error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, componentName), didWarnStateUpdateForUnmountedComponent[warningKey] = !0);
}
/**
* This is the abstract API for an update queue.
*/ var ReactNoopUpdateQueue = {
/**
* Checks whether or not this composite component is mounted.
* @param {ReactClass} publicInstance The instance we want to test.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/ isMounted: function(publicInstance) {
return !1;
},
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/ enqueueForceUpdate: function(publicInstance, callback, callerName) {
warnNoop(publicInstance, "forceUpdate");
},
/**
* Replaces all of the state. Always use this or `setState` to mutate state.
* You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} completeState Next state.
* @param {?function} callback Called after component is updated.
* @param {?string} callerName name of the calling function in the public API.
* @internal
*/ enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
warnNoop(publicInstance, "replaceState");
},
/**
* Sets a subset of the state. This only exists because _pendingState is
* internal. This provides a merging strategy that is not available to deep
* properties which is confusing. TODO: Expose pendingState or don't use it
* during the merge.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialState Next partial state to be merged with state.
* @param {?function} callback Called after component is updated.
* @param {?string} Name of the calling function in the public API.
* @internal
*/ enqueueSetState: function(publicInstance, partialState, callback, callerName) {
warnNoop(publicInstance, "setState");
}
}, emptyObject = {};
/**
* Base class helpers for the updating state of a component.
*/ function Component(props, context, updater) {
this.props = props, this.context = context, this.refs = emptyObject, // renderer.
this.updater = updater || ReactNoopUpdateQueue;
}
Object.freeze(emptyObject), Component.prototype.isReactComponent = {}, /**
* Sets a subset of the state. Always use this to mutate
* state. You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* There is no guarantee that calls to `setState` will run synchronously,
* as they may eventually be batched together. You can provide an optional
* callback that will be executed when the call to setState is actually
* completed.
*
* When a function is provided to setState, it will be called at some point in
* the future (not synchronously). It will be called with the up to date
* component arguments (state, props, context). These values can be different
* from this.* because your function may be called after receiveProps but before
* shouldComponentUpdate, and this new state, props, and context will not yet be
* assigned to this.
*
* @param {object|function} partialState Next partial state or function to
* produce next partial state to be merged with current state.
* @param {?function} callback Called after state is updated.
* @final
* @protected
*/ Component.prototype.setState = function(partialState, callback) {
if ("object" != typeof partialState && "function" != typeof partialState && null != partialState) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
this.updater.enqueueSetState(this, partialState, callback, "setState");
}, /**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {?function} callback Called after update is complete.
* @final
* @protected
*/ Component.prototype.forceUpdate = function(callback) {
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
};
var deprecatedAPIs = {
isMounted: [
"isMounted",
"Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
],
replaceState: [
"replaceState",
"Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
]
}, defineDeprecationWarning = function(methodName, info) {
Object.defineProperty(Component.prototype, methodName, {
get: function() {
warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
}
});
};
for(var fnName in deprecatedAPIs)deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
function ComponentDummy() {}
/**
* Convenience component with default shallow equality check for sCU.
*/ function PureComponent(props, context, updater) {
this.props = props, this.context = context, this.refs = emptyObject, this.updater = updater || ReactNoopUpdateQueue;
}
ComponentDummy.prototype = Component.prototype;
var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentName(type) {
if (null == type) // Host root, text node or just invalid type.
return null;
if ("number" == typeof type.tag && error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."), "function" == typeof type) return type.displayName || type.name || null;
if ("string" == typeof type) return type;
switch(type){
case exports.Fragment:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case exports.Profiler:
return "Profiler";
case exports.StrictMode:
return "StrictMode";
case exports.Suspense:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if ("object" == typeof type) switch(type.$$typeof){
case REACT_CONTEXT_TYPE:
return getContextName(type) + ".Consumer";
case REACT_PROVIDER_TYPE:
return getContextName(type._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
var innerType, wrapperName, functionName;
return innerType = type.render, wrapperName = "ForwardRef", functionName = innerType.displayName || innerType.name || "", type.displayName || ("" !== functionName ? wrapperName + "(" + functionName + ")" : wrapperName);
case REACT_MEMO_TYPE:
return getComponentName(type.type);
case REACT_BLOCK_TYPE:
return getComponentName(type._render);
case REACT_LAZY_TYPE:
var payload = type._payload, init = type._init;
try {
return getComponentName(init(payload));
} catch (x) {}
}
return null;
}
pureComponentPrototype.constructor = PureComponent, _assign(pureComponentPrototype, Component.prototype), pureComponentPrototype.isPureReactComponent = !0;
var hasOwnProperty = Object.prototype.hasOwnProperty, RESERVED_PROPS = {
key: !0,
ref: !0,
__self: !0,
__source: !0
};
function hasValidRef(config) {
if (hasOwnProperty.call(config, "ref")) {
var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
if (getter && getter.isReactWarning) return !1;
}
return void 0 !== config.ref;
}
function hasValidKey(config) {
if (hasOwnProperty.call(config, "key")) {
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
if (getter && getter.isReactWarning) return !1;
}
return void 0 !== config.key;
}
didWarnAboutStringRefs = {};
/**
* Factory method to create a new React element. This no longer adheres to
* the class pattern, so do not use new to call it. Also, instanceof check
* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
* if something is a React Element.
*
* @param {*} type
* @param {*} props
* @param {*} key
* @param {string|object} ref
* @param {*} owner
* @param {*} self A *temporary* helper to detect places where `this` is
* different from the `owner` when React.createElement is called, so that we
* can warn. We want to get rid of owner and replace string `ref`s with arrow
* functions, and as long as `this` and owner are the same, there will be no
* change in behavior.
* @param {*} source An annotation object (added by a transpiler or otherwise)
* indicating filename, line number, and/or other information.
* @internal
*/ var ReactElement = function(type, key, ref, self, source, owner, props) {
var element = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner
};
return(// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store = {}, // the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
Object.defineProperty(element._store, "validated", {
configurable: !1,
enumerable: !1,
writable: !0,
value: !1
}), Object.defineProperty(element, "_self", {
configurable: !1,
enumerable: !1,
writable: !1,
value: self
}), // equal for testing purposes and therefore we hide it from enumeration.
Object.defineProperty(element, "_source", {
configurable: !1,
enumerable: !1,
writable: !1,
value: source
}), Object.freeze && (Object.freeze(element.props), Object.freeze(element)), element);
};
/**
* Create and return a new ReactElement of the given type.
* See https://reactjs.org/docs/react-api.html#createelement
*/ function createElement(type, config, children) {
var propName, props = {}, key = null, ref = null, self = null, source = null;
if (null != config) for(propName in hasValidRef(config) && (ref = config.ref, function(config) {
if ("string" == typeof config.ref && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
var componentName = getComponentName(ReactCurrentOwner.current.type);
didWarnAboutStringRefs[componentName] || (error('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref), didWarnAboutStringRefs[componentName] = !0);
}
}(config)), hasValidKey(config) && (key = "" + config.key), self = void 0 === config.__self ? null : config.__self, source = void 0 === config.__source ? null : config.__source, config)hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName) && (props[propName] = config[propName]);
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (1 === childrenLength) props.children = children;
else if (childrenLength > 1) {
for(var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)childArray[i] = arguments[i + 2];
Object.freeze && Object.freeze(childArray), props.children = childArray;
} // Resolve default props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for(propName in defaultProps)void 0 === props[propName] && (props[propName] = defaultProps[propName]);
}
if (key || ref) {
var warnAboutAccessingKey, warnAboutAccessingRef, displayName = "function" == typeof type ? type.displayName || type.name || "Unknown" : type;
key && ((warnAboutAccessingKey = function() {
specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName));
}).isReactWarning = !0, Object.defineProperty(props, "key", {
get: warnAboutAccessingKey,
configurable: !0
})), ref && ((warnAboutAccessingRef = function() {
specialPropRefWarningShown || (specialPropRefWarningShown = !0, error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName));
}).isReactWarning = !0, Object.defineProperty(props, "ref", {
get: warnAboutAccessingRef,
configurable: !0
}));
}
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
}
/**
* Clone and return a new ReactElement using element as the starting point.
* See https://reactjs.org/docs/react-api.html#cloneelement
*/ function cloneElement(element, config, children) {
if (null == element) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
var propName, defaultProps, props = _assign({}, element.props), key = element.key, ref = element.ref, self = element._self, source = element._source, owner = element._owner; // Reserved names are extracted
if (null != config) for(propName in hasValidRef(config) && (// Silently steal the ref from the parent.
ref = config.ref, owner = ReactCurrentOwner.current), hasValidKey(config) && (key = "" + config.key), element.type && element.type.defaultProps && (defaultProps = element.type.defaultProps), config)hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName) && (void 0 === config[propName] && void 0 !== defaultProps ? // Resolve default props
props[propName] = defaultProps[propName] : props[propName] = config[propName]);
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (1 === childrenLength) props.children = children;
else if (childrenLength > 1) {
for(var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)childArray[i] = arguments[i + 2];
props.children = childArray;
}
return ReactElement(element.type, key, ref, self, source, owner, props);
}
/**
* Verifies the object is a ReactElement.
* See https://reactjs.org/docs/react-api.html#isvalidelement
* @param {?object} object
* @return {boolean} True if `object` is a ReactElement.
* @final
*/ function isValidElement(object) {
return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
}
/**
* TODO: Test that a single child and an array with one item have the same key
* pattern.
*/ var didWarnAboutMaps = !1, userProvidedKeyEscapeRegex = /\/+/g;
function escapeUserProvidedKey(text) {
return text.replace(userProvidedKeyEscapeRegex, "$&/");
}
/**
* Generate a key string that identifies a element within a set.
*
* @param {*} element A element that could contain a manual key.
* @param {number} index Index that is used if a manual key is not provided.
* @return {string}
*/ function getElementKey(element, index) {
// Do some typechecking here since we call this blindly. We want to ensure
// that we don't block potential future ES APIs.
if ("object" == typeof element && null !== element && null != element.key) {
var key, escaperLookup;
// Explicit key
return key = "" + element.key, escaperLookup = {
"=": "=0",
":": "=2"
}, "$" + key.replace(/[=:]/g, function(match) {
return escaperLookup[match];
});
} // Implicit key determined by the index in the set
return index.toString(36);
}
/**
* Maps children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenmap
*
* The provided mapFunction(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} func The map function.
* @param {*} context Context for mapFunction.
* @return {object} Object containing the ordered map of results.
*/ function mapChildren(children, func, context) {
if (null == children) return children;
var result = [], count = 0;
return !function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
var type = typeof children;
("undefined" === type || "boolean" === type) && // All of the above are perceived as null.
(children = null);
var invokeCallback = !1;
if (null === children) invokeCallback = !0;
else switch(type){
case "string":
case "number":
invokeCallback = !0;
break;
case "object":
switch(children.$$typeof){
case REACT_ELEMENT_TYPE:
case REACT_PORTAL_TYPE:
invokeCallback = !0;
}
}
if (invokeCallback) {
var oldElement, newKey, _child = children, mappedChild = callback(_child), childKey = "" === nameSoFar ? "." + getElementKey(_child, 0) : nameSoFar;
if (Array.isArray(mappedChild)) {
var escapedChildKey = "";
null != childKey && (escapedChildKey = escapeUserProvidedKey(childKey) + "/"), mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) {
return c;
});
} else null != mappedChild && (isValidElement(mappedChild) && (oldElement = mappedChild, newKey = // traverseAllChildren used to do for objects as children
escapedPrefix + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
(mappedChild.key && (!_child || _child.key !== mappedChild.key // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
) ? escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey, mappedChild = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props)), array.push(mappedChild));
return 1;
}
var subtreeCount = 0, nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":"; // Count of children found in the current subtree.
if (Array.isArray(children)) for(var i = 0; i < children.length; i++)nextName = nextNamePrefix + getElementKey(child = children[i], i), subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
else {
var iteratorFn = getIteratorFn(children);
if ("function" == typeof iteratorFn) {
var child, nextName, step, iterableChildren = children;
// Warn about using Maps as children
iteratorFn === iterableChildren.entries && (didWarnAboutMaps || warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0);
for(var iterator = iteratorFn.call(iterableChildren), ii = 0; !(step = iterator.next()).done;)nextName = nextNamePrefix + getElementKey(child = step.value, ii++), subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
} else if ("object" === type) {
var childrenString = "" + children;
throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead.");
}
}
return subtreeCount;
}(children, result, "", "", function(child) {
return func.call(context, child, count++);
}), result;
}
function lazyInitializer(payload) {
if (-1 === payload._status) {
var thenable = (0, payload._result)(); // Transition to the next state.
payload._status = 0, payload._result = thenable, thenable.then(function(moduleObject) {
if (0 === payload._status) {
var defaultExport = moduleObject.default;
void 0 === defaultExport && error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", moduleObject), payload._status = 1, payload._result = defaultExport;
}
}, function(error) {
0 === payload._status && (payload._status = 2, payload._result = error);
});
}
if (1 === payload._status) return payload._result;
throw payload._result;
}
function isValidElementType(type) {
return "string" == typeof type || "function" == typeof type || type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || "object" == typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) || !1 // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
;
}
function resolveDispatcher() {
var dispatcher = ReactCurrentDispatcher.current;
if (null === dispatcher) throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
return dispatcher;
}
// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
// We could also eagerly patch the method.
var disabledDepth = 0;
function disabledLog() {}
disabledLog.__reactDisabledLog = !0;
var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
function describeBuiltInComponentFrame(name, source, ownerFn) {
if (void 0 === prefix) // Extract the VM specific prefix used by each line.
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = match && match[1] || "";
}
// We use the prefix to ensure our stacks line up with native stack frames.
return "\n" + prefix + name;
}
var reentry = !1;
function describeNativeComponentFrame(fn, construct) {
// If something asked for a stack inside a fake render, it should get ignored.
if (!fn || reentry) return "";
var control, previousDispatcher, frame = componentFrameCache.get(fn);
if (void 0 !== frame) return frame;
reentry = !0;
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
Error.prepareStackTrace = void 0, previousDispatcher = ReactCurrentDispatcher$1.current, // for warnings.
ReactCurrentDispatcher$1.current = null, function() {
if (0 === disabledDepth) {
/* eslint-disable react-internal/no-production-logging */ prevLog = console.log, prevInfo = console.info, prevWarn = console.warn, prevError = console.error, prevGroup = console.group, prevGroupCollapsed = console.groupCollapsed, prevGroupEnd = console.groupEnd;
var props = {
configurable: !0,
enumerable: !0,
value: disabledLog,
writable: !0
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props
});
/* eslint-enable react-internal/no-production-logging */ }
disabledDepth++;
}();
try {
// This should throw.
if (construct) {
// Something should be setting the props in the constructor.
var Fake = function() {
throw Error();
}; // $FlowFixMe
if (Object.defineProperty(Fake.prototype, "props", {
set: function() {
// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throw Error();
}
}), "object" == typeof Reflect && Reflect.construct) {
// We construct a different control for this case to include any extra
// frames added by the construct call.
try {
Reflect.construct(Fake, []);
} catch (x) {
control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x) {
control = x;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x) {
control = x;
}
fn();
}
} catch (sample) {
// This is inlined manually because closure doesn't do it for us.
if (sample && control && "string" == typeof sample.stack) {
for(// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
var sampleLines = sample.stack.split("\n"), controlLines = control.stack.split("\n"), s = sampleLines.length - 1, c = controlLines.length - 1; s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c];)// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;
for(; s >= 1 && c >= 0; s--, c--)// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if (sampleLines[s] !== controlLines[c]) {
// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if (1 !== s || 1 !== c) do // The next one that isn't the same should be our match though.
if (s--, --c < 0 || sampleLines[s] !== controlLines[c]) {
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
return "function" == typeof fn && componentFrameCache.set(fn, _frame), _frame;
}
while (s >= 1 && c >= 0)
break;
}
}
} finally{
reentry = !1, ReactCurrentDispatcher$1.current = previousDispatcher, function() {
if (0 == --disabledDepth) {
/* eslint-disable react-internal/no-production-logging */ var props = {
configurable: !0,
enumerable: !0,
writable: !0
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
log: _assign({}, props, {
value: prevLog
}),
info: _assign({}, props, {
value: prevInfo
}),
warn: _assign({}, props, {
value: prevWarn
}),
error: _assign({}, props, {
value: prevError
}),
group: _assign({}, props, {
value: prevGroup
}),
groupCollapsed: _assign({}, props, {
value: prevGroupCollapsed
}),
groupEnd: _assign({}, props, {
value: prevGroupEnd
})
});
/* eslint-enable react-internal/no-production-logging */ }
disabledDepth < 0 && error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}(), Error.prepareStackTrace = previousPrepareStackTrace;
} // Fallback to just using the name if we couldn't make it throw.
var name = fn ? fn.displayName || fn.name : "", syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
return "function" == typeof fn && componentFrameCache.set(fn, syntheticFrame), syntheticFrame;
}
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (null == type) return "";
if ("function" == typeof type) return describeNativeComponentFrame(type, !!((prototype = type.prototype) && prototype.isReactComponent));
if ("string" == typeof type) return describeBuiltInComponentFrame(type);
switch(type){
case exports.Suspense:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if ("object" == typeof type) switch(type.$$typeof){
case REACT_FORWARD_REF_TYPE:
return describeNativeComponentFrame(type.render, !1);
case REACT_MEMO_TYPE:
// Memo may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
case REACT_BLOCK_TYPE:
return describeNativeComponentFrame(type._render, !1);
case REACT_LAZY_TYPE:
var prototype, payload = type._payload, init = type._init;
try {
// Lazy may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
} catch (x) {}
}
return "";
}
componentFrameCache = new ("function" == typeof WeakMap ? WeakMap : Map)();
var loggedTypeFailures = {}, ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element) {
if (element) {
var owner = element._owner, stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
function setCurrentlyValidatingElement$1(element) {
if (element) {
var owner = element._owner;
currentExtraStackFrame = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
} else currentExtraStackFrame = null;
}
function getDeclarationErrorAddendum() {
if (ReactCurrentOwner.current) {
var name = getComponentName(ReactCurrentOwner.current.type);
if (name) return "\n\nCheck the render method of `" + name + "`.";
}
return "";
}
propTypesMisspellWarningShown = !1;
/**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/ var ownerHasKeyUseWarning = {};
/**
* Warn if the element doesn't have an explicit key assigned to it.
* This element is in an array. The array could grow and shrink or be
* reordered. All children that haven't already been validated are required to
* have a "key" property assigned to it. Error statuses are cached so a warning
* will only be shown once.
*
* @internal
* @param {ReactElement} element Element that requires a key.
* @param {*} parentType element's parent's type.
*/ function validateExplicitKey(element, parentType) {
if (element._store && !element._store.validated && null == element.key) {
element._store.validated = !0;
var currentComponentErrorInfo = function(parentType) {
var info = getDeclarationErrorAddendum();
if (!info) {
var parentName = "string" == typeof parentType ? parentType : parentType.displayName || parentType.name;
parentName && (info = "\n\nCheck the top-level render call using <" + parentName + ">.");
}
return info;
}(parentType);
if (!ownerHasKeyUseWarning[currentComponentErrorInfo]) {
ownerHasKeyUseWarning[currentComponentErrorInfo] = !0;
// property, it may be the creator of the child that's responsible for
// assigning it a key.
var childOwner = "";
element && element._owner && element._owner !== ReactCurrentOwner.current && // Give the component that originally created this child.
(childOwner = " It was passed a child from " + getComponentName(element._owner.type) + "."), setCurrentlyValidatingElement$1(element), error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner), setCurrentlyValidatingElement$1(null);
}
}
}
/**
* Ensure that every element either is passed in a static location, in an
* array with an explicit keys property defined, or in an object literal
* with valid key property.
*
* @internal
* @param {ReactNode} node Statically passed child of any type.
* @param {*} parentType node's parent's type.
*/ function validateChildKeys(node, parentType) {
if ("object" == typeof node) {
if (Array.isArray(node)) for(var i = 0; i < node.length; i++){
var child = node[i];
isValidElement(child) && validateExplicitKey(child, parentType);
}
else if (isValidElement(node)) // This element was passed in a valid location.
node._store && (node._store.validated = !0);
else if (node) {
var iteratorFn = getIteratorFn(node);
if ("function" == typeof iteratorFn && iteratorFn !== node.entries) for(var step, iterator = iteratorFn.call(node); !(step = iterator.next()).done;)isValidElement(step.value) && validateExplicitKey(step.value, parentType);
}
}
}
/**
* Given an element, validate that its props follow the propTypes definition,
* provided by the type.
*
* @param {ReactElement} element
*/ function validatePropTypes(element) {
var propTypes, type = element.type;
if (null != type && "string" != typeof type) {
if ("function" == typeof type) propTypes = type.propTypes;
else {
if ("object" != typeof type || type.$$typeof !== REACT_FORWARD_REF_TYPE && // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
type.$$typeof !== REACT_MEMO_TYPE) return;
propTypes = type.propTypes;
}
if (propTypes) {
// Intentionally inside to avoid triggering lazy initializers:
var name = getComponentName(type);
!function(typeSpecs, values, location, componentName, element) {
// $FlowFixMe This is okay but Flow doesn't know it.
var has = Function.call.bind(Object.prototype.hasOwnProperty);
for(var typeSpecName in typeSpecs)if (has(typeSpecs, typeSpecName)) {
var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if ("function" != typeof typeSpecs[typeSpecName]) {
var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
throw err.name = "Invariant Violation", err;
}
error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (ex) {
error$1 = ex;
}
!error$1 || error$1 instanceof Error || (setCurrentlyValidatingElement(element), error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1), setCurrentlyValidatingElement(null)), error$1 instanceof Error && !(error$1.message in loggedTypeFailures) && (// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message] = !0, setCurrentlyValidatingElement(element), error("Failed %s type: %s", location, error$1.message), setCurrentlyValidatingElement(null));
}
}(propTypes, element.props, "prop", name, element);
} else void 0 === type.PropTypes || propTypesMisspellWarningShown || (propTypesMisspellWarningShown = !0, error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", getComponentName(type) || "Unknown"));
"function" != typeof type.getDefaultProps || type.getDefaultProps.isReactClassApproved || error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
}
}
function createElementWithValidation(type, props, children) {
var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
// succeed and there will likely be errors in render.
if (!validType) {
var typeString, info = "";
(void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
var sourceInfo = function(elementProps) {
if (null != elementProps) {
var source;
return void 0 !== (source = elementProps.__source) ? "\n\nCheck your code at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + "." : "";
}
return "";
}(props);
sourceInfo ? info += sourceInfo : info += getDeclarationErrorAddendum(), null === type ? typeString = "null" : Array.isArray(type) ? typeString = "array" : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE ? (typeString = "<" + (getComponentName(type.type) || "Unknown") + " />", info = " Did you accidentally export a JSX literal instead of a component?") : typeString = typeof type, error("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
}
var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
// TODO: Drop this when these are no longer allowed as the type argument.
if (null == element) return element;
// Skip key warning if the type isn't valid since our key validation logic
// doesn't expect a non-string/function type and can throw confusing errors.
// We don't want exception behavior to differ between dev and prod.
// (Rendering will throw with a helpful message and as soon as the type is
// fixed, the key warnings will appear.)
if (validType) for(var i = 2; i < arguments.length; i++)validateChildKeys(arguments[i], type);
return type === exports.Fragment ? /**
* Given a fragment, validate that it can only be provided with fragment props
* @param {ReactElement} fragment
*/ function(fragment) {
for(var keys = Object.keys(fragment.props), i = 0; i < keys.length; i++){
var key = keys[i];
if ("children" !== key && "key" !== key) {
setCurrentlyValidatingElement$1(fragment), error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key), setCurrentlyValidatingElement$1(null);
break;
}
}
null !== fragment.ref && (setCurrentlyValidatingElement$1(fragment), error("Invalid attribute `ref` supplied to `React.Fragment`."), setCurrentlyValidatingElement$1(null));
}(element) : validatePropTypes(element), element;
}
var didWarnAboutDeprecatedCreateFactory = !1;
try {
Object.freeze({});
/* eslint-enable no-new */ } catch (e) {}
exports.Children = {
map: mapChildren,
forEach: /**
* Iterates through children that are typically specified as `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenforeach
*
* The provided forEachFunc(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} forEachFunc
* @param {*} forEachContext Context for forEachContext.
*/ function(children, forEachFunc, forEachContext) {
mapChildren(children, function() {
forEachFunc.apply(this, arguments); // Don't return anything.
}, forEachContext);
},
count: /**
* Count the number of children that are typically specified as
* `props.children`.
*
* See https://reactjs.org/docs/react-api.html#reactchildrencount
*
* @param {?*} children Children tree container.
* @return {number} The number of children.
*/ function(children) {
var n = 0;
return mapChildren(children, function() {
n++; // Don't return anything
}), n;
},
toArray: /**
* Flatten a children object (typically specified as `props.children`) and
* return an array with appropriately re-keyed children.
*
* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
*/ function(children) {
return mapChildren(children, function(child) {
return child;
}) || [];
},
only: /**
* Returns the first child in a collection of children and verifies that there
* is only one child in the collection.
*
* See https://reactjs.org/docs/react-api.html#reactchildrenonly
*
* The current implementation of this function assumes that a single child gets
* passed without a wrapper, but the purpose of this helper function is to
* abstract away the particular structure of children.
*
* @param {?object} children Child collection structure.
* @return {ReactElement} The first and only `ReactElement` contained in the
* structure.
*/ function(children) {
if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child.");
return children;
}
}, exports.Component = Component, exports.PureComponent = PureComponent, exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals, exports.cloneElement = function(element, props, children) {
for(var newElement = cloneElement.apply(this, arguments), i = 2; i < arguments.length; i++)validateChildKeys(arguments[i], newElement.type);
return validatePropTypes(newElement), newElement;
}, exports.createContext = function(defaultValue, calculateChangedBits) {
void 0 === calculateChangedBits ? calculateChangedBits = null : null !== calculateChangedBits && "function" != typeof calculateChangedBits && error("createContext: Expected the optional second argument to be a function. Instead received: %s", calculateChangedBits);
var context = {
$$typeof: REACT_CONTEXT_TYPE,
_calculateChangedBits: calculateChangedBits,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
_currentValue: defaultValue,
_currentValue2: defaultValue,
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount: 0,
// These are circular
Provider: null,
Consumer: null
};
context.Provider = {
$$typeof: REACT_PROVIDER_TYPE,
_context: context
};
var hasWarnedAboutUsingNestedContextConsumers = !1, hasWarnedAboutUsingConsumerProvider = !1, hasWarnedAboutDisplayNameOnConsumer = !1, Consumer = {
$$typeof: REACT_CONTEXT_TYPE,
_context: context,
_calculateChangedBits: context._calculateChangedBits
};
return Object.defineProperties(Consumer, {
Provider: {
get: function() {
return hasWarnedAboutUsingConsumerProvider || (hasWarnedAboutUsingConsumerProvider = !0, error("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")), context.Provider;
},
set: function(_Provider) {
context.Provider = _Provider;
}
},
_currentValue: {
get: function() {
return context._currentValue;
},
set: function(_currentValue) {
context._currentValue = _currentValue;
}
},
_currentValue2: {
get: function() {
return context._currentValue2;
},
set: function(_currentValue2) {
context._currentValue2 = _currentValue2;
}
},
_threadCount: {
get: function() {
return context._threadCount;
},
set: function(_threadCount) {
context._threadCount = _threadCount;
}
},
Consumer: {
get: function() {
return hasWarnedAboutUsingNestedContextConsumers || (hasWarnedAboutUsingNestedContextConsumers = !0, error("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")), context.Consumer;
}
},
displayName: {
get: function() {
return context.displayName;
},
set: function(displayName) {
hasWarnedAboutDisplayNameOnConsumer || (warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName), hasWarnedAboutDisplayNameOnConsumer = !0);
}
}
}), context.Consumer = Consumer, context._currentRenderer = null, context._currentRenderer2 = null, context;
}, exports.createElement = createElementWithValidation, exports.createFactory = function(type) {
var validatedFactory = createElementWithValidation.bind(null, type);
return validatedFactory.type = type, didWarnAboutDeprecatedCreateFactory || (didWarnAboutDeprecatedCreateFactory = !0, warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(validatedFactory, "type", {
enumerable: !1,
get: function() {
return warn("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", {
value: type
}), type;
}
}), validatedFactory;
}, exports.createRef = // an immutable object with a single mutable value
function() {
var refObject = {
current: null
};
return Object.seal(refObject), refObject;
}, exports.forwardRef = function(render) {
null != render && render.$$typeof === REACT_MEMO_TYPE ? error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : "function" != typeof render ? error("forwardRef requires a render function but was given %s.", null === render ? "null" : typeof render) : 0 !== render.length && 2 !== render.length && error("forwardRef render functions accept exactly two parameters: props and ref. %s", 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), null != render && (null != render.defaultProps || null != render.propTypes) && error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
var ownName, elementType = {
$$typeof: REACT_FORWARD_REF_TYPE,
render: render
};
return Object.defineProperty(elementType, "displayName", {
enumerable: !1,
configurable: !0,
get: function() {
return ownName;
},
set: function(name) {
ownName = name, null == render.displayName && (render.displayName = name);
}
}), elementType;
}, exports.isValidElement = isValidElement, exports.lazy = function(ctor) {
var defaultProps, propTypes, lazyType = {
$$typeof: REACT_LAZY_TYPE,
_payload: {
// We use these fields to store the result.
_status: -1,
_result: ctor
},
_init: lazyInitializer
};
return Object.defineProperties(lazyType, {
defaultProps: {
configurable: !0,
get: function() {
return defaultProps;
},
set: function(newDefaultProps) {
error("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), defaultProps = newDefaultProps, // $FlowFixMe
Object.defineProperty(lazyType, "defaultProps", {
enumerable: !0
});
}
},
propTypes: {
configurable: !0,
get: function() {
return propTypes;
},
set: function(newPropTypes) {
error("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), propTypes = newPropTypes, // $FlowFixMe
Object.defineProperty(lazyType, "propTypes", {
enumerable: !0
});
}
}
}), lazyType;
}, exports.memo = function(type, compare) {
isValidElementType(type) || error("memo: The first argument must be a component. Instead received: %s", null === type ? "null" : typeof type);
var ownName, elementType = {
$$typeof: REACT_MEMO_TYPE,
type: type,
compare: void 0 === compare ? null : compare
};
return Object.defineProperty(elementType, "displayName", {
enumerable: !1,
configurable: !0,
get: function() {
return ownName;
},
set: function(name) {
ownName = name, null == type.displayName && (type.displayName = name);
}
}), elementType;
}, exports.useCallback = function(callback, deps) {
return resolveDispatcher().useCallback(callback, deps);
}, exports.useContext = function(Context, unstable_observedBits) {
var dispatcher = resolveDispatcher();
if (void 0 !== unstable_observedBits && error("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s", unstable_observedBits, "number" == typeof unstable_observedBits && Array.isArray(arguments[2]) ? "\n\nDid you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://reactjs.org/link/rules-of-hooks" : ""), void 0 !== Context._context) {
var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
// and nobody should be using this in existing code.
realContext.Consumer === Context ? error("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : realContext.Provider === Context && error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
}
return dispatcher.useContext(Context, unstable_observedBits);
}, exports.useDebugValue = function(value, formatterFn) {
return resolveDispatcher().useDebugValue(value, formatterFn);
}, exports.useEffect = function(create, deps) {
return resolveDispatcher().useEffect(create, deps);
}, exports.useImperativeHandle = function(ref, create, deps) {
return resolveDispatcher().useImperativeHandle(ref, create, deps);
}, exports.useLayoutEffect = function(create, deps) {
return resolveDispatcher().useLayoutEffect(create, deps);
}, exports.useMemo = function(create, deps) {
return resolveDispatcher().useMemo(create, deps);
}, exports.useReducer = function(reducer, initialArg, init) {
return resolveDispatcher().useReducer(reducer, initialArg, init);
}, exports.useRef = function(initialValue) {
return resolveDispatcher().useRef(initialValue);
}, exports.useState = function(initialState) {
return resolveDispatcher().useState(initialState);
}, exports.version = "17.0.1";
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/react-dom-17.0.2.js | JavaScript | !/** @license React v17.0.2
* react-dom.development.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/ function(global, factory) {
"object" == typeof exports && "undefined" != typeof module ? factory(exports, require("react")) : "function" == typeof define && define.amd ? define([
"exports",
"react"
], factory) : factory((global = global || self).ReactDOM = {}, global.React);
}(this, function(exports1, React) {
"use strict";
var func, devToolsConfig, findFiberByHostInstance, ReactCurrentDispatcher, prevLog, prevInfo, prevWarn, prevError, prevGroup, prevGroupCollapsed, prevGroupEnd, prefix, componentFrameCache, didWarnValueDefaultValue$1, reusableSVGContainer, attemptUserBlockingHydration, attemptContinuousHydration, attemptHydrationAtCurrentPriority, attemptHydrationAtPriority, lastMovementX, lastMovementY, lastMouseEvent, warnedUnknownTags, suppressHydrationWarning, validatePropertiesInDevelopment, warnForTextDifference, warnForPropDifference, warnForExtraAttributes, warnForInvalidEventListener, canDiffStyleForHydrationWarning, normalizeMarkupForTextOrAttribute, normalizeHTML, SUPPRESS_HYDRATION_WARNING$1, fiberStack, warnedAboutMissingGetChildContext, rendererSigil, didWarnUpdateInsideUpdate, currentlyProcessingQueue, didWarnAboutStateAssignmentForComponent, didWarnAboutUninitializedState, didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate, didWarnAboutLegacyLifecyclesAndDerivedState, didWarnAboutUndefinedDerivedState, warnOnUndefinedDerivedState, warnOnInvalidCallback, didWarnAboutDirectlyAssigningPropsToState, didWarnAboutContextTypeAndContextTypes, didWarnAboutInvalidateContextType, didWarnAboutMaps, didWarnAboutGenerators, didWarnAboutStringRefs, ownerHasKeyUseWarning, ownerHasFunctionTypeWarning, rendererSigil$1, didWarnAboutMismatchedHooksForComponent, didWarnAboutUseOpaqueIdentifier, didWarnAboutBadClass, didWarnAboutModulePatternComponent, didWarnAboutContextTypeOnFunctionComponent, didWarnAboutGetDerivedStateOnFunctionComponent, didWarnAboutFunctionRefs, didWarnAboutReassigningProps, didWarnAboutRevealOrder, didWarnAboutTailOptions, appendAllChildren, updateHostContainer, updateHostComponent$1, updateHostText$1, beginWork$1, didWarnAboutUpdateInRenderForAnotherComponent, hasBadMapPolyfill, didWarnAboutNestedUpdates, didWarnAboutFindNodeInStrictMode, topLevelUpdateWarnings, ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
// by calls to these methods by a Babel plugin.
//
// In PROD (or in packages without access to React internals),
// they are left as they are instead.
function warn(format) {
for(var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++)args[_key - 1] = arguments[_key];
printWarning("warn", format, args);
}
function error(format) {
for(var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++)args[_key2 - 1] = arguments[_key2];
printWarning("error", format, args);
}
function printWarning(level, format, args) {
var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
"" !== stack && (format += "%s", args = args.concat([
stack
]));
var argsWithFormat = args.map(function(item) {
return "" + item;
}); // Careful: RN currently depends on this prefix
argsWithFormat.unshift("Warning: " + format), // breaks IE9: https://github.com/facebook/react/issues/13610
// eslint-disable-next-line react-internal/no-production-logging
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
if (!React) throw Error("ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.");
var allNativeEvents = new Set(), registrationNameDependencies = {}, possibleRegistrationNames = {};
function registerTwoPhaseEvent(registrationName, dependencies) {
registerDirectEvent(registrationName, dependencies), registerDirectEvent(registrationName + "Capture", dependencies);
}
function registerDirectEvent(registrationName, dependencies) {
registrationNameDependencies[registrationName] && error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName), registrationNameDependencies[registrationName] = dependencies, possibleRegistrationNames[registrationName.toLowerCase()] = registrationName, "onDoubleClick" === registrationName && (possibleRegistrationNames.ondblclick = registrationName);
for(var i = 0; i < dependencies.length; i++)allNativeEvents.add(dependencies[i]);
}
var canUseDOM = "undefined" != typeof window && void 0 !== window.document && void 0 !== window.document.createElement, ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD", ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + "\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040", ROOT_ATTRIBUTE_NAME = "data-reactroot", VALID_ATTRIBUTE_NAME_REGEX = RegExp("^[" + ATTRIBUTE_NAME_START_CHAR + "][" + ATTRIBUTE_NAME_CHAR + "]*$"), hasOwnProperty = Object.prototype.hasOwnProperty, illegalAttributeNameCache = {}, validatedAttributeNameCache = {};
function isAttributeNameSafe(attributeName) {
return !!hasOwnProperty.call(validatedAttributeNameCache, attributeName) || !hasOwnProperty.call(illegalAttributeNameCache, attributeName) && (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName) ? (validatedAttributeNameCache[attributeName] = !0, !0) : (illegalAttributeNameCache[attributeName] = !0, error("Invalid attribute name: `%s`", attributeName), !1));
}
function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) {
return null !== propertyInfo ? 0 === propertyInfo.type : !isCustomComponentTag && !!(name.length > 2) && ("o" === name[0] || "O" === name[0]) && ("n" === name[1] || "N" === name[1]);
}
function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {
if (null !== propertyInfo && 0 === propertyInfo.type) return !1;
switch(typeof value){
case "function":
case "symbol":
// eslint-disable-line
return !0;
case "boolean":
if (isCustomComponentTag) return !1;
if (null !== propertyInfo) return !propertyInfo.acceptsBooleans;
var prefix = name.toLowerCase().slice(0, 5);
return "data-" !== prefix && "aria-" !== prefix;
default:
return !1;
}
}
function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) {
if (null == value || shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) return !0;
if (isCustomComponentTag) return !1;
if (null !== propertyInfo) switch(propertyInfo.type){
case 3:
return !value;
case 4:
return !1 === value;
case 5:
return isNaN(value);
case 6:
return isNaN(value) || value < 1;
}
return !1;
}
function getPropertyInfo(name) {
return properties.hasOwnProperty(name) ? properties[name] : null;
}
function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL, removeEmptyString) {
this.acceptsBooleans = 2 === type || 3 === type || 4 === type, this.attributeName = attributeName, this.attributeNamespace = attributeNamespace, this.mustUseProperty = mustUseProperty, this.propertyName = name, this.type = type, this.sanitizeURL = sanitizeURL, this.removeEmptyString = removeEmptyString;
} // When adding attributes to this list, be sure to also add them to
// the `possibleStandardNames` module to ensure casing and incorrect
// name warnings.
var properties = {}; // These props are reserved by React. They shouldn't be written to the DOM.
[
"children",
"dangerouslySetInnerHTML",
// elements (not just inputs). Now that ReactDOMInput assigns to the
// defaultValue property -- do we need this?
"defaultValue",
"defaultChecked",
"innerHTML",
"suppressContentEditableWarning",
"suppressHydrationWarning",
"style"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 0, !1, name, null, !1, !1);
}), // This is a mapping from React prop names to the attribute names.
[
[
"acceptCharset",
"accept-charset"
],
[
"className",
"class"
],
[
"htmlFor",
"for"
],
[
"httpEquiv",
"http-equiv"
]
].forEach(function(_ref) {
var name = _ref[0], attributeName = _ref[1];
properties[name] = new PropertyInfoRecord(name, 1, !1, attributeName, null, !1, !1);
}), // In React, we let users pass `true` and `false` even though technically
// these aren't boolean attributes (they are coerced to strings).
[
"contentEditable",
"draggable",
"spellCheck",
"value"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 2, !1, name.toLowerCase(), null, !1, !1);
}), // In React, we let users pass `true` and `false` even though technically
// these aren't boolean attributes (they are coerced to strings).
// Since these are SVG attributes, their attribute names are case-sensitive.
[
"autoReverse",
"externalResourcesRequired",
"focusable",
"preserveAlpha"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 2, !1, name, null, !1, !1);
}), [
"allowFullScreen",
"async",
// on the client side because the browsers are inconsistent. Instead we call focus().
"autoFocus",
"autoPlay",
"controls",
"default",
"defer",
"disabled",
"disablePictureInPicture",
"disableRemotePlayback",
"formNoValidate",
"hidden",
"loop",
"noModule",
"noValidate",
"open",
"playsInline",
"readOnly",
"required",
"reversed",
"scoped",
"seamless",
"itemScope"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 3, !1, name.toLowerCase(), null, !1, !1);
}), // rather than attributes. These are all booleans.
[
"checked",
// disabled with `removeAttribute`. We have special logic for handling this.
"multiple",
"muted",
"selected"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 3, !0, name, null, !1, !1);
}), // booleans, but can also accept a string value.
[
"capture",
"download"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 4, !1, name, null, !1, !1);
}), [
"cols",
"rows",
"size",
"span"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 6, !1, name, null, !1, !1);
}), [
"rowSpan",
"start"
].forEach(function(name) {
properties[name] = new PropertyInfoRecord(name, 5, !1, name.toLowerCase(), null, !1, !1);
});
var CAMELIZE = /[\-\:]([a-z])/g, capitalize = function(token) {
return token[1].toUpperCase();
};
// or boolean value assignment. Regular attributes that just accept strings
// and have the same names are omitted, just like in the HTML attribute filter.
// Some of these attributes can be hard to find. This list was created by
// scraping the MDN documentation.
[
"accent-height",
"alignment-baseline",
"arabic-form",
"baseline-shift",
"cap-height",
"clip-path",
"clip-rule",
"color-interpolation",
"color-interpolation-filters",
"color-profile",
"color-rendering",
"dominant-baseline",
"enable-background",
"fill-opacity",
"fill-rule",
"flood-color",
"flood-opacity",
"font-family",
"font-size",
"font-size-adjust",
"font-stretch",
"font-style",
"font-variant",
"font-weight",
"glyph-name",
"glyph-orientation-horizontal",
"glyph-orientation-vertical",
"horiz-adv-x",
"horiz-origin-x",
"image-rendering",
"letter-spacing",
"lighting-color",
"marker-end",
"marker-mid",
"marker-start",
"overline-position",
"overline-thickness",
"paint-order",
"panose-1",
"pointer-events",
"rendering-intent",
"shape-rendering",
"stop-color",
"stop-opacity",
"strikethrough-position",
"strikethrough-thickness",
"stroke-dasharray",
"stroke-dashoffset",
"stroke-linecap",
"stroke-linejoin",
"stroke-miterlimit",
"stroke-opacity",
"stroke-width",
"text-anchor",
"text-decoration",
"text-rendering",
"underline-position",
"underline-thickness",
"unicode-bidi",
"unicode-range",
"units-per-em",
"v-alphabetic",
"v-hanging",
"v-ideographic",
"v-mathematical",
"vector-effect",
"vert-adv-y",
"vert-origin-x",
"vert-origin-y",
"word-spacing",
"writing-mode",
"xmlns:xlink",
"x-height"
].forEach(function(attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(name, 1, !1, attributeName, null, !1, !1);
}), [
"xlink:actuate",
"xlink:arcrole",
"xlink:role",
"xlink:show",
"xlink:title",
"xlink:type"
].forEach(function(attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(name, 1, !1, attributeName, "http://www.w3.org/1999/xlink", !1, !1);
}), [
"xml:base",
"xml:lang",
"xml:space"
].forEach(function(attributeName) {
var name = attributeName.replace(CAMELIZE, capitalize);
properties[name] = new PropertyInfoRecord(name, 1, !1, attributeName, "http://www.w3.org/XML/1998/namespace", !1, !1);
}), // The attribute name is case-sensitive in SVG so we can't just use
// the React name like we do for attributes that exist only in HTML.
[
"tabIndex",
"crossOrigin"
].forEach(function(attributeName) {
properties[attributeName] = new PropertyInfoRecord(attributeName, 1, !1, attributeName.toLowerCase(), null, !1, !1);
}), properties.xlinkHref = new PropertyInfoRecord("xlinkHref", 1, !1, "xlink:href", "http://www.w3.org/1999/xlink", !0, !1), [
"src",
"href",
"action",
"formAction"
].forEach(function(attributeName) {
properties[attributeName] = new PropertyInfoRecord(attributeName, 1, !1, attributeName.toLowerCase(), null, !0, !0);
});
// and any newline or tab are filtered out as if they're not part of the URL.
// https://url.spec.whatwg.org/#url-parsing
// Tab or newline are defined as \r\n\t:
// https://infra.spec.whatwg.org/#ascii-tab-or-newline
// A C0 control is a code point in the range \u0000 NULL to \u001F
// INFORMATION SEPARATOR ONE, inclusive:
// https://infra.spec.whatwg.org/#c0-control-or-space
/* eslint-disable max-len */ var isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*\:/i, didWarn = !1;
function sanitizeURL(url) {
!didWarn && isJavaScriptProtocol.test(url) && (didWarn = !0, error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML try using dangerouslySetInnerHTML instead. React was passed %s.", JSON.stringify(url)));
}
/**
* Get the value for a attribute on a node. Only used in DEV for SSR validation.
* The third argument is used as a hint of what the expected value is. Some
* attributes have multiple equivalent values.
*/ function getValueForAttribute(node, name, expected) {
if (isAttributeNameSafe(name)) {
// the next prop is different than the server value, so just return
// expected
if (null !== (value = expected) && "object" == typeof value && value.$$typeof === REACT_OPAQUE_ID_TYPE) return expected;
if (!node.hasAttribute(name)) return void 0 === expected ? void 0 : null;
var value, value1 = node.getAttribute(name);
return value1 === "" + expected ? expected : value1;
} // If the object is an opaque reference ID, it's expected that
}
/**
* Sets the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
* @param {*} value
*/ function setValueForProperty(node, name, value, isCustomComponentTag) {
var propertyInfo = getPropertyInfo(name);
if (!shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) {
if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) && (value = null), isCustomComponentTag || null === propertyInfo) {
isAttributeNameSafe(name) && (null === value ? node.removeAttribute(name) : node.setAttribute(name, "" + value));
return;
}
if (propertyInfo.mustUseProperty) {
var propertyName = propertyInfo.propertyName;
if (null === value) {
var type = propertyInfo.type;
node[propertyName] = 3 !== type && "";
} else // Contrary to `setAttribute`, object properties are properly
// `toString`ed by IE8/9.
node[propertyName] = value;
return;
} // The rest are treated as attributes with special cases.
var attributeName = propertyInfo.attributeName, attributeNamespace = propertyInfo.attributeNamespace;
if (null === value) node.removeAttribute(attributeName);
else {
var attributeValue, _type = propertyInfo.type;
3 === _type || 4 === _type && !0 === value ? // If attribute type is boolean, we know for sure it won't be an execution sink
// and we won't require Trusted Type here.
attributeValue = "" : (attributeValue = "" + value, propertyInfo.sanitizeURL && sanitizeURL(attributeValue.toString())), attributeNamespace ? node.setAttributeNS(attributeNamespace, attributeName, attributeValue) : node.setAttribute(attributeName, attributeValue);
}
}
}
var _assign = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.assign, REACT_ELEMENT_TYPE = 0xeac7, REACT_PORTAL_TYPE = 0xeaca, REACT_FRAGMENT_TYPE = 0xeacb, REACT_STRICT_MODE_TYPE = 0xeacc, REACT_PROFILER_TYPE = 0xead2, REACT_PROVIDER_TYPE = 0xeacd, REACT_CONTEXT_TYPE = 0xeace, REACT_FORWARD_REF_TYPE = 0xead0, REACT_SUSPENSE_TYPE = 0xead1, REACT_SUSPENSE_LIST_TYPE = 0xead8, REACT_MEMO_TYPE = 0xead3, REACT_LAZY_TYPE = 0xead4, REACT_BLOCK_TYPE = 0xead9, REACT_SCOPE_TYPE = 0xead7, REACT_OPAQUE_ID_TYPE = 0xeae0, REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1, REACT_OFFSCREEN_TYPE = 0xeae2, REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
if ("function" == typeof Symbol && Symbol.for) {
var symbolFor = Symbol.for;
REACT_ELEMENT_TYPE = symbolFor("react.element"), REACT_PORTAL_TYPE = symbolFor("react.portal"), REACT_FRAGMENT_TYPE = symbolFor("react.fragment"), REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode"), REACT_PROFILER_TYPE = symbolFor("react.profiler"), REACT_PROVIDER_TYPE = symbolFor("react.provider"), REACT_CONTEXT_TYPE = symbolFor("react.context"), REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref"), REACT_SUSPENSE_TYPE = symbolFor("react.suspense"), REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list"), REACT_MEMO_TYPE = symbolFor("react.memo"), REACT_LAZY_TYPE = symbolFor("react.lazy"), REACT_BLOCK_TYPE = symbolFor("react.block"), symbolFor("react.server.block"), symbolFor("react.fundamental"), symbolFor("react.scope"), REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id"), REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode"), REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen"), REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
}
var MAYBE_ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator;
function getIteratorFn(maybeIterable) {
if (null === maybeIterable || "object" != typeof maybeIterable) return null;
var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
return "function" == typeof maybeIterator ? maybeIterator : null;
}
// Helpers to patch console.logs to avoid logging during side-effect free
// replaying on render function. This currently only patches the object
// lazily which won't cover if the log function was extracted eagerly.
// We could also eagerly patch the method.
var disabledDepth = 0;
function disabledLog() {}
function disableLogs() {
if (0 === disabledDepth) {
/* eslint-disable react-internal/no-production-logging */ prevLog = console.log, prevInfo = console.info, prevWarn = console.warn, prevError = console.error, prevGroup = console.group, prevGroupCollapsed = console.groupCollapsed, prevGroupEnd = console.groupEnd;
var props = {
configurable: !0,
enumerable: !0,
value: disabledLog,
writable: !0
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props
});
/* eslint-enable react-internal/no-production-logging */ }
disabledDepth++;
}
function reenableLogs() {
if (0 == --disabledDepth) {
/* eslint-disable react-internal/no-production-logging */ var props = {
configurable: !0,
enumerable: !0,
writable: !0
}; // $FlowFixMe Flow thinks console is immutable.
Object.defineProperties(console, {
log: _assign({}, props, {
value: prevLog
}),
info: _assign({}, props, {
value: prevInfo
}),
warn: _assign({}, props, {
value: prevWarn
}),
error: _assign({}, props, {
value: prevError
}),
group: _assign({}, props, {
value: prevGroup
}),
groupCollapsed: _assign({}, props, {
value: prevGroupCollapsed
}),
groupEnd: _assign({}, props, {
value: prevGroupEnd
})
});
/* eslint-enable react-internal/no-production-logging */ }
disabledDepth < 0 && error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}
disabledLog.__reactDisabledLog = !0;
var ReactCurrentDispatcher1 = ReactSharedInternals.ReactCurrentDispatcher;
function describeBuiltInComponentFrame(name, source, ownerFn) {
if (void 0 === prefix) // Extract the VM specific prefix used by each line.
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = match && match[1] || "";
}
// We use the prefix to ensure our stacks line up with native stack frames.
return "\n" + prefix + name;
}
var reentry = !1;
function describeNativeComponentFrame(fn, construct) {
// If something asked for a stack inside a fake render, it should get ignored.
if (!fn || reentry) return "";
var control, previousDispatcher, frame = componentFrameCache.get(fn);
if (void 0 !== frame) return frame;
reentry = !0;
var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
Error.prepareStackTrace = void 0, previousDispatcher = ReactCurrentDispatcher1.current, // for warnings.
ReactCurrentDispatcher1.current = null, disableLogs();
try {
// This should throw.
if (construct) {
// Something should be setting the props in the constructor.
var Fake = function() {
throw Error();
}; // $FlowFixMe
if (Object.defineProperty(Fake.prototype, "props", {
set: function() {
// We use a throwing setter instead of frozen or non-writable props
// because that won't throw in a non-strict mode function.
throw Error();
}
}), "object" == typeof Reflect && Reflect.construct) {
// We construct a different control for this case to include any extra
// frames added by the construct call.
try {
Reflect.construct(Fake, []);
} catch (x) {
control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x) {
control = x;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x) {
control = x;
}
fn();
}
} catch (sample) {
// This is inlined manually because closure doesn't do it for us.
if (sample && control && "string" == typeof sample.stack) {
for(// This extracts the first frame from the sample that isn't also in the control.
// Skipping one frame that we assume is the frame that calls the two.
var sampleLines = sample.stack.split("\n"), controlLines = control.stack.split("\n"), s = sampleLines.length - 1, c = controlLines.length - 1; s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c];)// We expect at least one stack frame to be shared.
// Typically this will be the root most one. However, stack frames may be
// cut off due to maximum stack limits. In this case, one maybe cut off
// earlier than the other. We assume that the sample is longer or the same
// and there for cut off earlier. So we should find the root most frame in
// the sample somewhere in the control.
c--;
for(; s >= 1 && c >= 0; s--, c--)// Next we find the first one that isn't the same which should be the
// frame that called our sample function and the control.
if (sampleLines[s] !== controlLines[c]) {
// In V8, the first line is describing the message but other VMs don't.
// If we're about to return the first line, and the control is also on the same
// line, that's a pretty good indicator that our sample threw at same line as
// the control. I.e. before we entered the sample frame. So we ignore this result.
// This can happen if you passed a class to function component, or non-function.
if (1 !== s || 1 !== c) do // The next one that isn't the same should be our match though.
if (s--, --c < 0 || sampleLines[s] !== controlLines[c]) {
// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
return "function" == typeof fn && componentFrameCache.set(fn, _frame), _frame;
}
while (s >= 1 && c >= 0)
break;
}
}
} finally{
reentry = !1, ReactCurrentDispatcher1.current = previousDispatcher, reenableLogs(), Error.prepareStackTrace = previousPrepareStackTrace;
} // Fallback to just using the name if we couldn't make it throw.
var name = fn ? fn.displayName || fn.name : "", syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
return "function" == typeof fn && componentFrameCache.set(fn, syntheticFrame), syntheticFrame;
}
componentFrameCache = new ("function" == typeof WeakMap ? WeakMap : Map)();
function getStackByFiberInDevAndProd(workInProgress) {
try {
var info = "", node = workInProgress;
do info += function(fiber) {
switch(fiber._debugOwner && fiber._debugOwner.type, fiber._debugSource, fiber.tag){
case 5:
return describeBuiltInComponentFrame(fiber.type);
case 16:
return describeBuiltInComponentFrame("Lazy");
case 13:
return describeBuiltInComponentFrame("Suspense");
case 19:
return describeBuiltInComponentFrame("SuspenseList");
case 0:
case 2:
case 15:
return describeNativeComponentFrame(fiber.type, !1);
case 11:
return describeNativeComponentFrame(fiber.type.render, !1);
case 22:
return describeNativeComponentFrame(fiber.type._render, !1);
case 1:
return describeNativeComponentFrame(fiber.type, !0);
default:
return "";
}
}(node), node = node.return;
while (node)
return info;
} catch (x) {
return "\nError generating stack: " + x.message + "\n" + x.stack;
}
}
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentName(type) {
if (null == type) // Host root, text node or just invalid type.
return null;
if ("number" == typeof type.tag && error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."), "function" == typeof type) return type.displayName || type.name || null;
if ("string" == typeof type) return type;
switch(type){
case REACT_FRAGMENT_TYPE:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case REACT_PROFILER_TYPE:
return "Profiler";
case REACT_STRICT_MODE_TYPE:
return "StrictMode";
case REACT_SUSPENSE_TYPE:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if ("object" == typeof type) switch(type.$$typeof){
case REACT_CONTEXT_TYPE:
return getContextName(type) + ".Consumer";
case REACT_PROVIDER_TYPE:
return getContextName(type._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
var innerType, wrapperName, functionName;
return innerType = type.render, wrapperName = "ForwardRef", functionName = innerType.displayName || innerType.name || "", type.displayName || ("" !== functionName ? wrapperName + "(" + functionName + ")" : wrapperName);
case REACT_MEMO_TYPE:
return getComponentName(type.type);
case REACT_BLOCK_TYPE:
return getComponentName(type._render);
case REACT_LAZY_TYPE:
var payload = type._payload, init = type._init;
try {
return getComponentName(init(payload));
} catch (x) {}
}
return null;
}
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame, current = null, isRendering = !1;
function getCurrentFiberOwnerNameInDevOrNull() {
if (null === current) return null;
var owner = current._debugOwner;
return null != owner ? getComponentName(owner.type) : null;
}
function getCurrentFiberStackInDev() {
return null === current ? "" : getStackByFiberInDevAndProd(current) // Safe because if current fiber exists, we are reconciling,
;
}
function resetCurrentFiber() {
ReactDebugCurrentFrame.getCurrentStack = null, current = null, isRendering = !1;
}
function setCurrentFiber(fiber) {
ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev, current = fiber, isRendering = !1;
}
function getToStringValue(value) {
switch(typeof value){
case "boolean":
case "number":
case "object":
case "string":
case "undefined":
return value;
default:
// function, symbol are assigned as empty strings
return "";
}
}
var hasReadOnlyValue = {
button: !0,
checkbox: !0,
image: !0,
hidden: !0,
radio: !0,
reset: !0,
submit: !0
};
function checkControlledValueProps(tagName, props) {
hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || null == props.value || error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`."), props.onChange || props.readOnly || props.disabled || null == props.checked || error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`.");
}
function isCheckable(elem) {
var type = elem.type, nodeName = elem.nodeName;
return nodeName && "input" === nodeName.toLowerCase() && ("checkbox" === type || "radio" === type);
}
function getTracker(node) {
return node._valueTracker;
}
function track(node) {
!getTracker(node) && (node._valueTracker = function(node) {
var valueField = isCheckable(node) ? "checked" : "value", descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField), currentValue = "" + node[valueField];
// and don't track value will cause over reporting of changes,
// but it's better then a hard failure
// (needed for certain tests that spyOn input values and Safari)
if (!node.hasOwnProperty(valueField) && void 0 !== descriptor && "function" == typeof descriptor.get && "function" == typeof descriptor.set) {
var get = descriptor.get, set = descriptor.set;
return Object.defineProperty(node, valueField, {
configurable: !0,
get: function() {
return get.call(this);
},
set: function(value) {
currentValue = "" + value, set.call(this, value);
}
}), // but it triggers a bug in IE11 and Edge 14/15.
// Calling defineProperty() again should be equivalent.
// https://github.com/facebook/react/issues/11768
Object.defineProperty(node, valueField, {
enumerable: descriptor.enumerable
}), {
getValue: function() {
return currentValue;
},
setValue: function(value) {
currentValue = "" + value;
},
stopTracking: function() {
node._valueTracker = null, delete node[valueField];
}
};
}
}(node)); // TODO: Once it's just Fiber we can move this to node._wrapperState
}
function updateValueIfChanged(node) {
if (!node) return !1;
var value, tracker = getTracker(node); // if there is no tracker at this point it's unlikely
// that trying again will succeed
if (!tracker) return !0;
var lastValue = tracker.getValue(), nextValue = (value = "", node ? value = isCheckable(node) ? node.checked ? "true" : "false" : node.value : value);
return nextValue !== lastValue && (tracker.setValue(nextValue), !0);
}
function getActiveElement(doc) {
if (void 0 === (doc = doc || ("undefined" != typeof document ? document : void 0))) return null;
try {
return doc.activeElement || doc.body;
} catch (e) {
return doc.body;
}
}
var didWarnValueDefaultValue = !1, didWarnCheckedDefaultChecked = !1, didWarnControlledToUncontrolled = !1, didWarnUncontrolledToControlled = !1;
function isControlled(props) {
return "checkbox" === props.type || "radio" === props.type ? null != props.checked : null != props.value;
}
/**
* Implements an <input> host component that allows setting these optional
* props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
*
* If `checked` or `value` are not supplied (or null/undefined), user actions
* that affect the checked state or value will trigger updates to the element.
*
* If they are supplied (and not null/undefined), the rendered element will not
* trigger updates to the element. Instead, the props must change in order for
* the rendered element to be updated.
*
* The rendered element will be initialized as unchecked (or `defaultChecked`)
* with an empty value (or `defaultValue`).
*
* See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
*/ function getHostProps(element, props) {
var checked = props.checked;
return _assign({}, props, {
defaultChecked: void 0,
defaultValue: void 0,
value: void 0,
checked: null != checked ? checked : element._wrapperState.initialChecked
});
}
function initWrapperState(element, props) {
checkControlledValueProps("input", props), void 0 === props.checked || void 0 === props.defaultChecked || didWarnCheckedDefaultChecked || (error("%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type), didWarnCheckedDefaultChecked = !0), void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue || (error("%s contains an input of type %s with both value and defaultValue props. Input elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type), didWarnValueDefaultValue = !0);
var defaultValue = null == props.defaultValue ? "" : props.defaultValue;
element._wrapperState = {
initialChecked: null != props.checked ? props.checked : props.defaultChecked,
initialValue: getToStringValue(null != props.value ? props.value : defaultValue),
controlled: isControlled(props)
};
}
function updateChecked(element, props) {
var checked = props.checked;
null != checked && setValueForProperty(element, "checked", checked, !1);
}
function updateWrapper(element, props) {
var controlled = isControlled(props);
element._wrapperState.controlled || !controlled || didWarnUncontrolledToControlled || (error("A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"), didWarnUncontrolledToControlled = !0), !element._wrapperState.controlled || controlled || didWarnControlledToUncontrolled || (error("A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"), didWarnControlledToUncontrolled = !0), updateChecked(element, props);
var value = getToStringValue(props.value), type = props.type;
if (null != value) "number" === type ? (0 === value && "" === element.value || // We explicitly want to coerce to number here if possible.
// eslint-disable-next-line
element.value != value) && (element.value = "" + value) : element.value !== "" + value && (element.value = "" + value);
else if ("submit" === type || "reset" === type) {
// Submit/reset inputs need the attribute removed completely to avoid
// blank-text buttons.
element.removeAttribute("value");
return;
}
props.hasOwnProperty("value") ? setDefaultValue(element, props.type, value) : props.hasOwnProperty("defaultValue") && setDefaultValue(element, props.type, getToStringValue(props.defaultValue)), null == props.checked && null != props.defaultChecked && (element.defaultChecked = !!props.defaultChecked);
}
function postMountWrapper(element, props, isHydrating) {
// from being lost during SSR hydration.
if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) {
var type = props.type;
// default value provided by the browser. See: #12872
if (("submit" === type || "reset" === type) && (void 0 === props.value || null === props.value)) return;
var initialValue = "" + element._wrapperState.initialValue; // Do not assign value if it is already set. This prevents user text input
isHydrating || initialValue === element.value || (element.value = initialValue), // Otherwise, the value attribute is synchronized to the property,
// so we assign defaultValue to the same thing as the value property
// assignment step above.
element.defaultValue = initialValue;
} // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
// this is needed to work around a chrome bug where setting defaultChecked
// will sometimes influence the value of checked (even after detachment).
// Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
// We need to temporarily unset name to avoid disrupting radio button groups.
var name = element.name;
"" !== name && (element.name = ""), // When syncing the checked attribute, both the checked property and
// attribute are assigned at the same time using defaultChecked. This uses:
//
// 1. The checked React property when present
// 2. The defaultChecked React property when present
// 3. Otherwise, false
element.defaultChecked = !element.defaultChecked, element.defaultChecked = !!element._wrapperState.initialChecked, "" !== name && (element.name = name);
}
// For number inputs, the display value loses trailing decimal points. For email inputs,
// Chrome raises "The specified value <x> is not a valid email address".
//
// Here we check to see if the defaultValue has actually changed, avoiding these problems
// when the user is inputting text
//
// https://github.com/facebook/react/issues/7253
function setDefaultValue(node, type, value) {
// Focused number inputs synchronize on blur. See ChangeEventPlugin.js
("number" !== type || getActiveElement(node.ownerDocument) !== node) && (null == value ? node.defaultValue = "" + node._wrapperState.initialValue : node.defaultValue !== "" + value && (node.defaultValue = "" + value));
}
var didWarnSelectedSetOnOption = !1, didWarnInvalidChild = !1;
/**
* Implements an <option> host component that warns when `selected` is set.
*/ function validateProps(element, props) {
"object" == typeof props.children && null !== props.children && React.Children.forEach(props.children, function(child) {
null != child && "string" != typeof child && "number" != typeof child && "string" == typeof child.type && (didWarnInvalidChild || (didWarnInvalidChild = !0, error("Only strings and numbers are supported as <option> children.")));
}), null == props.selected || didWarnSelectedSetOnOption || (error("Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>."), didWarnSelectedSetOnOption = !0);
}
function getHostProps$1(element, props) {
var children, content, hostProps = _assign({
children: void 0
}, props), content1 = (children = props.children, content = "", // during validateProps() which runs for hydration too.
// Note that this would throw on non-element objects.
// Elements are stringified (which is normally irrelevant
// but matters for <fbt>).
React.Children.forEach(children, function(child) {
null != child && (content += child);
// Instead, this is done separately below so that
// it happens during the hydration code path too.
}), content);
return content1 && (hostProps.children = content1), hostProps;
}
function getDeclarationErrorAddendum() {
var ownerName = getCurrentFiberOwnerNameInDevOrNull();
return ownerName ? "\n\nCheck the render method of `" + ownerName + "`." : "";
}
didWarnValueDefaultValue$1 = !1;
var valuePropNames = [
"value",
"defaultValue"
];
function updateOptions(node, multiple, propValue, setDefaultSelected) {
var options = node.options;
if (multiple) {
for(var selectedValue = {}, i = 0; i < propValue.length; i++)// Prefix to avoid chaos with special keys.
selectedValue["$" + propValue[i]] = !0;
for(var _i = 0; _i < options.length; _i++){
var selected = selectedValue.hasOwnProperty("$" + options[_i].value);
options[_i].selected !== selected && (options[_i].selected = selected), selected && setDefaultSelected && (options[_i].defaultSelected = !0);
}
} else {
for(var _selectedValue = "" + getToStringValue(propValue), defaultSelected = null, _i2 = 0; _i2 < options.length; _i2++){
if (options[_i2].value === _selectedValue) {
options[_i2].selected = !0, setDefaultSelected && (options[_i2].defaultSelected = !0);
return;
}
null !== defaultSelected || options[_i2].disabled || (defaultSelected = options[_i2]);
}
null !== defaultSelected && (defaultSelected.selected = !0);
}
}
/**
* Implements a <select> host component that allows optionally setting the
* props `value` and `defaultValue`. If `multiple` is false, the prop must be a
* stringable. If `multiple` is true, the prop must be an array of stringables.
*
* If `value` is not supplied (or null/undefined), user actions that change the
* selected option will trigger updates to the rendered options.
*
* If it is supplied (and not null/undefined), the rendered options will not
* update in response to user actions. Instead, the `value` prop must change in
* order for the rendered options to update.
*
* If `defaultValue` is provided, any options with the supplied values will be
* selected.
*/ function getHostProps$2(element, props) {
return _assign({}, props, {
value: void 0
});
}
function initWrapperState$1(element, props) {
!/**
* Validation function for `value` and `defaultValue`.
*/ function(props) {
checkControlledValueProps("select", props);
for(var i = 0; i < valuePropNames.length; i++){
var propName = valuePropNames[i];
if (null != props[propName]) {
var isArray = Array.isArray(props[propName]);
props.multiple && !isArray ? error("The `%s` prop supplied to <select> must be an array if `multiple` is true.%s", propName, getDeclarationErrorAddendum()) : !props.multiple && isArray && error("The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.%s", propName, getDeclarationErrorAddendum());
}
}
}(props), element._wrapperState = {
wasMultiple: !!props.multiple
}, void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue$1 || (error("Select elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled select element and remove one of these props. More info: https://reactjs.org/link/controlled-components"), didWarnValueDefaultValue$1 = !0);
}
var didWarnValDefaultVal = !1;
/**
* Implements a <textarea> host component that allows setting `value`, and
* `defaultValue`. This differs from the traditional DOM API because value is
* usually set as PCDATA children.
*
* If `value` is not supplied (or null/undefined), user actions that affect the
* value will trigger updates to the element.
*
* If `value` is supplied (and not null/undefined), the rendered element will
* not trigger updates to the element. Instead, the `value` prop must change in
* order for the rendered element to be updated.
*
* The rendered element will be initialized with an empty value, the prop
* `defaultValue` if specified, or the children content (deprecated).
*/ function getHostProps$3(element, props) {
if (null != props.dangerouslySetInnerHTML) throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");
// Always set children to the same thing. In IE9, the selection range will
return _assign({}, props, {
value: void 0,
defaultValue: void 0,
children: "" + element._wrapperState.initialValue
});
}
function initWrapperState$2(element, props) {
checkControlledValueProps("textarea", props), void 0 === props.value || void 0 === props.defaultValue || didWarnValDefaultVal || (error("%s contains a textarea with both value and defaultValue props. Textarea elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled textarea and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component"), didWarnValDefaultVal = !0);
var initialValue = props.value; // Only bother fetching default value if we're going to use it
if (null == initialValue) {
var children = props.children, defaultValue = props.defaultValue;
if (null != children) {
if (error("Use the `defaultValue` or `value` props instead of setting children on <textarea>."), null != defaultValue) throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");
if (Array.isArray(children)) {
if (!(children.length <= 1)) throw Error("<textarea> can only have at most one child.");
children = children[0];
}
defaultValue = children;
}
null == defaultValue && (defaultValue = ""), initialValue = defaultValue;
}
element._wrapperState = {
initialValue: getToStringValue(initialValue)
};
}
function updateWrapper$1(element, props) {
var value = getToStringValue(props.value), defaultValue = getToStringValue(props.defaultValue);
if (null != value) {
// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
var newValue = "" + value; // To avoid side effects (such as losing text selection), only set value if changed
newValue !== element.value && (element.value = newValue), null == props.defaultValue && element.defaultValue !== newValue && (element.defaultValue = newValue);
}
null != defaultValue && (element.defaultValue = "" + defaultValue);
}
function postMountWrapper$3(element, props) {
// available until after the component has mounted.
var textContent = element.textContent; // Only set node.value if textContent is equal to the expected
// initial value. In IE10/IE11 there is a bug where the placeholder attribute
// will populate textContent as well.
// https://developer.microsoft.com/microsoft-edge/platform/issues/101525/
textContent === element._wrapperState.initialValue && "" !== textContent && null !== textContent && (element.value = textContent);
}
var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml", SVG_NAMESPACE = "http://www.w3.org/2000/svg";
function getIntrinsicNamespace(type) {
switch(type){
case "svg":
return SVG_NAMESPACE;
case "math":
return "http://www.w3.org/1998/Math/MathML";
default:
return HTML_NAMESPACE;
}
}
function getChildNamespace(parentNamespace, type) {
return null == parentNamespace || parentNamespace === HTML_NAMESPACE ? getIntrinsicNamespace(type) : parentNamespace === SVG_NAMESPACE && "foreignObject" === type ? HTML_NAMESPACE : parentNamespace;
}
/**
* Set the innerHTML property of a node
*
* @param {DOMElement} node
* @param {string} html
* @internal
*/ var setInnerHTML = (func = function(node, html) {
if (node.namespaceURI === SVG_NAMESPACE && !("innerHTML" in node)) {
// IE does not have innerHTML for SVG nodes, so instead we inject the
// new markup in a temp node and then move the child nodes across into
// the target node
(reusableSVGContainer = reusableSVGContainer || document.createElement("div")).innerHTML = "<svg>" + html.valueOf().toString() + "</svg>";
for(var svgNode = reusableSVGContainer.firstChild; node.firstChild;)node.removeChild(node.firstChild);
for(; svgNode.firstChild;)node.appendChild(svgNode.firstChild);
return;
}
node.innerHTML = html;
}, "undefined" != typeof MSApp && MSApp.execUnsafeLocalFunction ? function(arg0, arg1, arg2, arg3) {
MSApp.execUnsafeLocalFunction(function() {
return func(arg0, arg1, arg2, arg3);
});
} : func), setTextContent = function(node, text) {
if (text) {
var firstChild = node.firstChild;
if (firstChild && firstChild === node.lastChild && 3 === firstChild.nodeType) {
firstChild.nodeValue = text;
return;
}
}
node.textContent = text;
}, shorthandToLonghand = {
animation: [
"animationDelay",
"animationDirection",
"animationDuration",
"animationFillMode",
"animationIterationCount",
"animationName",
"animationPlayState",
"animationTimingFunction"
],
background: [
"backgroundAttachment",
"backgroundClip",
"backgroundColor",
"backgroundImage",
"backgroundOrigin",
"backgroundPositionX",
"backgroundPositionY",
"backgroundRepeat",
"backgroundSize"
],
backgroundPosition: [
"backgroundPositionX",
"backgroundPositionY"
],
border: [
"borderBottomColor",
"borderBottomStyle",
"borderBottomWidth",
"borderImageOutset",
"borderImageRepeat",
"borderImageSlice",
"borderImageSource",
"borderImageWidth",
"borderLeftColor",
"borderLeftStyle",
"borderLeftWidth",
"borderRightColor",
"borderRightStyle",
"borderRightWidth",
"borderTopColor",
"borderTopStyle",
"borderTopWidth"
],
borderBlockEnd: [
"borderBlockEndColor",
"borderBlockEndStyle",
"borderBlockEndWidth"
],
borderBlockStart: [
"borderBlockStartColor",
"borderBlockStartStyle",
"borderBlockStartWidth"
],
borderBottom: [
"borderBottomColor",
"borderBottomStyle",
"borderBottomWidth"
],
borderColor: [
"borderBottomColor",
"borderLeftColor",
"borderRightColor",
"borderTopColor"
],
borderImage: [
"borderImageOutset",
"borderImageRepeat",
"borderImageSlice",
"borderImageSource",
"borderImageWidth"
],
borderInlineEnd: [
"borderInlineEndColor",
"borderInlineEndStyle",
"borderInlineEndWidth"
],
borderInlineStart: [
"borderInlineStartColor",
"borderInlineStartStyle",
"borderInlineStartWidth"
],
borderLeft: [
"borderLeftColor",
"borderLeftStyle",
"borderLeftWidth"
],
borderRadius: [
"borderBottomLeftRadius",
"borderBottomRightRadius",
"borderTopLeftRadius",
"borderTopRightRadius"
],
borderRight: [
"borderRightColor",
"borderRightStyle",
"borderRightWidth"
],
borderStyle: [
"borderBottomStyle",
"borderLeftStyle",
"borderRightStyle",
"borderTopStyle"
],
borderTop: [
"borderTopColor",
"borderTopStyle",
"borderTopWidth"
],
borderWidth: [
"borderBottomWidth",
"borderLeftWidth",
"borderRightWidth",
"borderTopWidth"
],
columnRule: [
"columnRuleColor",
"columnRuleStyle",
"columnRuleWidth"
],
columns: [
"columnCount",
"columnWidth"
],
flex: [
"flexBasis",
"flexGrow",
"flexShrink"
],
flexFlow: [
"flexDirection",
"flexWrap"
],
font: [
"fontFamily",
"fontFeatureSettings",
"fontKerning",
"fontLanguageOverride",
"fontSize",
"fontSizeAdjust",
"fontStretch",
"fontStyle",
"fontVariant",
"fontVariantAlternates",
"fontVariantCaps",
"fontVariantEastAsian",
"fontVariantLigatures",
"fontVariantNumeric",
"fontVariantPosition",
"fontWeight",
"lineHeight"
],
fontVariant: [
"fontVariantAlternates",
"fontVariantCaps",
"fontVariantEastAsian",
"fontVariantLigatures",
"fontVariantNumeric",
"fontVariantPosition"
],
gap: [
"columnGap",
"rowGap"
],
grid: [
"gridAutoColumns",
"gridAutoFlow",
"gridAutoRows",
"gridTemplateAreas",
"gridTemplateColumns",
"gridTemplateRows"
],
gridArea: [
"gridColumnEnd",
"gridColumnStart",
"gridRowEnd",
"gridRowStart"
],
gridColumn: [
"gridColumnEnd",
"gridColumnStart"
],
gridColumnGap: [
"columnGap"
],
gridGap: [
"columnGap",
"rowGap"
],
gridRow: [
"gridRowEnd",
"gridRowStart"
],
gridRowGap: [
"rowGap"
],
gridTemplate: [
"gridTemplateAreas",
"gridTemplateColumns",
"gridTemplateRows"
],
listStyle: [
"listStyleImage",
"listStylePosition",
"listStyleType"
],
margin: [
"marginBottom",
"marginLeft",
"marginRight",
"marginTop"
],
marker: [
"markerEnd",
"markerMid",
"markerStart"
],
mask: [
"maskClip",
"maskComposite",
"maskImage",
"maskMode",
"maskOrigin",
"maskPositionX",
"maskPositionY",
"maskRepeat",
"maskSize"
],
maskPosition: [
"maskPositionX",
"maskPositionY"
],
outline: [
"outlineColor",
"outlineStyle",
"outlineWidth"
],
overflow: [
"overflowX",
"overflowY"
],
padding: [
"paddingBottom",
"paddingLeft",
"paddingRight",
"paddingTop"
],
placeContent: [
"alignContent",
"justifyContent"
],
placeItems: [
"alignItems",
"justifyItems"
],
placeSelf: [
"alignSelf",
"justifySelf"
],
textDecoration: [
"textDecorationColor",
"textDecorationLine",
"textDecorationStyle"
],
textEmphasis: [
"textEmphasisColor",
"textEmphasisStyle"
],
transition: [
"transitionDelay",
"transitionDuration",
"transitionProperty",
"transitionTimingFunction"
],
wordWrap: [
"overflowWrap"
]
}, isUnitlessNumber = {
animationIterationCount: !0,
borderImageOutset: !0,
borderImageSlice: !0,
borderImageWidth: !0,
boxFlex: !0,
boxFlexGroup: !0,
boxOrdinalGroup: !0,
columnCount: !0,
columns: !0,
flex: !0,
flexGrow: !0,
flexPositive: !0,
flexShrink: !0,
flexNegative: !0,
flexOrder: !0,
gridArea: !0,
gridRow: !0,
gridRowEnd: !0,
gridRowSpan: !0,
gridRowStart: !0,
gridColumn: !0,
gridColumnEnd: !0,
gridColumnSpan: !0,
gridColumnStart: !0,
fontWeight: !0,
lineClamp: !0,
lineHeight: !0,
opacity: !0,
order: !0,
orphans: !0,
tabSize: !0,
widows: !0,
zIndex: !0,
zoom: !0,
// SVG-related properties
fillOpacity: !0,
floodOpacity: !0,
stopOpacity: !0,
strokeDasharray: !0,
strokeDashoffset: !0,
strokeMiterlimit: !0,
strokeOpacity: !0,
strokeWidth: !0
}, prefixes = [
"Webkit",
"ms",
"Moz",
"O"
];
/**
* Convert a value into the proper css writable value. The style name `name`
* should be logical (no hyphens), as specified
* in `CSSProperty.isUnitlessNumber`.
*
* @param {string} name CSS property name such as `topMargin`.
* @param {*} value CSS property value such as `10px`.
* @return {string} Normalized style value with dimensions applied.
*/ function dangerousStyleValue(name, value, isCustomProperty) {
return null == value || "boolean" == typeof value || "" === value ? "" : isCustomProperty || "number" != typeof value || 0 === value || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name] ? ("" + value).trim() : value + "px";
}
// infinite loop, because it iterates over the newly added props too.
Object.keys(isUnitlessNumber).forEach(function(prop) {
prefixes.forEach(function(prefix) {
isUnitlessNumber[prefix + prop.charAt(0).toUpperCase() + prop.substring(1)] = isUnitlessNumber[prop];
});
});
var uppercasePattern = /([A-Z])/g, msPattern = /^ms-/, warnValidStyle = function() {}, badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/, msPattern$1 = /^-ms-/, hyphenPattern = /-(.)/g, badStyleValueWithSemicolonPattern = /;\s*$/, warnedStyleNames = {}, warnedStyleValues = {}, warnedForNaNValue = !1, warnedForInfinityValue = !1, warnHyphenatedStyleName = function(name) {
(!warnedStyleNames.hasOwnProperty(name) || !warnedStyleNames[name]) && (warnedStyleNames[name] = !0, error("Unsupported style property %s. Did you mean %s?", name, name.replace(msPattern$1, "ms-").replace(hyphenPattern, function(_, character) {
return character.toUpperCase();
})));
}, warnBadVendoredStyleName = function(name) {
(!warnedStyleNames.hasOwnProperty(name) || !warnedStyleNames[name]) && (warnedStyleNames[name] = !0, error("Unsupported vendor-prefixed style property %s. Did you mean %s?", name, name.charAt(0).toUpperCase() + name.slice(1)));
}, warnStyleValueWithSemicolon = function(name, value) {
(!warnedStyleValues.hasOwnProperty(value) || !warnedStyleValues[value]) && (warnedStyleValues[value] = !0, error('Style property values shouldn\'t contain a semicolon. Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, "")));
}, warnStyleValueIsNaN = function(name, value) {
!warnedForNaNValue && (warnedForNaNValue = !0, error("`NaN` is an invalid value for the `%s` css style property.", name));
}, warnStyleValueIsInfinity = function(name, value) {
!warnedForInfinityValue && (warnedForInfinityValue = !0, error("`Infinity` is an invalid value for the `%s` css style property.", name));
}, warnValidStyle$1 = function(name, value) {
name.indexOf("-") > -1 ? warnHyphenatedStyleName(name) : badVendoredStyleNamePattern.test(name) ? warnBadVendoredStyleName(name) : badStyleValueWithSemicolonPattern.test(value) && warnStyleValueWithSemicolon(name, value), "number" != typeof value || (isNaN(value) ? warnStyleValueIsNaN(name, value) : isFinite(value) || warnStyleValueIsInfinity(name, value));
};
/**
* Sets the value for multiple styles on a node. If a value is specified as
* '' (empty string), the corresponding style property will be unset.
*
* @param {DOMElement} node
* @param {object} styles
*/ function setValueForStyles(node, styles) {
var style = node.style;
for(var styleName in styles)if (styles.hasOwnProperty(styleName)) {
var isCustomProperty = 0 === styleName.indexOf("--");
isCustomProperty || warnValidStyle$1(styleName, styles[styleName]);
var styleValue = dangerousStyleValue(styleName, styles[styleName], isCustomProperty);
"float" === styleName && (styleName = "cssFloat"), isCustomProperty ? style.setProperty(styleName, styleValue) : style[styleName] = styleValue;
}
}
/**
* Given {color: 'red', overflow: 'hidden'} returns {
* color: 'color',
* overflowX: 'overflow',
* overflowY: 'overflow',
* }. This can be read as "the overflowY property was set by the overflow
* shorthand". That is, the values are the property that each was derived from.
*/ function expandShorthandMap(styles) {
var expanded = {};
for(var key in styles)for(var longhands = shorthandToLonghand[key] || [
key
], i = 0; i < longhands.length; i++)expanded[longhands[i]] = key;
return expanded;
}
// `omittedCloseTags` except that `menuitem` should still have its closing tag.
var voidElementTags = _assign({
menuitem: !0
}, {
area: !0,
base: !0,
br: !0,
col: !0,
embed: !0,
hr: !0,
img: !0,
input: !0,
keygen: !0,
link: !0,
meta: !0,
param: !0,
source: !0,
track: !0,
wbr: !0
});
function assertValidProps(tag, props) {
if (props) {
if (voidElementTags[tag] && (null != props.children || null != props.dangerouslySetInnerHTML)) throw Error(tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
if (null != props.dangerouslySetInnerHTML) {
if (null != props.children) throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
if (!("object" == typeof props.dangerouslySetInnerHTML && "__html" in props.dangerouslySetInnerHTML)) throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");
}
if (!props.suppressContentEditableWarning && props.contentEditable && null != props.children && error("A component is `contentEditable` and contains `children` managed by React. It is now your responsibility to guarantee that none of those nodes are unexpectedly modified or duplicated. This is probably not intentional."), null != props.style && "object" != typeof props.style) throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");
} // Note the use of `==` which checks for null or undefined.
}
function isCustomComponent(tagName, props) {
if (-1 === tagName.indexOf("-")) return "string" == typeof props.is;
switch(tagName){
// These are reserved SVG and MathML elements.
// We don't mind this list too much because we expect it to never grow.
// The alternative is to track the namespace in a few places which is convoluted.
// https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
case "annotation-xml":
case "color-profile":
case "font-face":
case "font-face-src":
case "font-face-uri":
case "font-face-format":
case "font-face-name":
case "missing-glyph":
return !1;
default:
return !0;
}
}
// When adding attributes to the HTML or SVG allowed attribute list, be sure to
// also add them to this module to ensure casing and incorrect name
// warnings.
var possibleStandardNames = {
// HTML
accept: "accept",
acceptcharset: "acceptCharset",
"accept-charset": "acceptCharset",
accesskey: "accessKey",
action: "action",
allowfullscreen: "allowFullScreen",
alt: "alt",
as: "as",
async: "async",
autocapitalize: "autoCapitalize",
autocomplete: "autoComplete",
autocorrect: "autoCorrect",
autofocus: "autoFocus",
autoplay: "autoPlay",
autosave: "autoSave",
capture: "capture",
cellpadding: "cellPadding",
cellspacing: "cellSpacing",
challenge: "challenge",
charset: "charSet",
checked: "checked",
children: "children",
cite: "cite",
class: "className",
classid: "classID",
classname: "className",
cols: "cols",
colspan: "colSpan",
content: "content",
contenteditable: "contentEditable",
contextmenu: "contextMenu",
controls: "controls",
controlslist: "controlsList",
coords: "coords",
crossorigin: "crossOrigin",
dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
data: "data",
datetime: "dateTime",
default: "default",
defaultchecked: "defaultChecked",
defaultvalue: "defaultValue",
defer: "defer",
dir: "dir",
disabled: "disabled",
disablepictureinpicture: "disablePictureInPicture",
disableremoteplayback: "disableRemotePlayback",
download: "download",
draggable: "draggable",
enctype: "encType",
enterkeyhint: "enterKeyHint",
for: "htmlFor",
form: "form",
formmethod: "formMethod",
formaction: "formAction",
formenctype: "formEncType",
formnovalidate: "formNoValidate",
formtarget: "formTarget",
frameborder: "frameBorder",
headers: "headers",
height: "height",
hidden: "hidden",
high: "high",
href: "href",
hreflang: "hrefLang",
htmlfor: "htmlFor",
httpequiv: "httpEquiv",
"http-equiv": "httpEquiv",
icon: "icon",
id: "id",
innerhtml: "innerHTML",
inputmode: "inputMode",
integrity: "integrity",
is: "is",
itemid: "itemID",
itemprop: "itemProp",
itemref: "itemRef",
itemscope: "itemScope",
itemtype: "itemType",
keyparams: "keyParams",
keytype: "keyType",
kind: "kind",
label: "label",
lang: "lang",
list: "list",
loop: "loop",
low: "low",
manifest: "manifest",
marginwidth: "marginWidth",
marginheight: "marginHeight",
max: "max",
maxlength: "maxLength",
media: "media",
mediagroup: "mediaGroup",
method: "method",
min: "min",
minlength: "minLength",
multiple: "multiple",
muted: "muted",
name: "name",
nomodule: "noModule",
nonce: "nonce",
novalidate: "noValidate",
open: "open",
optimum: "optimum",
pattern: "pattern",
placeholder: "placeholder",
playsinline: "playsInline",
poster: "poster",
preload: "preload",
profile: "profile",
radiogroup: "radioGroup",
readonly: "readOnly",
referrerpolicy: "referrerPolicy",
rel: "rel",
required: "required",
reversed: "reversed",
role: "role",
rows: "rows",
rowspan: "rowSpan",
sandbox: "sandbox",
scope: "scope",
scoped: "scoped",
scrolling: "scrolling",
seamless: "seamless",
selected: "selected",
shape: "shape",
size: "size",
sizes: "sizes",
span: "span",
spellcheck: "spellCheck",
src: "src",
srcdoc: "srcDoc",
srclang: "srcLang",
srcset: "srcSet",
start: "start",
step: "step",
style: "style",
summary: "summary",
tabindex: "tabIndex",
target: "target",
title: "title",
type: "type",
usemap: "useMap",
value: "value",
width: "width",
wmode: "wmode",
wrap: "wrap",
// SVG
about: "about",
accentheight: "accentHeight",
"accent-height": "accentHeight",
accumulate: "accumulate",
additive: "additive",
alignmentbaseline: "alignmentBaseline",
"alignment-baseline": "alignmentBaseline",
allowreorder: "allowReorder",
alphabetic: "alphabetic",
amplitude: "amplitude",
arabicform: "arabicForm",
"arabic-form": "arabicForm",
ascent: "ascent",
attributename: "attributeName",
attributetype: "attributeType",
autoreverse: "autoReverse",
azimuth: "azimuth",
basefrequency: "baseFrequency",
baselineshift: "baselineShift",
"baseline-shift": "baselineShift",
baseprofile: "baseProfile",
bbox: "bbox",
begin: "begin",
bias: "bias",
by: "by",
calcmode: "calcMode",
capheight: "capHeight",
"cap-height": "capHeight",
clip: "clip",
clippath: "clipPath",
"clip-path": "clipPath",
clippathunits: "clipPathUnits",
cliprule: "clipRule",
"clip-rule": "clipRule",
color: "color",
colorinterpolation: "colorInterpolation",
"color-interpolation": "colorInterpolation",
colorinterpolationfilters: "colorInterpolationFilters",
"color-interpolation-filters": "colorInterpolationFilters",
colorprofile: "colorProfile",
"color-profile": "colorProfile",
colorrendering: "colorRendering",
"color-rendering": "colorRendering",
contentscripttype: "contentScriptType",
contentstyletype: "contentStyleType",
cursor: "cursor",
cx: "cx",
cy: "cy",
d: "d",
datatype: "datatype",
decelerate: "decelerate",
descent: "descent",
diffuseconstant: "diffuseConstant",
direction: "direction",
display: "display",
divisor: "divisor",
dominantbaseline: "dominantBaseline",
"dominant-baseline": "dominantBaseline",
dur: "dur",
dx: "dx",
dy: "dy",
edgemode: "edgeMode",
elevation: "elevation",
enablebackground: "enableBackground",
"enable-background": "enableBackground",
end: "end",
exponent: "exponent",
externalresourcesrequired: "externalResourcesRequired",
fill: "fill",
fillopacity: "fillOpacity",
"fill-opacity": "fillOpacity",
fillrule: "fillRule",
"fill-rule": "fillRule",
filter: "filter",
filterres: "filterRes",
filterunits: "filterUnits",
floodopacity: "floodOpacity",
"flood-opacity": "floodOpacity",
floodcolor: "floodColor",
"flood-color": "floodColor",
focusable: "focusable",
fontfamily: "fontFamily",
"font-family": "fontFamily",
fontsize: "fontSize",
"font-size": "fontSize",
fontsizeadjust: "fontSizeAdjust",
"font-size-adjust": "fontSizeAdjust",
fontstretch: "fontStretch",
"font-stretch": "fontStretch",
fontstyle: "fontStyle",
"font-style": "fontStyle",
fontvariant: "fontVariant",
"font-variant": "fontVariant",
fontweight: "fontWeight",
"font-weight": "fontWeight",
format: "format",
from: "from",
fx: "fx",
fy: "fy",
g1: "g1",
g2: "g2",
glyphname: "glyphName",
"glyph-name": "glyphName",
glyphorientationhorizontal: "glyphOrientationHorizontal",
"glyph-orientation-horizontal": "glyphOrientationHorizontal",
glyphorientationvertical: "glyphOrientationVertical",
"glyph-orientation-vertical": "glyphOrientationVertical",
glyphref: "glyphRef",
gradienttransform: "gradientTransform",
gradientunits: "gradientUnits",
hanging: "hanging",
horizadvx: "horizAdvX",
"horiz-adv-x": "horizAdvX",
horizoriginx: "horizOriginX",
"horiz-origin-x": "horizOriginX",
ideographic: "ideographic",
imagerendering: "imageRendering",
"image-rendering": "imageRendering",
in2: "in2",
in: "in",
inlist: "inlist",
intercept: "intercept",
k1: "k1",
k2: "k2",
k3: "k3",
k4: "k4",
k: "k",
kernelmatrix: "kernelMatrix",
kernelunitlength: "kernelUnitLength",
kerning: "kerning",
keypoints: "keyPoints",
keysplines: "keySplines",
keytimes: "keyTimes",
lengthadjust: "lengthAdjust",
letterspacing: "letterSpacing",
"letter-spacing": "letterSpacing",
lightingcolor: "lightingColor",
"lighting-color": "lightingColor",
limitingconeangle: "limitingConeAngle",
local: "local",
markerend: "markerEnd",
"marker-end": "markerEnd",
markerheight: "markerHeight",
markermid: "markerMid",
"marker-mid": "markerMid",
markerstart: "markerStart",
"marker-start": "markerStart",
markerunits: "markerUnits",
markerwidth: "markerWidth",
mask: "mask",
maskcontentunits: "maskContentUnits",
maskunits: "maskUnits",
mathematical: "mathematical",
mode: "mode",
numoctaves: "numOctaves",
offset: "offset",
opacity: "opacity",
operator: "operator",
order: "order",
orient: "orient",
orientation: "orientation",
origin: "origin",
overflow: "overflow",
overlineposition: "overlinePosition",
"overline-position": "overlinePosition",
overlinethickness: "overlineThickness",
"overline-thickness": "overlineThickness",
paintorder: "paintOrder",
"paint-order": "paintOrder",
panose1: "panose1",
"panose-1": "panose1",
pathlength: "pathLength",
patterncontentunits: "patternContentUnits",
patterntransform: "patternTransform",
patternunits: "patternUnits",
pointerevents: "pointerEvents",
"pointer-events": "pointerEvents",
points: "points",
pointsatx: "pointsAtX",
pointsaty: "pointsAtY",
pointsatz: "pointsAtZ",
prefix: "prefix",
preservealpha: "preserveAlpha",
preserveaspectratio: "preserveAspectRatio",
primitiveunits: "primitiveUnits",
property: "property",
r: "r",
radius: "radius",
refx: "refX",
refy: "refY",
renderingintent: "renderingIntent",
"rendering-intent": "renderingIntent",
repeatcount: "repeatCount",
repeatdur: "repeatDur",
requiredextensions: "requiredExtensions",
requiredfeatures: "requiredFeatures",
resource: "resource",
restart: "restart",
result: "result",
results: "results",
rotate: "rotate",
rx: "rx",
ry: "ry",
scale: "scale",
security: "security",
seed: "seed",
shaperendering: "shapeRendering",
"shape-rendering": "shapeRendering",
slope: "slope",
spacing: "spacing",
specularconstant: "specularConstant",
specularexponent: "specularExponent",
speed: "speed",
spreadmethod: "spreadMethod",
startoffset: "startOffset",
stddeviation: "stdDeviation",
stemh: "stemh",
stemv: "stemv",
stitchtiles: "stitchTiles",
stopcolor: "stopColor",
"stop-color": "stopColor",
stopopacity: "stopOpacity",
"stop-opacity": "stopOpacity",
strikethroughposition: "strikethroughPosition",
"strikethrough-position": "strikethroughPosition",
strikethroughthickness: "strikethroughThickness",
"strikethrough-thickness": "strikethroughThickness",
string: "string",
stroke: "stroke",
strokedasharray: "strokeDasharray",
"stroke-dasharray": "strokeDasharray",
strokedashoffset: "strokeDashoffset",
"stroke-dashoffset": "strokeDashoffset",
strokelinecap: "strokeLinecap",
"stroke-linecap": "strokeLinecap",
strokelinejoin: "strokeLinejoin",
"stroke-linejoin": "strokeLinejoin",
strokemiterlimit: "strokeMiterlimit",
"stroke-miterlimit": "strokeMiterlimit",
strokewidth: "strokeWidth",
"stroke-width": "strokeWidth",
strokeopacity: "strokeOpacity",
"stroke-opacity": "strokeOpacity",
suppresscontenteditablewarning: "suppressContentEditableWarning",
suppresshydrationwarning: "suppressHydrationWarning",
surfacescale: "surfaceScale",
systemlanguage: "systemLanguage",
tablevalues: "tableValues",
targetx: "targetX",
targety: "targetY",
textanchor: "textAnchor",
"text-anchor": "textAnchor",
textdecoration: "textDecoration",
"text-decoration": "textDecoration",
textlength: "textLength",
textrendering: "textRendering",
"text-rendering": "textRendering",
to: "to",
transform: "transform",
typeof: "typeof",
u1: "u1",
u2: "u2",
underlineposition: "underlinePosition",
"underline-position": "underlinePosition",
underlinethickness: "underlineThickness",
"underline-thickness": "underlineThickness",
unicode: "unicode",
unicodebidi: "unicodeBidi",
"unicode-bidi": "unicodeBidi",
unicoderange: "unicodeRange",
"unicode-range": "unicodeRange",
unitsperem: "unitsPerEm",
"units-per-em": "unitsPerEm",
unselectable: "unselectable",
valphabetic: "vAlphabetic",
"v-alphabetic": "vAlphabetic",
values: "values",
vectoreffect: "vectorEffect",
"vector-effect": "vectorEffect",
version: "version",
vertadvy: "vertAdvY",
"vert-adv-y": "vertAdvY",
vertoriginx: "vertOriginX",
"vert-origin-x": "vertOriginX",
vertoriginy: "vertOriginY",
"vert-origin-y": "vertOriginY",
vhanging: "vHanging",
"v-hanging": "vHanging",
videographic: "vIdeographic",
"v-ideographic": "vIdeographic",
viewbox: "viewBox",
viewtarget: "viewTarget",
visibility: "visibility",
vmathematical: "vMathematical",
"v-mathematical": "vMathematical",
vocab: "vocab",
widths: "widths",
wordspacing: "wordSpacing",
"word-spacing": "wordSpacing",
writingmode: "writingMode",
"writing-mode": "writingMode",
x1: "x1",
x2: "x2",
x: "x",
xchannelselector: "xChannelSelector",
xheight: "xHeight",
"x-height": "xHeight",
xlinkactuate: "xlinkActuate",
"xlink:actuate": "xlinkActuate",
xlinkarcrole: "xlinkArcrole",
"xlink:arcrole": "xlinkArcrole",
xlinkhref: "xlinkHref",
"xlink:href": "xlinkHref",
xlinkrole: "xlinkRole",
"xlink:role": "xlinkRole",
xlinkshow: "xlinkShow",
"xlink:show": "xlinkShow",
xlinktitle: "xlinkTitle",
"xlink:title": "xlinkTitle",
xlinktype: "xlinkType",
"xlink:type": "xlinkType",
xmlbase: "xmlBase",
"xml:base": "xmlBase",
xmllang: "xmlLang",
"xml:lang": "xmlLang",
xmlns: "xmlns",
"xml:space": "xmlSpace",
xmlnsxlink: "xmlnsXlink",
"xmlns:xlink": "xmlnsXlink",
xmlspace: "xmlSpace",
y1: "y1",
y2: "y2",
y: "y",
ychannelselector: "yChannelSelector",
z: "z",
zoomandpan: "zoomAndPan"
}, ariaProperties = {
"aria-current": 0,
// state
"aria-details": 0,
"aria-disabled": 0,
// state
"aria-hidden": 0,
// state
"aria-invalid": 0,
// state
"aria-keyshortcuts": 0,
"aria-label": 0,
"aria-roledescription": 0,
// Widget Attributes
"aria-autocomplete": 0,
"aria-checked": 0,
"aria-expanded": 0,
"aria-haspopup": 0,
"aria-level": 0,
"aria-modal": 0,
"aria-multiline": 0,
"aria-multiselectable": 0,
"aria-orientation": 0,
"aria-placeholder": 0,
"aria-pressed": 0,
"aria-readonly": 0,
"aria-required": 0,
"aria-selected": 0,
"aria-sort": 0,
"aria-valuemax": 0,
"aria-valuemin": 0,
"aria-valuenow": 0,
"aria-valuetext": 0,
// Live Region Attributes
"aria-atomic": 0,
"aria-busy": 0,
"aria-live": 0,
"aria-relevant": 0,
// Drag-and-Drop Attributes
"aria-dropeffect": 0,
"aria-grabbed": 0,
// Relationship Attributes
"aria-activedescendant": 0,
"aria-colcount": 0,
"aria-colindex": 0,
"aria-colspan": 0,
"aria-controls": 0,
"aria-describedby": 0,
"aria-errormessage": 0,
"aria-flowto": 0,
"aria-labelledby": 0,
"aria-owns": 0,
"aria-posinset": 0,
"aria-rowcount": 0,
"aria-rowindex": 0,
"aria-rowspan": 0,
"aria-setsize": 0
}, warnedProperties = {}, rARIA = RegExp("^(aria)-[" + ATTRIBUTE_NAME_CHAR + "]*$"), rARIACamel = RegExp("^(aria)[A-Z][" + ATTRIBUTE_NAME_CHAR + "]*$"), hasOwnProperty$1 = Object.prototype.hasOwnProperty, didWarnValueNull = !1, validateProperty$1 = function() {}, warnedProperties$1 = {}, _hasOwnProperty = Object.prototype.hasOwnProperty, EVENT_NAME_REGEX = /^on./, INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/, rARIA$1 = RegExp("^(aria)-[" + ATTRIBUTE_NAME_CHAR + "]*$"), rARIACamel$1 = RegExp("^(aria)[A-Z][" + ATTRIBUTE_NAME_CHAR + "]*$");
validateProperty$1 = function(tagName, name, value, eventRegistry) {
if (_hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name]) return !0;
var lowerCasedName = name.toLowerCase();
if ("onfocusin" === lowerCasedName || "onfocusout" === lowerCasedName) return error("React uses onFocus and onBlur instead of onFocusIn and onFocusOut. All React events are normalized to bubble, so onFocusIn and onFocusOut are not needed/supported by React."), warnedProperties$1[name] = !0, !0;
// We can't rely on the event system being injected on the server.
if (null != eventRegistry) {
var registrationNameDependencies = eventRegistry.registrationNameDependencies, possibleRegistrationNames = eventRegistry.possibleRegistrationNames;
if (registrationNameDependencies.hasOwnProperty(name)) return !0;
var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;
if (null != registrationName) return error("Invalid event handler property `%s`. Did you mean `%s`?", name, registrationName), warnedProperties$1[name] = !0, !0;
if (EVENT_NAME_REGEX.test(name)) return error("Unknown event handler property `%s`. It will be ignored.", name), warnedProperties$1[name] = !0, !0;
} else if (EVENT_NAME_REGEX.test(name)) return INVALID_EVENT_NAME_REGEX.test(name) && error("Invalid event handler property `%s`. React events use the camelCase naming convention, for example `onClick`.", name), warnedProperties$1[name] = !0, !0;
// Let the ARIA attribute hook validate ARIA attributes
if (rARIA$1.test(name) || rARIACamel$1.test(name)) return !0;
if ("innerhtml" === lowerCasedName) return error("Directly setting property `innerHTML` is not permitted. For more information, lookup documentation on `dangerouslySetInnerHTML`."), warnedProperties$1[name] = !0, !0;
if ("aria" === lowerCasedName) return error("The `aria` attribute is reserved for future use in React. Pass individual `aria-` attributes instead."), warnedProperties$1[name] = !0, !0;
if ("is" === lowerCasedName && null != value && "string" != typeof value) return error("Received a `%s` for a string attribute `is`. If this is expected, cast the value to a string.", typeof value), warnedProperties$1[name] = !0, !0;
if ("number" == typeof value && isNaN(value)) return error("Received NaN for the `%s` attribute. If this is expected, cast the value to a string.", name), warnedProperties$1[name] = !0, !0;
var propertyInfo = getPropertyInfo(name), isReserved = null !== propertyInfo && 0 === propertyInfo.type;
if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
var standardName = possibleStandardNames[lowerCasedName];
if (standardName !== name) return error("Invalid DOM property `%s`. Did you mean `%s`?", name, standardName), warnedProperties$1[name] = !0, !0;
} else if (!isReserved && name !== lowerCasedName) return(// Unknown attributes should have lowercase casing since that's how they
// will be cased anyway with server rendering.
error("React does not recognize the `%s` prop on a DOM element. If you intentionally want it to appear in the DOM as a custom attribute, spell it as lowercase `%s` instead. If you accidentally passed it from a parent component, remove it from the DOM element.", name, lowerCasedName), warnedProperties$1[name] = !0, !0);
return "boolean" == typeof value && shouldRemoveAttributeWithWarning(name, value, propertyInfo, !1) ? (value ? error('Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.', value, name, name, value, name) : error('Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.\n\nIf you used to conditionally omit it with %s={condition && value}, pass %s={condition ? value : undefined} instead.', value, name, name, value, name, name, name), warnedProperties$1[name] = !0, !0) : !!isReserved || (shouldRemoveAttributeWithWarning(name, value, propertyInfo, !1) ? (warnedProperties$1[name] = !0, !1) : (("false" === value || "true" === value) && null !== propertyInfo && 3 === propertyInfo.type && (error("Received the string `%s` for the boolean attribute `%s`. %s Did you mean %s={%s}?", value, name, "false" === value ? "The browser will interpret it as a truthy value." : 'Although this works, it will not work as expected if you pass the string "false".', name, value), warnedProperties$1[name] = !0), !0)) // Now that we've validated casing, do not validate
;
};
var warnUnknownProperties = function(type, props, eventRegistry) {
var unknownProps = [];
for(var key in props)validateProperty$1(type, key, props[key], eventRegistry) || unknownProps.push(key);
var unknownPropString = unknownProps.map(function(prop) {
return "`" + prop + "`";
}).join(", ");
1 === unknownProps.length ? error("Invalid value for prop %s on <%s> tag. Either remove it from the element, or pass a string or number value to keep it in the DOM. For details, see https://reactjs.org/link/attribute-behavior ", unknownPropString, type) : unknownProps.length > 1 && error("Invalid values for props %s on <%s> tag. Either remove them from the element, or pass a string or number value to keep them in the DOM. For details, see https://reactjs.org/link/attribute-behavior ", unknownPropString, type);
};
/**
* Gets the target node from a native browser event by accounting for
* inconsistencies in browser DOM APIs.
*
* @param {object} nativeEvent Native browser event.
* @return {DOMEventTarget} Target node.
*/ function getEventTarget(nativeEvent) {
// Fallback to nativeEvent.srcElement for IE9
// https://github.com/facebook/react/issues/12506
var target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963
// @see http://www.quirksmode.org/js/events_properties.html
return target.correspondingUseElement && (target = target.correspondingUseElement), 3 === target.nodeType ? target.parentNode : target;
}
var restoreImpl = null, restoreTarget = null, restoreQueue = null;
function restoreStateOfTarget(target) {
// We perform this translation at the end of the event loop so that we
// always receive the correct fiber here
var internalInstance = getInstanceFromNode(target);
if (internalInstance) {
if ("function" != typeof restoreImpl) throw Error("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
if (stateNode) {
var _props = getFiberCurrentPropsFromNode(stateNode);
restoreImpl(internalInstance.stateNode, internalInstance.type, _props);
}
}
}
function enqueueStateRestore(target) {
restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [
target
] : restoreTarget = target;
}
function restoreStateIfNeeded() {
if (restoreTarget) {
var target = restoreTarget, queuedTargets = restoreQueue;
if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for(var i = 0; i < queuedTargets.length; i++)restoreStateOfTarget(queuedTargets[i]);
}
}
// the renderer. Such as when we're dispatching events or if third party
// libraries need to call batchedUpdates. Eventually, this API will go away when
// everything is batched by default. We'll then have a similar API to opt-out of
// scheduled work and instead do synchronous work.
// Defaults
var batchedUpdatesImpl = function(fn, bookkeeping) {
return fn(bookkeeping);
}, discreteUpdatesImpl = function(fn, a, b, c, d) {
return fn(a, b, c, d);
}, flushDiscreteUpdatesImpl = function() {}, batchedEventUpdatesImpl = batchedUpdatesImpl, isInsideEventHandler = !1, isBatchingEventUpdates = !1;
function finishEventHandler() {
(null !== restoreTarget || null !== restoreQueue) && (// If a controlled event was fired, we may need to restore the state of
// the DOM node back to the controlled value. This is necessary when React
// bails out of the update without touching the DOM.
flushDiscreteUpdatesImpl(), restoreStateIfNeeded());
}
/**
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @return {?function} The stored callback.
*/ function getListener(inst, registrationName) {
var stateNode = inst.stateNode;
if (null === stateNode) // Work in progress (ex: onload events in incremental mode).
return null;
var props = getFiberCurrentPropsFromNode(stateNode);
if (null === props) // Work in progress.
return null;
var listener = props[registrationName];
if (function(name, type, props) {
switch(name){
case "onClick":
case "onClickCapture":
case "onDoubleClick":
case "onDoubleClickCapture":
case "onMouseDown":
case "onMouseDownCapture":
case "onMouseMove":
case "onMouseMoveCapture":
case "onMouseUp":
case "onMouseUpCapture":
case "onMouseEnter":
return !!(props.disabled && ("button" === type || "input" === type || "select" === type || "textarea" === type));
default:
return !1;
}
}(registrationName, inst.type, props)) return null;
if (!(!listener || "function" == typeof listener)) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type.");
return listener;
}
var passiveBrowserEventsSupported = !1; // Check if browser support events with passive listeners
// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
if (canUseDOM) try {
var options = {}; // $FlowFixMe: Ignore Flow complaining about needing a value
Object.defineProperty(options, "passive", {
get: function() {
passiveBrowserEventsSupported = !0;
}
}), window.addEventListener("test", options, options), window.removeEventListener("test", options, options);
} catch (e) {
passiveBrowserEventsSupported = !1;
}
function invokeGuardedCallbackProd(name, func, context, a, b, c, d, e, f) {
var funcArgs = Array.prototype.slice.call(arguments, 3);
try {
func.apply(context, funcArgs);
} catch (error) {
this.onError(error);
}
}
var invokeGuardedCallbackImpl = invokeGuardedCallbackProd;
// In DEV mode, we swap out invokeGuardedCallback for a special version
// that plays more nicely with the browser's DevTools. The idea is to preserve
// "Pause on exceptions" behavior. Because React wraps all user-provided
// functions in invokeGuardedCallback, and the production version of
// invokeGuardedCallback uses a try-catch, all user exceptions are treated
// like caught exceptions, and the DevTools won't pause unless the developer
// takes the extra step of enabling pause on caught exceptions. This is
// unintuitive, though, because even though React has caught the error, from
// the developer's perspective, the error is uncaught.
//
// To preserve the expected "Pause on exceptions" behavior, we don't use a
// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake
// DOM node, and call the user-provided callback from inside an event handler
// for that fake event. If the callback throws, the error is "captured" using
// a global event handler. But because the error happens in a different
// event loop context, it does not interrupt the normal program flow.
// Effectively, this gives us try-catch behavior without actually using
// try-catch. Neat!
// Check that the browser supports the APIs we need to implement our special
// DEV version of invokeGuardedCallback
if ("undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) {
var fakeNode = document.createElement("react");
invokeGuardedCallbackImpl = function(name, func, context, a, b, c, d, e, f) {
// If document doesn't exist we know for sure we will crash in this method
// when we call document.createEvent(). However this can cause confusing
// errors: https://github.com/facebookincubator/create-react-app/issues/3482
// So we preemptively throw with a better message instead.
if ("undefined" == typeof document) throw Error("The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.");
var error, evt = document.createEvent("Event"), didCall = !1, didError = !0, windowEvent = window.event, windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
function restoreAfterDispatch() {
// We immediately remove the callback from event listeners so that
// nested `invokeGuardedCallback` calls do not clash. Otherwise, a
// nested call would trigger the fake event handlers of any call higher
// in the stack.
fakeNode.removeEventListener(evtType, callCallback, !1), void 0 !== window.event && window.hasOwnProperty("event") && (window.event = windowEvent);
} // Create an event handler for our fake event. We will synchronously
// dispatch our fake event using `dispatchEvent`. Inside the handler, we
// call the user-provided callback.
var funcArgs = Array.prototype.slice.call(arguments, 3);
function callCallback() {
didCall = !0, restoreAfterDispatch(), func.apply(context, funcArgs), didError = !1;
} // Create a global error event handler. We use this to capture the value
var didSetError = !1, isCrossOriginError = !1;
function handleWindowError(event) {
if (error = event.error, didSetError = !0, null === error && 0 === event.colno && 0 === event.lineno && (isCrossOriginError = !0), event.defaultPrevented && null != error && "object" == typeof error) try {
error._suppressLogging = !0;
} catch (inner) {
// Ignore.
}
} // Create a fake event type.
var evtType = "react-" + (name || "invokeguardedcallback"); // Attach our event handlers
if (window.addEventListener("error", handleWindowError), fakeNode.addEventListener(evtType, callCallback, !1), // errors, it will trigger our global error handler.
evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), windowEventDescriptor && Object.defineProperty(window, "event", windowEventDescriptor), didCall && didError && (didSetError ? isCrossOriginError && (error = Error("A cross-origin error was thrown. React doesn't have access to the actual error object in development. See https://reactjs.org/link/crossorigin-error for more information.")) : // The callback errored, but the error event never fired.
error = Error("An error was thrown inside one of your components, but React doesn't know what it was. This is likely due to browser flakiness. React does its best to preserve the \"Pause on exceptions\" behavior of the DevTools, which requires some DEV-mode only tricks. It's possible that these don't work in your browser. Try triggering the error in production mode, or switching to a modern browser. If you suspect that this is actually an issue with React, please file an issue."), this.onError(error)), window.removeEventListener("error", handleWindowError), !didCall) return(// Something went really wrong, and our event was not dispatched.
// https://github.com/facebook/react/issues/16734
// https://github.com/facebook/react/issues/16585
// Fall back to the production implementation.
restoreAfterDispatch(), invokeGuardedCallbackProd.apply(this, arguments));
};
}
var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl, hasError = !1, caughtError = null, hasRethrowError = !1, rethrowError = null, reporter = {
onError: function(error) {
hasError = !0, caughtError = error;
}
};
/**
* Call a function while guarding against errors that happens within it.
* Returns an error if it throws, otherwise null.
*
* In production, this is implemented using a try-catch. The reason we don't
* use a try-catch directly is so that we can swap out a different
* implementation in DEV mode.
*
* @param {String} name of the guard to use for logging or debugging
* @param {Function} func The function to invoke
* @param {*} context The context to use when calling the function
* @param {...*} args Arguments for function
*/ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
hasError = !1, caughtError = null, invokeGuardedCallbackImpl$1.apply(reporter, arguments);
}
function clearCaughtError() {
if (hasError) {
var error = caughtError;
return hasError = !1, caughtError = null, error;
}
throw Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.");
}
var _ReactInternals$Sched = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler, unstable_cancelCallback = _ReactInternals$Sched.unstable_cancelCallback, unstable_now = _ReactInternals$Sched.unstable_now, unstable_scheduleCallback = _ReactInternals$Sched.unstable_scheduleCallback, unstable_shouldYield = _ReactInternals$Sched.unstable_shouldYield, unstable_requestPaint = _ReactInternals$Sched.unstable_requestPaint, unstable_runWithPriority = (_ReactInternals$Sched.unstable_getFirstCallbackNode, _ReactInternals$Sched.unstable_runWithPriority), unstable_getCurrentPriorityLevel = (_ReactInternals$Sched.unstable_next, _ReactInternals$Sched.unstable_continueExecution, _ReactInternals$Sched.unstable_pauseExecution, _ReactInternals$Sched.unstable_getCurrentPriorityLevel), unstable_ImmediatePriority = _ReactInternals$Sched.unstable_ImmediatePriority, unstable_UserBlockingPriority = _ReactInternals$Sched.unstable_UserBlockingPriority, unstable_NormalPriority = _ReactInternals$Sched.unstable_NormalPriority, unstable_LowPriority = _ReactInternals$Sched.unstable_LowPriority, unstable_IdlePriority = _ReactInternals$Sched.unstable_IdlePriority, unstable_flushAllWithoutAsserting = (_ReactInternals$Sched.unstable_forceFrameRate, _ReactInternals$Sched.unstable_flushAllWithoutAsserting);
/**
* `ReactInstanceMap` maintains a mapping from a public facing stateful
* instance (key) and the internal representation (value). This allows public
* methods to accept the user facing instance as an argument and map them back
* to internal methods.
*
* Note that this module is currently shared and assumed to be stateless.
* If this becomes an actual Map, that will break.
*/ function get(key) {
return key._reactInternals;
}
var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
function getNearestMountedFiber(fiber) {
var node = fiber, nearestMounted = fiber;
if (fiber.alternate) for(; node.return;)node = node.return;
else {
// If there is no alternate, this might be a new tree that isn't inserted
// yet. If it is, then it will have a pending insertion effect on it.
var nextNode = node;
do (1026 & (node = nextNode).flags) != /* */ 0 && // This is an insertion or in-progress hydration. The nearest possible
// mounted fiber is the parent but we need to continue to figure out
// if that one is still mounted.
(nearestMounted = node.return), nextNode = node.return;
while (nextNode)
}
return 3 === node.tag ? nearestMounted : null // If we didn't hit the root, that means that we're in an disconnected tree
;
}
function getSuspenseInstanceFromFiber(fiber) {
if (13 === fiber.tag) {
var suspenseState = fiber.memoizedState;
if (null === suspenseState) {
var current = fiber.alternate;
null !== current && (suspenseState = current.memoizedState);
}
if (null !== suspenseState) return suspenseState.dehydrated;
}
return null;
}
function getContainerFromFiber(fiber) {
return 3 === fiber.tag ? fiber.stateNode.containerInfo : null;
}
function assertIsMounted(fiber) {
if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
}
function findCurrentFiberUsingSlowPath(fiber) {
var alternate = fiber.alternate;
if (!alternate) {
// If there is no alternate, then we only need to check if it is mounted.
var nearestMounted = getNearestMountedFiber(fiber);
if (null === nearestMounted) throw Error("Unable to find node on an unmounted component.");
return nearestMounted !== fiber ? null : fiber;
} // If we have two possible branches, we'll walk backwards up to the root
for(// to see what path the root points to. On the way we may hit one of the
// special cases and we'll deal with them.
var a = fiber, b = alternate;;){
var parentA = a.return;
if (null === parentA) break;
var parentB = parentA.alternate;
if (null === parentB) {
// There is no alternate. This is an unusual case. Currently, it only
// happens when a Suspense component is hidden. An extra fragment fiber
// is inserted in between the Suspense fiber and its children. Skip
// over this extra fragment fiber and proceed to the next parent.
var nextParent = parentA.return;
if (null !== nextParent) {
a = b = nextParent;
continue;
} // If there's no parent, we're at the root.
break;
} // If both copies of the parent fiber point to the same child, we can
// assume that the child is current. This happens when we bailout on low
// priority: the bailed out fiber's child reuses the current child.
if (parentA.child === parentB.child) {
for(var child = parentA.child; child;){
if (child === a) return(// We've determined that A is the current branch.
assertIsMounted(parentA), fiber);
if (child === b) return(// We've determined that B is the current branch.
assertIsMounted(parentA), alternate);
child = child.sibling;
} // We should never have an alternate for any mounting node. So the only
throw Error("Unable to find node on an unmounted component.");
}
if (a.return !== b.return) // The return pointer of A and the return pointer of B point to different
// fibers. We assume that return pointers never criss-cross, so A must
// belong to the child set of A.return, and B must belong to the child
// set of B.return.
a = parentA, b = parentB;
else {
for(// The return pointers point to the same fiber. We'll have to use the
// default, slow path: scan the child sets of each parent alternate to see
// which child belongs to which set.
//
// Search parent A's child set
var didFindChild = !1, _child = parentA.child; _child;){
if (_child === a) {
didFindChild = !0, a = parentA, b = parentB;
break;
}
if (_child === b) {
didFindChild = !0, b = parentA, a = parentB;
break;
}
_child = _child.sibling;
}
if (!didFindChild) {
for(// Search parent B's child set
_child = parentB.child; _child;){
if (_child === a) {
didFindChild = !0, a = parentB, b = parentA;
break;
}
if (_child === b) {
didFindChild = !0, b = parentB, a = parentA;
break;
}
_child = _child.sibling;
}
if (!didFindChild) throw Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
}
}
if (a.alternate !== b) throw Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
} // If the root is not a host container, we're in a disconnected tree. I.e.
// unmounted.
if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
return a.stateNode.current === a ? fiber : alternate // Otherwise B has to be current branch.
;
}
function findCurrentHostFiber(parent) {
var currentParent = findCurrentFiberUsingSlowPath(parent);
if (!currentParent) return null;
// Next we'll drill down this component to find the first HostComponent/Text.
for(var node = currentParent;;){
if (5 === node.tag || 6 === node.tag) return node;
if (node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === currentParent) break;
for(; !node.sibling;){
if (!node.return || node.return === currentParent) return null;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
} // Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
return null;
}
function doesFiberContain(parentFiber, childFiber) {
for(var node = childFiber, parentFiberAlternate = parentFiber.alternate; null !== node;){
if (node === parentFiber || node === parentFiberAlternate) return !0;
node = node.return;
}
return !1;
}
var hasScheduledReplayAttempt = !1, queuedDiscreteEvents = [], queuedFocus = null, queuedDrag = null, queuedMouse = null, queuedPointers = new Map(), queuedPointerCaptures = new Map(), queuedExplicitHydrationTargets = [], discreteReplayableEvents = [
"mousedown",
"mouseup",
"touchcancel",
"touchend",
"touchstart",
"auxclick",
"dblclick",
"pointercancel",
"pointerdown",
"pointerup",
"dragend",
"dragstart",
"drop",
"compositionend",
"compositionstart",
"keydown",
"keypress",
"keyup",
"input",
"textInput",
"copy",
"cut",
"paste",
"click",
"change",
"contextmenu",
"reset",
"submit"
]; // The queue of discrete events to be replayed.
function isReplayableDiscreteEvent(eventType) {
return discreteReplayableEvents.indexOf(eventType) > -1;
}
function createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
return {
blockedOn: blockedOn,
domEventName: domEventName,
eventSystemFlags: 16 | eventSystemFlags,
nativeEvent: nativeEvent,
targetContainers: [
targetContainer
]
};
}
function queueDiscreteEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
var queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
queuedDiscreteEvents.push(queuedEvent);
} // Resets the replaying for this type of continuous event to no event.
function clearIfContinuousEvent(domEventName, nativeEvent) {
switch(domEventName){
case "focusin":
case "focusout":
queuedFocus = null;
break;
case "dragenter":
case "dragleave":
queuedDrag = null;
break;
case "mouseover":
case "mouseout":
queuedMouse = null;
break;
case "pointerover":
case "pointerout":
var pointerId = nativeEvent.pointerId;
queuedPointers.delete(pointerId);
break;
case "gotpointercapture":
case "lostpointercapture":
var _pointerId = nativeEvent.pointerId;
queuedPointerCaptures.delete(_pointerId);
}
}
function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
if (null === existingQueuedEvent || existingQueuedEvent.nativeEvent !== nativeEvent) {
var queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
if (null !== blockedOn) {
var _fiber2 = getInstanceFromNode(blockedOn);
null !== _fiber2 && // Attempt to increase the priority of this target.
attemptContinuousHydration(_fiber2);
}
return queuedEvent;
} // If we have already queued this exact event, then it's because
// the different event systems have different DOM event listeners.
// We can accumulate the flags, and the targetContainers, and
// store a single event to be replayed.
existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
var targetContainers = existingQueuedEvent.targetContainers;
return null !== targetContainer && -1 === targetContainers.indexOf(targetContainer) && targetContainers.push(targetContainer), existingQueuedEvent;
}
function attemptReplayContinuousQueuedEvent(queuedEvent) {
if (null !== queuedEvent.blockedOn) return !1;
for(var targetContainers = queuedEvent.targetContainers; targetContainers.length > 0;){
var targetContainer = targetContainers[0], nextBlockedOn = attemptToDispatchEvent(queuedEvent.domEventName, queuedEvent.eventSystemFlags, targetContainer, queuedEvent.nativeEvent);
if (null !== nextBlockedOn) {
// We're still blocked. Try again later.
var _fiber3 = getInstanceFromNode(nextBlockedOn);
return null !== _fiber3 && attemptContinuousHydration(_fiber3), queuedEvent.blockedOn = nextBlockedOn, !1;
} // This target container was successfully dispatched. Try the next.
targetContainers.shift();
}
return !0;
}
function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
}
function replayUnblockedEvents() {
for(hasScheduledReplayAttempt = !1; queuedDiscreteEvents.length > 0;){
var nextDiscreteEvent = queuedDiscreteEvents[0];
if (null !== nextDiscreteEvent.blockedOn) {
// We're still blocked.
// Increase the priority of this boundary to unblock
// the next discrete event.
var _fiber4 = getInstanceFromNode(nextDiscreteEvent.blockedOn);
null !== _fiber4 && attemptUserBlockingHydration(_fiber4);
break;
}
for(var targetContainers = nextDiscreteEvent.targetContainers; targetContainers.length > 0;){
var targetContainer = targetContainers[0], nextBlockedOn = attemptToDispatchEvent(nextDiscreteEvent.domEventName, nextDiscreteEvent.eventSystemFlags, targetContainer, nextDiscreteEvent.nativeEvent);
if (null !== nextBlockedOn) {
// We're still blocked. Try again later.
nextDiscreteEvent.blockedOn = nextBlockedOn;
break;
} // This target container was successfully dispatched. Try the next.
targetContainers.shift();
}
null === nextDiscreteEvent.blockedOn && // We've successfully replayed the first event. Let's try the next one.
queuedDiscreteEvents.shift();
} // Next replay any continuous events.
null !== queuedFocus && attemptReplayContinuousQueuedEvent(queuedFocus) && (queuedFocus = null), null !== queuedDrag && attemptReplayContinuousQueuedEvent(queuedDrag) && (queuedDrag = null), null !== queuedMouse && attemptReplayContinuousQueuedEvent(queuedMouse) && (queuedMouse = null), queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap), queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
}
function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
queuedEvent.blockedOn !== unblocked || (queuedEvent.blockedOn = null, hasScheduledReplayAttempt || (hasScheduledReplayAttempt = !0, // now unblocked. This first might not actually be unblocked yet.
// We could check it early to avoid scheduling an unnecessary callback.
unstable_scheduleCallback(unstable_NormalPriority, replayUnblockedEvents)));
}
function retryIfBlockedOn(unblocked) {
// Mark anything that was blocked on this as no longer blocked
// and eligible for a replay.
if (queuedDiscreteEvents.length > 0) {
scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
// worth it because we expect very few discrete events to queue up and once
// we are actually fully unblocked it will be fast to replay them.
for(var i = 1; i < queuedDiscreteEvents.length; i++){
var queuedEvent = queuedDiscreteEvents[i];
queuedEvent.blockedOn === unblocked && (queuedEvent.blockedOn = null);
}
}
null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked), null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked), null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
var unblock = function(queuedEvent) {
return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
};
queuedPointers.forEach(unblock), queuedPointerCaptures.forEach(unblock);
for(var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++){
var queuedTarget = queuedExplicitHydrationTargets[_i];
queuedTarget.blockedOn === unblocked && (queuedTarget.blockedOn = null);
}
for(; queuedExplicitHydrationTargets.length > 0;){
var nextExplicitTarget = queuedExplicitHydrationTargets[0];
if (null !== nextExplicitTarget.blockedOn) break;
!function(queuedTarget) {
// TODO: This function shares a lot of logic with attemptToDispatchEvent.
// Try to unify them. It's a bit tricky since it would require two return
// values.
var targetInst = getClosestInstanceFromNode(queuedTarget.target);
if (null !== targetInst) {
var nearestMounted = getNearestMountedFiber(targetInst);
if (null !== nearestMounted) {
var tag = nearestMounted.tag;
if (13 === tag) {
var instance = getSuspenseInstanceFromFiber(nearestMounted);
if (null !== instance) {
// We're blocked on hydrating this boundary.
// Increase its priority.
queuedTarget.blockedOn = instance, attemptHydrationAtPriority(queuedTarget.lanePriority, function() {
unstable_runWithPriority(queuedTarget.priority, function() {
attemptHydrationAtCurrentPriority(nearestMounted);
});
});
return;
}
} else if (3 === tag && nearestMounted.stateNode.hydrate) {
queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
// a root other than sync.
return;
}
}
}
queuedTarget.blockedOn = null;
}(nextExplicitTarget), null === nextExplicitTarget.blockedOn && // We're unblocked.
queuedExplicitHydrationTargets.shift();
}
}
/**
* Generate a mapping of standard vendor prefixes using the defined style property and event name.
*
* @param {string} styleProp
* @param {string} eventName
* @returns {object}
*/ function makePrefixMap(styleProp, eventName) {
var prefixes = {};
return prefixes[styleProp.toLowerCase()] = eventName.toLowerCase(), prefixes["Webkit" + styleProp] = "webkit" + eventName, prefixes["Moz" + styleProp] = "moz" + eventName, prefixes;
}
/**
* A list of event names to a configurable list of vendor prefixes.
*/ var vendorPrefixes = {
animationend: makePrefixMap("Animation", "AnimationEnd"),
animationiteration: makePrefixMap("Animation", "AnimationIteration"),
animationstart: makePrefixMap("Animation", "AnimationStart"),
transitionend: makePrefixMap("Transition", "TransitionEnd")
}, prefixedEventNames = {}, style = {};
/**
* Attempts to determine the correct vendor prefixed event name.
*
* @param {string} eventName
* @returns {string}
*/ function getVendorPrefixedEventName(eventName) {
if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
if (!vendorPrefixes[eventName]) return eventName;
var prefixMap = vendorPrefixes[eventName];
for(var styleProp in prefixMap)if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) return prefixedEventNames[eventName] = prefixMap[styleProp];
return eventName;
}
!canUseDOM || (style = document.createElement("div").style, "AnimationEvent" in window || (delete vendorPrefixes.animationend.animation, delete vendorPrefixes.animationiteration.animation, delete vendorPrefixes.animationstart.animation), "TransitionEvent" in window || delete vendorPrefixes.transitionend.transition);
var ANIMATION_END = getVendorPrefixedEventName("animationend"), ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"), ANIMATION_START = getVendorPrefixedEventName("animationstart"), TRANSITION_END = getVendorPrefixedEventName("transitionend"), topLevelEventsToReactNames = new Map(), eventPriorities = new Map();
/**
* Turns
* ['abort', ...]
*
* into
*
* topLevelEventsToReactNames = new Map([
* ['abort', 'onAbort'],
* ]);
*
* and registers them.
*/ function registerSimplePluginEventsAndSetTheirPriorities(eventTypes, priority) {
// As the event types are in pairs of two, we need to iterate
// through in twos. The events are in pairs of two to save code
// and improve init perf of processing this array, as it will
// result in far fewer object allocations and property accesses
// if we only use three arrays to process all the categories of
// instead of tuples.
for(var i = 0; i < eventTypes.length; i += 2){
var topEvent = eventTypes[i], event = eventTypes[i + 1], reactName = "on" + (event[0].toUpperCase() + event.slice(1));
eventPriorities.set(topEvent, priority), topLevelEventsToReactNames.set(topEvent, reactName), registerTwoPhaseEvent(reactName, [
topEvent
]);
}
}
var _ReactInternals$Sched$1 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.SchedulerTracing, __interactionsRef = _ReactInternals$Sched$1.__interactionsRef, __subscriberRef = _ReactInternals$Sched$1.__subscriberRef, unstable_getThreadID = (_ReactInternals$Sched$1.unstable_clear, _ReactInternals$Sched$1.unstable_getCurrent, _ReactInternals$Sched$1.unstable_getThreadID), unstable_wrap = (_ReactInternals$Sched$1.unstable_subscribe, _ReactInternals$Sched$1.unstable_trace, _ReactInternals$Sched$1.unstable_unsubscribe, _ReactInternals$Sched$1.unstable_wrap);
// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if (null == __interactionsRef || null == __interactionsRef.current) throw Error("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling");
unstable_now();
// Used by getHighestPriorityLanes and getNextLanes:
var return_highestLanePriority = 8;
function getHighestPriorityLanes(lanes) {
if ((/* */ 1 & lanes) != /* */ 0) return return_highestLanePriority = 15, 1;
if ((/* */ 2 & lanes) != 0) return return_highestLanePriority = 14, 2;
if ((/* */ 4 & lanes) != 0) return return_highestLanePriority = 13, 4;
var inputDiscreteLanes = /* */ 24 & lanes;
if (0 !== inputDiscreteLanes) return return_highestLanePriority = 12, inputDiscreteLanes;
if ((/* */ 32 & lanes) != 0) return return_highestLanePriority = 11, 32;
var inputContinuousLanes = /* */ 192 & lanes;
if (0 !== inputContinuousLanes) return return_highestLanePriority = 10, inputContinuousLanes;
if ((/* */ 256 & lanes) != 0) return return_highestLanePriority = 9, 256;
var defaultLanes = /* */ 3584 & lanes;
if (0 !== defaultLanes) return return_highestLanePriority = 8, defaultLanes;
if ((/* */ 4096 & lanes) != 0) return return_highestLanePriority = 7, 4096;
var transitionLanes = /* */ 4186112 & lanes;
if (0 !== transitionLanes) return return_highestLanePriority = 6, transitionLanes;
var retryLanes = /* */ 62914560 & lanes;
if (0 !== retryLanes) return return_highestLanePriority = 5, retryLanes;
if (/* */ 67108864 & lanes) return return_highestLanePriority = 4, 67108864;
if ((/* */ 134217728 & lanes) != 0) return return_highestLanePriority = 3, 134217728;
var idleLanes = /* */ 805306368 & lanes;
return 0 !== idleLanes ? (return_highestLanePriority = 2, idleLanes) : (/* */ 1073741824 & lanes) != 0 ? (return_highestLanePriority = 1, 1073741824) : (error("Should have found matching lanes. This is a bug in React."), return_highestLanePriority = 8, lanes);
}
function getNextLanes(root, wipLanes) {
// Early bailout if there's no pending work left.
var index, pendingLanes = root.pendingLanes;
if (0 === pendingLanes) return return_highestLanePriority = 0, 0;
var nextLanes = 0, nextLanePriority = 0, expiredLanes = root.expiredLanes, suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes;
if (0 !== expiredLanes) nextLanes = expiredLanes, nextLanePriority = return_highestLanePriority = 15;
else {
// Do not work on any idle work until all the non-idle work has finished,
// even if the work is suspended.
var nonIdlePendingLanes = /* */ 134217727 & pendingLanes;
if (0 !== nonIdlePendingLanes) {
var nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;
if (0 !== nonIdleUnblockedLanes) nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes), nextLanePriority = return_highestLanePriority;
else {
var nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;
0 !== nonIdlePingedLanes && (nextLanes = getHighestPriorityLanes(nonIdlePingedLanes), nextLanePriority = return_highestLanePriority);
}
} else {
// The only remaining work is Idle.
var unblockedLanes = pendingLanes & ~suspendedLanes;
0 !== unblockedLanes ? (nextLanes = getHighestPriorityLanes(unblockedLanes), nextLanePriority = return_highestLanePriority) : 0 !== pingedLanes && (nextLanes = getHighestPriorityLanes(pingedLanes), nextLanePriority = return_highestLanePriority);
}
}
if (0 === nextLanes) // This should only be reachable if we're suspended
// TODO: Consider warning in this path if a fallback timer is not scheduled.
return 0;
// If there are higher priority lanes, we'll include them even if they
// it and we'll lose our progress. We should only do this if the new lanes are
// higher priority.
if (// are suspended.
nextLanes = pendingLanes & (((index = 31 - clz32(nextLanes)) < 0 ? 0 : 1 << index) << 1) - 1, 0 !== wipLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't
// bother waiting until the root is complete.
(wipLanes & suspendedLanes) == 0) {
if (getHighestPriorityLanes(wipLanes), nextLanePriority <= return_highestLanePriority) return wipLanes;
return_highestLanePriority = nextLanePriority;
} // Check for entangled lanes and add them to the batch.
//
// A lane is said to be entangled with another when it's not allowed to render
// in a batch that does not also include the other lane. Typically we do this
// when multiple updates have the same source, and we only want to respond to
// the most recent event from that source.
//
// Note that we apply entanglements *after* checking for partial work above.
// This means that if a lane is entangled during an interleaved event while
// it's already rendering, we won't interrupt it. This is intentional, since
// entanglement is usually "best effort": we'll try our best to render the
// lanes in the same batch, but it's not worth throwing out partially
// completed work in order to do it.
//
// For those exceptions where entanglement is semantically important, like
// useMutableSource, we should ensure that there is no partial work at the
// time we apply the entanglement.
var entangledLanes = root.entangledLanes;
if (0 !== entangledLanes) for(var entanglements = root.entanglements, lanes = nextLanes & entangledLanes; lanes > 0;){
var index1 = pickArbitraryLaneIndex(lanes), lane = 1 << index1;
nextLanes |= entanglements[index1], lanes &= ~lane;
}
return nextLanes;
}
function getLanesToRetrySynchronouslyOnError(root) {
var everythingButOffscreen = -1073741825 & root.pendingLanes;
return 0 !== everythingButOffscreen ? everythingButOffscreen : 1073741824 & everythingButOffscreen ? 1073741824 : 0;
}
function includesNonIdleWork(lanes) {
return (134217727 & lanes) != 0;
}
function includesOnlyRetries(lanes) {
return (62914560 & lanes) === lanes;
}
// be a pure function, so that it always returns the same lane for given inputs.
function findUpdateLane(lanePriority, wipLanes) {
switch(lanePriority){
case 0:
case 6:
case 5:
break;
case 15:
return 1;
case 14:
return 2;
case 12:
var _lane = pickArbitraryLane(24 & ~wipLanes);
if (/* */ 0 === _lane) // Shift to the next priority level
return findUpdateLane(10, wipLanes);
return _lane;
case 10:
var _lane2 = pickArbitraryLane(192 & ~wipLanes);
if (0 === _lane2) // Shift to the next priority level
return findUpdateLane(8, wipLanes);
return _lane2;
case 8:
var _lane3 = pickArbitraryLane(3584 & ~wipLanes);
return 0 === _lane3 && 0 === // If all the default lanes are already being worked on, look for a
// lane in the transition range.
(_lane3 = pickArbitraryLane(4186112 & ~wipLanes)) && // All the transition lanes are taken, too. This should be very
// rare, but as a last resort, pick a default lane. This will have
// the effect of interrupting the current work-in-progress render.
(_lane3 = pickArbitraryLane(3584)), _lane3;
case 2:
var lane = pickArbitraryLane(805306368 & ~wipLanes);
return 0 === lane && (lane = pickArbitraryLane(805306368)), lane;
}
throw Error("Invalid update priority: " + lanePriority + ". This is a bug in React.");
} // To ensure consistency across multiple updates in the same event, this should
function pickArbitraryLane(lanes) {
// This wrapper function gets inlined. Only exists so to communicate that it
// doesn't matter which bit is selected; you can pick any bit without
// affecting the algorithms where its used. Here I'm using
// getHighestPriorityLane because it requires the fewest operations.
return lanes & -lanes;
}
function pickArbitraryLaneIndex(lanes) {
return 31 - clz32(lanes);
}
function includesSomeLane(a, b) {
return (a & b) != 0;
}
function createLaneMap(initial) {
for(var laneMap = [], i = 0; i < 31; i++)laneMap.push(initial);
return laneMap;
}
function markRootUpdated(root, updateLane, eventTime) {
root.pendingLanes |= updateLane;
// it's not practical to try every single possible combination. We need a
// heuristic to decide which lanes to attempt to render, and in which batches.
// For now, we use the same heuristic as in the old ExpirationTimes model:
// retry any lane at equal or lower priority, but don't try updates at higher
// priority without also including the lower priority updates. This works well
// when considering updates across different priority levels, but isn't
// sufficient for updates within the same priority, since we want to treat
// those updates as parallel.
// Unsuspend any update at equal or lower priority.
var higherPriorityLanes = updateLane - 1; // Turns 0b1000 into 0b0111
root.suspendedLanes &= higherPriorityLanes, root.pingedLanes &= higherPriorityLanes, // recent event, and we assume time is monotonically increasing.
root.eventTimes[pickArbitraryLaneIndex(updateLane)] = eventTime;
}
function markRootPinged(root, pingedLanes, eventTime) {
root.pingedLanes |= root.suspendedLanes & pingedLanes;
}
function markRootMutableRead(root, updateLane) {
root.mutableReadLanes |= updateLane & root.pendingLanes;
}
var clz32 = Math.clz32 ? Math.clz32 : function(lanes) {
return 0 === lanes ? 32 : 31 - (log(lanes) / LN2 | 0) | 0;
}, log = Math.log, LN2 = Math.LN2, _enabled = !0; // Count leading zeros. Only used on lanes, so assume input is an integer.
function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
var timeStamp;
nativeEvent.timeStamp, isInsideEventHandler || flushDiscreteUpdatesImpl(), function(fn, a, b, c, d) {
var prevIsInsideEventHandler = isInsideEventHandler;
isInsideEventHandler = !0;
try {
return discreteUpdatesImpl(fn, a, b, c, d);
} finally{
(isInsideEventHandler = prevIsInsideEventHandler) || finishEventHandler();
}
}(dispatchEvent, domEventName, eventSystemFlags, container, nativeEvent);
}
function dispatchUserBlockingUpdate(domEventName, eventSystemFlags, container, nativeEvent) {
unstable_runWithPriority(unstable_UserBlockingPriority, dispatchEvent.bind(null, domEventName, eventSystemFlags, container, nativeEvent));
}
function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
if (_enabled) {
var allowReplay = !0;
if (// TODO: replaying capture phase events is currently broken
// because we used to do it during top-level native bubble handlers
// but now we use different bubble and capture handlers.
// In eager mode, we attach capture listeners early, so we need
// to filter them out until we fix the logic to handle them correctly.
// This could've been outside the flag but I put it inside to reduce risk.
(allowReplay = (4 & eventSystemFlags) == 0) && queuedDiscreteEvents.length > 0 && isReplayableDiscreteEvent(domEventName)) {
// If we already have a queue of discrete events, and this is another discrete
// event, then we can't dispatch it regardless of its target, since they
// need to dispatch in order.
queueDiscreteEvent(null, domEventName, eventSystemFlags, targetContainer, nativeEvent);
return;
}
var blockedOn = attemptToDispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent);
if (null === blockedOn) {
// We successfully dispatched this event.
allowReplay && clearIfContinuousEvent(domEventName, nativeEvent);
return;
}
if (allowReplay) {
if (isReplayableDiscreteEvent(domEventName)) {
// This this to be replayed later once the target is available.
queueDiscreteEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);
return;
}
if (function(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
// These set relatedTarget to null because the replayed event will be treated as if we
// moved from outside the window (no target) onto the target once it hydrates.
// Instead of mutating we could clone the event.
switch(domEventName){
case "focusin":
return queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent), !0;
case "dragenter":
return queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent), !0;
case "mouseover":
return queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent), !0;
case "pointerover":
var pointerId = nativeEvent.pointerId;
return queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)), !0;
case "gotpointercapture":
var _pointerId2 = nativeEvent.pointerId;
return queuedPointerCaptures.set(_pointerId2, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(_pointerId2) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)), !0;
}
return !1;
} // Check if this target is unblocked. Returns true if it's unblocked.
(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) return;
// We need to clear only if we didn't queue because
// queueing is accummulative.
clearIfContinuousEvent(domEventName, nativeEvent);
} // This is not replayable so we'll invoke it but without a target,
// in case the event system needs to trace it.
dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, null, targetContainer);
}
} // Attempt dispatching an event. Returns a SuspenseInstance or Container if it's blocked.
function attemptToDispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
var targetInst = getClosestInstanceFromNode(getEventTarget(nativeEvent));
if (null !== targetInst) {
var nearestMounted = getNearestMountedFiber(targetInst);
if (null === nearestMounted) // This tree has been unmounted already. Dispatch without a target.
targetInst = null;
else {
var tag = nearestMounted.tag;
if (13 === tag) {
var instance = getSuspenseInstanceFromFiber(nearestMounted);
if (null !== instance) // Queue the event to be replayed later. Abort dispatching since we
// don't want this event dispatched twice through the event system.
// TODO: If this is the first discrete event in the queue. Schedule an increased
// priority for this boundary.
return instance;
// This shouldn't happen, something went wrong but to avoid blocking
// the whole system, dispatch the event without a target.
// TODO: Warn.
targetInst = null;
} else if (3 === tag) {
if (nearestMounted.stateNode.hydrate) // If this happens during a replay something went wrong and it might block
// the whole system.
return getContainerFromFiber(nearestMounted);
targetInst = null;
} else nearestMounted !== targetInst && // If we get an event (ex: img onload) before committing that
// component's mount, ignore it for now (that is, treat it as if it was an
// event on a non-React tree). We might also consider queueing events and
// dispatching them after the mount.
(targetInst = null);
}
}
return dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer), null;
}
/**
* These variables store information about text content of a target node,
* allowing comparison of content before and after a given event.
*
* Identify the node where selection currently begins, then observe
* both its text content and its current position in the DOM. Since the
* browser may natively replace the target node during composition, we can
* use its position to find its replacement.
*
*
*/ var root = null, startText = null, fallbackText = null;
function getData() {
if (fallbackText) return fallbackText;
var start, end, startValue = startText, startLength = startValue.length, endValue = getText(), endLength = endValue.length;
for(start = 0; start < startLength && startValue[start] === endValue[start]; start++);
var minEnd = startLength - start;
for(end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++);
var sliceTail = end > 1 ? 1 - end : void 0;
return fallbackText = endValue.slice(start, sliceTail);
}
function getText() {
return "value" in root ? root.value : root.textContent;
}
/**
* `charCode` represents the actual "character code" and is safe to use with
* `String.fromCharCode`. As such, only keys that correspond to printable
* characters produce a valid `charCode`, the only exception to this is Enter.
* The Tab-key is considered non-printable and does not have a `charCode`,
* presumably because it does not produce a tab-character in browsers.
*
* @param {object} nativeEvent Native browser event.
* @return {number} Normalized `charCode` property.
*/ function getEventCharCode(nativeEvent) {
var charCode, keyCode = nativeEvent.keyCode;
return(// Must not discard the (non-)printable Enter-key.
("charCode" in nativeEvent ? 0 === (charCode = nativeEvent.charCode) && 13 === keyCode && (charCode = 13) : // IE8 does not implement `charCode`, but `keyCode` has the correct value.
charCode = keyCode, 10 === charCode && (charCode = 13), charCode >= 32 || 13 === charCode) ? charCode : 0);
}
function functionThatReturnsTrue() {
return !0;
}
function functionThatReturnsFalse() {
return !1;
} // This is intentionally a factory so that we have different returned constructors.
// If we had a single constructor, it would be megamorphic and engines would deopt.
function createSyntheticEvent(Interface) {
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*/ function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
for(var _propName in this._reactName = reactName, this._targetInst = targetInst, this.type = reactEventType, this.nativeEvent = nativeEvent, this.target = nativeEventTarget, this.currentTarget = null, Interface)if (Interface.hasOwnProperty(_propName)) {
var normalize = Interface[_propName];
normalize ? this[_propName] = normalize(nativeEvent) : this[_propName] = nativeEvent[_propName];
}
return (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? this.isDefaultPrevented = functionThatReturnsTrue : this.isDefaultPrevented = functionThatReturnsFalse, this.isPropagationStopped = functionThatReturnsFalse, this;
}
return _assign(SyntheticBaseEvent.prototype, {
preventDefault: function() {
this.defaultPrevented = !0;
var event = this.nativeEvent;
event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
},
stopPropagation: function() {
var event = this.nativeEvent;
event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && // The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// IE specific).
(event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
},
/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/ persist: function() {
// Modern event system doesn't use pooling.
},
/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/ isPersistent: functionThatReturnsTrue
}), SyntheticBaseEvent;
}
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/ var EventInterface = {
eventPhase: 0,
bubbles: 0,
cancelable: 0,
timeStamp: function(event) {
return event.timeStamp || Date.now();
},
defaultPrevented: 0,
isTrusted: 0
}, SyntheticEvent = createSyntheticEvent(EventInterface), UIEventInterface = _assign({}, EventInterface, {
view: 0,
detail: 0
}), SyntheticUIEvent = createSyntheticEvent(UIEventInterface), MouseEventInterface = _assign({}, UIEventInterface, {
screenX: 0,
screenY: 0,
clientX: 0,
clientY: 0,
pageX: 0,
pageY: 0,
ctrlKey: 0,
shiftKey: 0,
altKey: 0,
metaKey: 0,
getModifierState: getEventModifierState,
button: 0,
buttons: 0,
relatedTarget: function(event) {
return void 0 === event.relatedTarget ? event.fromElement === event.srcElement ? event.toElement : event.fromElement : event.relatedTarget;
},
movementX: function(event) {
return "movementX" in event ? event.movementX : (event !== lastMouseEvent && (lastMouseEvent && "mousemove" === event.type ? (lastMovementX = event.screenX - lastMouseEvent.screenX, lastMovementY = event.screenY - lastMouseEvent.screenY) : (lastMovementX = 0, lastMovementY = 0), lastMouseEvent = event), lastMovementX);
},
movementY: function(event) {
return "movementY" in event ? event.movementY : lastMovementY // Don't need to call updateMouseMovementPolyfillState() here
;
}
}), SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface), SyntheticDragEvent = createSyntheticEvent(_assign({}, MouseEventInterface, {
dataTransfer: 0
})), SyntheticFocusEvent = createSyntheticEvent(_assign({}, UIEventInterface, {
relatedTarget: 0
})), SyntheticAnimationEvent = createSyntheticEvent(_assign({}, EventInterface, {
animationName: 0,
elapsedTime: 0,
pseudoElement: 0
})), SyntheticClipboardEvent = createSyntheticEvent(_assign({}, EventInterface, {
clipboardData: function(event) {
return "clipboardData" in event ? event.clipboardData : window.clipboardData;
}
})), SyntheticCompositionEvent = createSyntheticEvent(_assign({}, EventInterface, {
data: 0
})), normalizeKey = {
Esc: "Escape",
Spacebar: " ",
Left: "ArrowLeft",
Up: "ArrowUp",
Right: "ArrowRight",
Down: "ArrowDown",
Del: "Delete",
Win: "OS",
Menu: "ContextMenu",
Apps: "ContextMenu",
Scroll: "ScrollLock",
MozPrintableKey: "Unidentified"
}, translateToKey = {
8: "Backspace",
9: "Tab",
12: "Clear",
13: "Enter",
16: "Shift",
17: "Control",
18: "Alt",
19: "Pause",
20: "CapsLock",
27: "Escape",
32: " ",
33: "PageUp",
34: "PageDown",
35: "End",
36: "Home",
37: "ArrowLeft",
38: "ArrowUp",
39: "ArrowRight",
40: "ArrowDown",
45: "Insert",
46: "Delete",
112: "F1",
113: "F2",
114: "F3",
115: "F4",
116: "F5",
117: "F6",
118: "F7",
119: "F8",
120: "F9",
121: "F10",
122: "F11",
123: "F12",
144: "NumLock",
145: "ScrollLock",
224: "Meta"
}, modifierKeyToProp = {
Alt: "altKey",
Control: "ctrlKey",
Meta: "metaKey",
Shift: "shiftKey"
};
// getModifierState. If getModifierState is not supported, we map it to a set of
// modifier keys exposed by the event. In this case, Lock-keys are not supported.
function modifierStateGetter(keyArg) {
var nativeEvent = this.nativeEvent;
if (nativeEvent.getModifierState) return nativeEvent.getModifierState(keyArg);
var keyProp = modifierKeyToProp[keyArg];
return !!keyProp && !!nativeEvent[keyProp];
}
function getEventModifierState(nativeEvent) {
return modifierStateGetter;
}
var SyntheticKeyboardEvent = createSyntheticEvent(_assign({}, UIEventInterface, {
key: /**
* @param {object} nativeEvent Native browser event.
* @return {string} Normalized `key` property.
*/ function(nativeEvent) {
if (nativeEvent.key) {
// Normalize inconsistent values reported by browsers due to
// implementations of a working draft specification.
// FireFox implements `key` but returns `MozPrintableKey` for all
// printable characters (normalized to `Unidentified`), ignore it.
var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
if ("Unidentified" !== key) return key;
} // Browser does not implement `key`, polyfill as much of it as we can.
if ("keypress" === nativeEvent.type) {
var charCode = getEventCharCode(nativeEvent); // The enter-key is technically both printable and non-printable and can
// thus be captured by `keypress`, no other non-printable key should.
return 13 === charCode ? "Enter" : String.fromCharCode(charCode);
}
return "keydown" === nativeEvent.type || "keyup" === nativeEvent.type ? translateToKey[nativeEvent.keyCode] || "Unidentified" : "";
},
code: 0,
location: 0,
ctrlKey: 0,
shiftKey: 0,
altKey: 0,
metaKey: 0,
repeat: 0,
locale: 0,
getModifierState: getEventModifierState,
// Legacy Interface
charCode: function(event) {
return(// `charCode` is the result of a KeyPress event and represents the value of
// the actual printable character.
// KeyPress is deprecated, but its replacement is not yet final and not
// implemented in any major browser. Only KeyPress has charCode.
"keypress" === event.type ? getEventCharCode(event) : 0);
},
keyCode: function(event) {
return(// `keyCode` is the result of a KeyDown/Up event and represents the value of
// physical keyboard key.
// The actual meaning of the value depends on the users' keyboard layout
// which cannot be detected. Assuming that it is a US keyboard layout
// provides a surprisingly accurate mapping for US and European users.
// Due to this, it is left to the user to implement at this time.
"keydown" === event.type || "keyup" === event.type ? event.keyCode : 0);
},
which: function(event) {
return(// `which` is an alias for either `keyCode` or `charCode` depending on the
// type of the event.
"keypress" === event.type ? getEventCharCode(event) : "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0);
}
})), SyntheticPointerEvent = createSyntheticEvent(_assign({}, MouseEventInterface, {
pointerId: 0,
width: 0,
height: 0,
pressure: 0,
tangentialPressure: 0,
tiltX: 0,
tiltY: 0,
twist: 0,
pointerType: 0,
isPrimary: 0
})), SyntheticTouchEvent = createSyntheticEvent(_assign({}, UIEventInterface, {
touches: 0,
targetTouches: 0,
changedTouches: 0,
altKey: 0,
metaKey: 0,
ctrlKey: 0,
shiftKey: 0,
getModifierState: getEventModifierState
})), SyntheticTransitionEvent = createSyntheticEvent(_assign({}, EventInterface, {
propertyName: 0,
elapsedTime: 0,
pseudoElement: 0
})), SyntheticWheelEvent = createSyntheticEvent(_assign({}, MouseEventInterface, {
deltaX: function(event) {
return "deltaX" in event ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
: "wheelDeltaX" in event ? -event.wheelDeltaX : 0;
},
deltaY: function(event) {
return "deltaY" in event ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
: "wheelDeltaY" in event ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
: "wheelDelta" in event ? -event.wheelDelta : 0;
},
deltaZ: 0,
// Browsers without "deltaMode" is reporting in raw wheel delta where one
// notch on the scroll is always +/- 120, roughly equivalent to pixels.
// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
deltaMode: 0
})), END_KEYCODES = [
9,
13,
27,
32
], canUseCompositionEvent = canUseDOM && "CompositionEvent" in window, documentMode = null;
canUseDOM && "documentMode" in document && (documentMode = document.documentMode);
// directly represent `beforeInput`. The IE `textinput` event is not as
// useful, so we don't use it.
var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode, useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11), hasSpaceKeypress = !1; // In IE9+, we have access to composition events, but the data supplied
/**
* Does our fallback mode think that this event is the end of composition?
*/ function isFallbackCompositionEnd(domEventName, nativeEvent) {
switch(domEventName){
case "keyup":
// Command keys insert or clear IME input.
return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
case "keydown":
// Expect IME keyCode on each keydown. If we get any other
// code we must have exited earlier.
return 229 !== nativeEvent.keyCode;
case "keypress":
case "mousedown":
case "focusout":
// Events are not possible without cancelling IME.
return !0;
default:
return !1;
}
}
/**
* Google Input Tools provides composition data via a CustomEvent,
* with the `data` property populated in the `detail` object. If this
* is available on the event object, use it. If not, this is a plain
* composition event and we have nothing special to extract.
*
* @param {object} nativeEvent
* @return {?string}
*/ function getDataFromCustomEvent(nativeEvent) {
var detail = nativeEvent.detail;
return "object" == typeof detail && "data" in detail ? detail.data : null;
}
/**
* Check if a composition event was triggered by Korean IME.
* Our fallback mode does not work well with IE's Korean IME,
* so just use native composition events when Korean IME is used.
* Although CompositionEvent.locale property is deprecated,
* it is available in IE, where our fallback mode is enabled.
*
* @param {object} nativeEvent
* @return {boolean}
*/ function isUsingKoreanIME(nativeEvent) {
return "ko" === nativeEvent.locale;
} // Track the current IME composition status, if any.
var isComposing = !1, supportedInputTypes = {
color: !0,
date: !0,
datetime: !0,
"datetime-local": !0,
email: !0,
month: !0,
number: !0,
password: !0,
range: !0,
search: !0,
tel: !0,
text: !0,
time: !0,
url: !0,
week: !0
};
function isTextInputElement(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName;
}
function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
// Flag this event loop as needing state restore.
enqueueStateRestore(target);
var listeners = accumulateTwoPhaseListeners(inst, "onChange");
if (listeners.length > 0) {
var event = new SyntheticEvent("onChange", "change", null, nativeEvent, target);
dispatchQueue.push({
event: event,
listeners: listeners
});
}
}
/**
* For IE shims
*/ var activeElement = null, activeElementInst = null;
function runEventInBatch(dispatchQueue) {
processDispatchQueue(dispatchQueue, 0);
}
function getInstIfValueChanged(targetInst) {
if (updateValueIfChanged(getNodeFromInstance(targetInst))) return targetInst;
}
function getTargetInstForChangeEvent(domEventName, targetInst) {
if ("change" === domEventName) return targetInst;
}
/**
* SECTION: handle `input` event
*/ var isInputEventSupported = !1;
/**
* (For IE <=9) Removes the event listeners from the currently-tracked element,
* if any exists.
*/ function stopWatchingForValueChange() {
activeElement && (activeElement.detachEvent("onpropertychange", handlePropertyChange), activeElement = null, activeElementInst = null);
}
/**
* (For IE <=9) Handles a propertychange event, sending a `change` event if
* the value of the active element has changed.
*/ function handlePropertyChange(nativeEvent) {
if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst)) {
var dispatchQueue;
createAndAccumulateChangeEvent(dispatchQueue = [], activeElementInst, nativeEvent, getEventTarget(nativeEvent)), // other events and have it go through ReactBrowserEventEmitter. Since it
// doesn't, we manually listen for the events and so we have to enqueue and
// process the abstract event manually.
//
// Batching is necessary here in order to ensure that all event handlers run
// before the next rerender (including event handlers attached to ancestor
// elements instead of directly on the input). Without this, controlled
// components don't work properly in conjunction with event bubbling because
// the component is rerendered and the value reverted before all the event
// handlers can run. See https://github.com/facebook/react/issues/708.
function(fn, bookkeeping) {
if (isInsideEventHandler) // If we are currently inside another batch, we need to wait until it
// fully completes before restoring state.
return fn(bookkeeping);
isInsideEventHandler = !0;
try {
return batchedUpdatesImpl(fn, bookkeeping);
} finally{
isInsideEventHandler = !1, finishEventHandler();
}
}(runEventInBatch, dispatchQueue);
}
}
function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
if ("focusin" === domEventName) // In IE9, propertychange fires for most input events but is buggy and
// doesn't fire when text is deleted, but conveniently, selectionchange
// appears to fire in all of the remaining cases so we catch those and
// forward the event if the value has changed
// In either case, we don't want to call the event handler if the value
// is changed from JS so we redefine a setter for `.value` that updates
// our activeElementValue variable, allowing us to ignore those changes
//
// stopWatching() should be a noop here but we call it just in case we
// missed a blur event somehow.
stopWatchingForValueChange(), activeElement = target, activeElementInst = targetInst, activeElement.attachEvent("onpropertychange", handlePropertyChange);
else "focusout" === domEventName && stopWatchingForValueChange();
} // For IE8 and IE9.
function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName) // On the selectionchange event, the target is just document which isn't
// helpful for us so just check activeElement instead.
//
// 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
// propertychange on the first input event after setting `value` from a
// script and fires only keydown, keypress, keyup. Catching keyup usually
// gets it and catching keydown lets us fire an event for the first
// keystroke if user does a key repeat (it'll be a little delayed: right
// before the second keystroke). Other input methods (e.g., paste) seem to
// fire selectionchange normally.
return getInstIfValueChanged(activeElementInst);
}
function getTargetInstForClickEvent(domEventName, targetInst) {
if ("click" === domEventName) return getInstIfValueChanged(targetInst);
}
function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
if ("input" === domEventName || "change" === domEventName) return getInstIfValueChanged(targetInst);
}
canUseDOM && // IE9 claims to support the input event but fails to trigger it when
// deleting text, so we ignore its input events.
(isInputEventSupported = /**
* Checks if an event is supported in the current execution environment.
*
* NOTE: This will not work correctly for non-generic events such as `change`,
* `reset`, `load`, `error`, and `select`.
*
* Borrows from Modernizr.
*
* @param {string} eventNameSuffix Event name, e.g. "click".
* @return {boolean} True if the event is supported.
* @internal
* @license Modernizr 3.0.0pre (Custom Build) | MIT
*/ function(eventNameSuffix) {
if (!canUseDOM) return !1;
var eventName = "on" + eventNameSuffix, isSupported = eventName in document;
if (!isSupported) {
var element = document.createElement("div");
element.setAttribute(eventName, "return;"), isSupported = "function" == typeof element[eventName];
}
return isSupported;
}("input") && (!document.documentMode || document.documentMode > 9));
var objectIs = "function" == typeof Object.is ? Object.is : /**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/ function(x, y) {
return x === y && (0 !== x || 1 / x == 1 / y) || x != x && y != y // eslint-disable-line no-self-compare
;
}, hasOwnProperty$2 = Object.prototype.hasOwnProperty;
/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/ function shallowEqual(objA, objB) {
if (objectIs(objA, objB)) return !0;
if ("object" != typeof objA || null === objA || "object" != typeof objB || null === objB) return !1;
var keysA = Object.keys(objA), keysB = Object.keys(objB);
if (keysA.length !== keysB.length) return !1;
// Test for A's keys different from B.
for(var i = 0; i < keysA.length; i++)if (!hasOwnProperty$2.call(objB, keysA[i]) || !objectIs(objA[keysA[i]], objB[keysA[i]])) return !1;
return !0;
}
/**
* Given any node return the first leaf node without children.
*
* @param {DOMElement|DOMTextNode} node
* @return {DOMElement|DOMTextNode}
*/ function getLeafNode(node) {
for(; node && node.firstChild;)node = node.firstChild;
return node;
}
/**
* Get object describing the nodes which contain characters at offset.
*
* @param {DOMElement|DOMTextNode} root
* @param {number} offset
* @return {?object}
*/ function getNodeForCharacterOffset(root, offset) {
for(var node = getLeafNode(root), nodeStart = 0, nodeEnd = 0; node;){
if (3 === node.nodeType) {
if (nodeEnd = nodeStart + node.textContent.length, nodeStart <= offset && nodeEnd >= offset) return {
node: node,
offset: offset - nodeStart
};
nodeStart = nodeEnd;
}
node = getLeafNode(/**
* Get the next sibling within a container. This will walk up the
* DOM if a node's siblings have been exhausted.
*
* @param {DOMElement|DOMTextNode} node
* @return {?DOMElement|DOMTextNode}
*/ function(node) {
for(; node;){
if (node.nextSibling) return node.nextSibling;
node = node.parentNode;
}
}(node));
}
}
function isTextNode(node) {
return node && 3 === node.nodeType;
}
function getActiveElementDeep() {
for(var win = window, element = getActiveElement(); element instanceof win.HTMLIFrameElement && function(iframe) {
try {
// Accessing the contentDocument of a HTMLIframeElement can cause the browser
// to throw, e.g. if it has a cross-origin src attribute.
// Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
// iframe.contentDocument.defaultView;
// A safety way is to access one of the cross origin properties: Window or Location
// Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
// https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
return "string" == typeof iframe.contentWindow.location.href;
} catch (err) {
return !1;
}
}(element);)element = getActiveElement((win = element.contentWindow).document);
return element;
}
/**
* @ReactInputSelection: React input selection module. Based on Selection.js,
* but modified to be suitable for react and has a couple of bug fixes (doesn't
* assume buttons have range selections allowed).
* Input selection module for React.
*/ /**
* @hasSelectionCapabilities: we get the element types that support selection
* from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
* and `selectionEnd` rows.
*/ function hasSelectionCapabilities(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
}
var skipSelectionChangeEvent = canUseDOM && "documentMode" in document && document.documentMode <= 11, activeElement$1 = null, activeElementInst$1 = null, lastSelection = null, mouseDown = !1;
/**
* Poll selection to see whether it's changed.
*
* @param {object} nativeEvent
* @param {object} nativeEventTarget
* @return {?SyntheticEvent}
*/ function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
// Ensure we have the right element, and that the user is not dragging a
// selection (this matches native `select` event behavior). In HTML5, select
// fires only on input and textarea thus if there's no focused element we
// won't dispatch.
var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
if (!mouseDown && null != activeElement$1 && activeElement$1 === getActiveElement(doc)) {
var currentSelection = /**
* Get an object which is a unique representation of the current selection.
*
* The return value will not be consistent across nodes or browsers, but
* two identical selections on the same node will return identical objects.
*/ function(node) {
if ("selectionStart" in node && hasSelectionCapabilities(node)) return {
start: node.selectionStart,
end: node.selectionEnd
};
var selection = (node.ownerDocument && node.ownerDocument.defaultView || window).getSelection();
return {
anchorNode: selection.anchorNode,
anchorOffset: selection.anchorOffset,
focusNode: selection.focusNode,
focusOffset: selection.focusOffset
};
}(activeElement$1);
if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
lastSelection = currentSelection;
var listeners = accumulateTwoPhaseListeners(activeElementInst$1, "onSelect");
if (listeners.length > 0) {
var event = new SyntheticEvent("onSelect", "select", null, nativeEvent, nativeEventTarget);
dispatchQueue.push({
event: event,
listeners: listeners
}), event.target = activeElement$1;
}
}
} // Only fire when selection has actually changed.
}
registerSimplePluginEventsAndSetTheirPriorities([
'cancel',
'cancel',
'click',
'click',
'close',
'close',
'contextmenu',
'contextMenu',
'copy',
'copy',
'cut',
'cut',
'auxclick',
'auxClick',
'dblclick',
'doubleClick',
'dragend',
'dragEnd',
'dragstart',
'dragStart',
'drop',
'drop',
'focusin',
'focus',
'focusout',
'blur',
'input',
'input',
'invalid',
'invalid',
'keydown',
'keyDown',
'keypress',
'keyPress',
'keyup',
'keyUp',
'mousedown',
'mouseDown',
'mouseup',
'mouseUp',
'paste',
'paste',
'pause',
'pause',
'play',
'play',
'pointercancel',
'pointerCancel',
'pointerdown',
'pointerDown',
'pointerup',
'pointerUp',
'ratechange',
'rateChange',
'reset',
'reset',
'seeked',
'seeked',
'submit',
'submit',
'touchcancel',
'touchCancel',
'touchend',
'touchEnd',
'touchstart',
'touchStart',
'volumechange',
'volumeChange'
], 0), registerSimplePluginEventsAndSetTheirPriorities([
'drag',
'drag',
'dragenter',
'dragEnter',
'dragexit',
'dragExit',
'dragleave',
'dragLeave',
'dragover',
'dragOver',
'mousemove',
'mouseMove',
'mouseout',
'mouseOut',
'mouseover',
'mouseOver',
'pointermove',
'pointerMove',
'pointerout',
'pointerOut',
'pointerover',
'pointerOver',
'scroll',
'scroll',
'toggle',
'toggle',
'touchmove',
'touchMove',
'wheel',
'wheel'
], 1), registerSimplePluginEventsAndSetTheirPriorities([
"abort",
"abort",
ANIMATION_END,
"animationEnd",
ANIMATION_ITERATION,
"animationIteration",
ANIMATION_START,
"animationStart",
"canplay",
"canPlay",
"canplaythrough",
"canPlayThrough",
"durationchange",
"durationChange",
"emptied",
"emptied",
"encrypted",
"encrypted",
"ended",
"ended",
"error",
"error",
"gotpointercapture",
"gotPointerCapture",
"load",
"load",
"loadeddata",
"loadedData",
"loadedmetadata",
"loadedMetadata",
"loadstart",
"loadStart",
"lostpointercapture",
"lostPointerCapture",
"playing",
"playing",
"progress",
"progress",
"seeking",
"seeking",
"stalled",
"stalled",
"suspend",
"suspend",
"timeupdate",
"timeUpdate",
TRANSITION_END,
"transitionEnd",
"waiting",
"waiting"
], 2), function(eventTypes, priority) {
for(var i = 0; i < eventTypes.length; i++)eventPriorities.set(eventTypes[i], 0);
}([
"change",
"selectionchange",
"textInput",
"compositionstart",
"compositionend",
"compositionupdate"
], 0), registerDirectEvent("onMouseEnter", [
"mouseout",
"mouseover"
]), registerDirectEvent("onMouseLeave", [
"mouseout",
"mouseover"
]), registerDirectEvent("onPointerEnter", [
"pointerout",
"pointerover"
]), registerDirectEvent("onPointerLeave", [
"pointerout",
"pointerover"
]), registerTwoPhaseEvent("onChange", [
"change",
"click",
"focusin",
"focusout",
"input",
"keydown",
"keyup",
"selectionchange"
]), registerTwoPhaseEvent("onSelect", [
"focusout",
"contextmenu",
"dragend",
"focusin",
"keydown",
"keyup",
"mousedown",
"mouseup",
"selectionchange"
]), registerTwoPhaseEvent("onBeforeInput", [
"compositionend",
"keypress",
"textInput",
"paste"
]), registerTwoPhaseEvent("onCompositionEnd", [
"compositionend",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown"
]), registerTwoPhaseEvent("onCompositionStart", [
"compositionstart",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown"
]), registerTwoPhaseEvent("onCompositionUpdate", [
"compositionupdate",
"focusout",
"keydown",
"keypress",
"keyup",
"mousedown"
]);
var mediaEventTypes = [
"abort",
"canplay",
"canplaythrough",
"durationchange",
"emptied",
"encrypted",
"ended",
"error",
"loadeddata",
"loadedmetadata",
"loadstart",
"pause",
"play",
"playing",
"progress",
"ratechange",
"seeked",
"seeking",
"stalled",
"suspend",
"timeupdate",
"volumechange",
"waiting"
], nonDelegatedEvents = new Set([
"cancel",
"close",
"invalid",
"load",
"scroll",
"toggle"
].concat(mediaEventTypes)); // We should not delegate these events to the container, but rather
function executeDispatch(event, listener, currentTarget) {
var type = event.type || "unknown-event";
event.currentTarget = currentTarget, /**
* Same as invokeGuardedCallback, but instead of returning an error, it stores
* it in a global so it can be rethrown by `rethrowCaughtError` later.
* TODO: See if caughtError and rethrowError can be unified.
*
* @param {String} name of the guard to use for logging or debugging
* @param {Function} func The function to invoke
* @param {*} context The context to use when calling the function
* @param {...*} args Arguments for function
*/ function(name, func, context, a, b, c, d, e, f) {
if (invokeGuardedCallback.apply(this, arguments), hasError) {
var error = clearCaughtError();
hasRethrowError || (hasRethrowError = !0, rethrowError = error);
}
}(type, listener, void 0, event), event.currentTarget = null;
}
function processDispatchQueue(dispatchQueue, eventSystemFlags) {
for(var inCapturePhase = (4 & eventSystemFlags) != 0, i = 0; i < dispatchQueue.length; i++){
var _dispatchQueue$i = dispatchQueue[i];
!function(event, dispatchListeners, inCapturePhase) {
var previousInstance;
if (inCapturePhase) for(var i = dispatchListeners.length - 1; i >= 0; i--){
var _dispatchListeners$i = dispatchListeners[i], instance = _dispatchListeners$i.instance, currentTarget = _dispatchListeners$i.currentTarget, listener = _dispatchListeners$i.listener;
if (instance !== previousInstance && event.isPropagationStopped()) return;
executeDispatch(event, listener, currentTarget), previousInstance = instance;
}
else for(var _i = 0; _i < dispatchListeners.length; _i++){
var _dispatchListeners$_i = dispatchListeners[_i], _instance = _dispatchListeners$_i.instance, _currentTarget = _dispatchListeners$_i.currentTarget, _listener = _dispatchListeners$_i.listener;
if (_instance !== previousInstance && event.isPropagationStopped()) return;
executeDispatch(event, _listener, _currentTarget), previousInstance = _instance;
}
}(_dispatchQueue$i.event, _dispatchQueue$i.listeners, inCapturePhase); // event system doesn't use pooling.
} // This would be a good time to rethrow if any of the event handlers threw.
!/**
* During execution of guarded functions we will capture the first error which
* we will rethrow to be handled by the top level error handler.
*/ function() {
if (hasRethrowError) {
var error = rethrowError;
throw hasRethrowError = !1, rethrowError = null, error;
}
}();
}
function listenToNonDelegatedEvent(domEventName, targetElement) {
var listenerSet = getEventListenerSet(targetElement), listenerSetKey = getListenerSetKey(domEventName, !1);
listenerSet.has(listenerSetKey) || (addTrappedEventListener(targetElement, domEventName, 2, !1), listenerSet.add(listenerSetKey));
}
var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
function listenToAllSupportedEvents(rootContainerElement) {
!rootContainerElement[listeningMarker] && (rootContainerElement[listeningMarker] = !0, allNativeEvents.forEach(function(domEventName) {
nonDelegatedEvents.has(domEventName) || listenToNativeEvent(domEventName, !1, rootContainerElement, null), listenToNativeEvent(domEventName, !0, rootContainerElement, null);
}));
}
function listenToNativeEvent(domEventName, isCapturePhaseListener, rootContainerElement, targetElement) {
var eventSystemFlags = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : 0, target = rootContainerElement;
// register it to the root container. Otherwise, we should
// register the event to the target element and mark it as
// a non-delegated event.
if ("selectionchange" === domEventName && 9 !== rootContainerElement.nodeType && (target = rootContainerElement.ownerDocument), null !== targetElement && !isCapturePhaseListener && nonDelegatedEvents.has(domEventName)) {
// For all non-delegated events, apart from scroll, we attach
// their event listeners to the respective elements that their
// events fire on. That means we can skip this step, as event
// listener has already been added previously. However, we
// special case the scroll event because the reality is that any
// element can scroll.
// TODO: ideally, we'd eventually apply the same logic to all
// events from the nonDelegatedEvents list. Then we can remove
// this special case and use the same logic for all events.
if ("scroll" !== domEventName) return;
eventSystemFlags |= 2, target = targetElement;
}
var listenerSet = getEventListenerSet(target), listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
listenerSet.has(listenerSetKey) || (isCapturePhaseListener && (eventSystemFlags |= 4), addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener), listenerSet.add(listenerSetKey));
}
function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {
var passive, passive1, unsubscribeListener, listener = function(targetContainer, domEventName, eventSystemFlags) {
var priority, listenerWrapper;
switch(void 0 === (priority = eventPriorities.get(domEventName)) ? 2 : priority){
case 0:
listenerWrapper = dispatchDiscreteEvent;
break;
case 1:
listenerWrapper = dispatchUserBlockingUpdate;
break;
default:
listenerWrapper = dispatchEvent;
}
return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);
}(targetContainer, domEventName, eventSystemFlags), isPassiveListener = void 0; // If passive option is not supported, then the event will be
passiveBrowserEventsSupported && ("touchstart" === domEventName || "touchmove" === domEventName || "wheel" === domEventName) && (isPassiveListener = !0), isCapturePhaseListener ? void 0 !== isPassiveListener ? (passive = isPassiveListener, targetContainer.addEventListener(domEventName, listener, {
capture: !0,
passive: passive
})) : targetContainer.addEventListener(domEventName, listener, !0) : void 0 !== isPassiveListener ? (passive1 = isPassiveListener, targetContainer.addEventListener(domEventName, listener, {
passive: passive1
})) : targetContainer.addEventListener(domEventName, listener, !1);
}
function isMatchingRootContainer(grandContainer, targetContainer) {
return grandContainer === targetContainer || 8 === grandContainer.nodeType && grandContainer.parentNode === targetContainer;
}
function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {
var ancestorInst = targetInst;
if ((1 & eventSystemFlags) == 0 && (2 & eventSystemFlags) == 0 && null !== targetInst) {
// The below logic attempts to work out if we need to change
// the target fiber to a different ancestor. We had similar logic
// in the legacy event system, except the big difference between
// systems is that the modern event system now has an event listener
// attached to each React Root and React Portal Root. Together,
// the DOM nodes representing these roots are the "rootContainer".
// To figure out which ancestor instance we should use, we traverse
// up the fiber tree from the target instance and attempt to find
// root boundaries that match that of our current "rootContainer".
// If we find that "rootContainer", we find the parent fiber
// sub-tree for that root and make that our ancestor instance.
var node = targetInst;
mainLoop: for(;;){
if (null === node) return;
var nodeTag = node.tag;
if (3 === nodeTag || 4 === nodeTag) {
var container = node.stateNode.containerInfo;
if (isMatchingRootContainer(container, targetContainer)) break;
if (4 === nodeTag) for(// The target is a portal, but it's not the rootContainer we're looking for.
// Normally portals handle their own events all the way down to the root.
// So we should be able to stop now. However, we don't know if this portal
// was part of *our* root.
var grandNode = node.return; null !== grandNode;){
var grandTag = grandNode.tag;
if ((3 === grandTag || 4 === grandTag) && isMatchingRootContainer(grandNode.stateNode.containerInfo, targetContainer)) // This is the rootContainer we're looking for and we found it as
// a parent of the Portal. That means we can ignore it because the
// Portal will bubble through to us.
return;
grandNode = grandNode.return;
}
// Now we need to find it's corresponding host fiber in the other
// tree. To do this we can use getClosestInstanceFromNode, but we
// need to validate that the fiber is a host instance, otherwise
// we need to traverse up through the DOM till we find the correct
// node that is from the other tree.
for(; null !== container;){
var parentNode = getClosestInstanceFromNode(container);
if (null === parentNode) return;
var parentTag = parentNode.tag;
if (5 === parentTag || 6 === parentTag) {
node = ancestorInst = parentNode;
continue mainLoop;
}
container = container.parentNode;
}
}
node = node.return;
}
}
!function(fn, a, b) {
if (isBatchingEventUpdates) // If we are currently inside another batch, we need to wait until it
// fully completes before restoring state.
return fn(void 0, void 0);
isBatchingEventUpdates = !0;
try {
return batchedEventUpdatesImpl(fn, void 0, void 0);
} finally{
isBatchingEventUpdates = !1, finishEventHandler();
}
}(function() {
var targetInst, nativeEventTarget, dispatchQueue;
return targetInst = ancestorInst, nativeEventTarget = getEventTarget(nativeEvent), void (function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
// event's native "bubble" phase, which means that we're
// not in the capture phase. That's because we emulate
// the capture phase here still. This is a trade-off,
// because in an ideal world we would not emulate and use
// the phases properly, like we do with the SimpleEvent
// plugin. However, the plugins below either expect
// emulation (EnterLeave) or use state localized to that
// plugin (BeforeInput, Change, Select). The state in
// these modules complicates things, as you'll essentially
// get the case where the capture phase event might change
// state, only for the following bubble event to come in
// later and not trigger anything as the state now
// invalidates the heuristics of the event plugin. We
// could alter all these plugins to work in such ways, but
// that might cause other unknown side-effects that we
// can't forsee right now.
if (// TODO: we should remove the concept of a "SimpleEventPlugin".
// This is the basic functionality of the event system. All
// the other plugins are essentially polyfills. So the plugin
// should probably be inlined somewhere and have its logic
// be core the to event system. This would potentially allow
// us to ship builds of React without the polyfilled plugins below.
function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
var reactName = topLevelEventsToReactNames.get(domEventName);
if (void 0 !== reactName) {
var SyntheticEventCtor = SyntheticEvent, reactEventType = domEventName;
switch(domEventName){
case "keypress":
// Firefox creates a keypress event for function keys too. This removes
// the unwanted keypress events. Enter is however both printable and
// non-printable. One would expect Tab to be as well (but it isn't).
if (0 === getEventCharCode(nativeEvent)) return;
/* falls through */ case "keydown":
case "keyup":
SyntheticEventCtor = SyntheticKeyboardEvent;
break;
case "focusin":
reactEventType = "focus", SyntheticEventCtor = SyntheticFocusEvent;
break;
case "focusout":
reactEventType = "blur", SyntheticEventCtor = SyntheticFocusEvent;
break;
case "beforeblur":
case "afterblur":
SyntheticEventCtor = SyntheticFocusEvent;
break;
case "click":
// Firefox creates a click event on right mouse clicks. This removes the
// unwanted click events.
if (2 === nativeEvent.button) return;
/* falls through */ case "auxclick":
case "dblclick":
case "mousedown":
case "mousemove":
case "mouseup":
/* falls through */ case "mouseout":
case "mouseover":
case "contextmenu":
SyntheticEventCtor = SyntheticMouseEvent;
break;
case "drag":
case "dragend":
case "dragenter":
case "dragexit":
case "dragleave":
case "dragover":
case "dragstart":
case "drop":
SyntheticEventCtor = SyntheticDragEvent;
break;
case "touchcancel":
case "touchend":
case "touchmove":
case "touchstart":
SyntheticEventCtor = SyntheticTouchEvent;
break;
case ANIMATION_END:
case ANIMATION_ITERATION:
case ANIMATION_START:
SyntheticEventCtor = SyntheticAnimationEvent;
break;
case TRANSITION_END:
SyntheticEventCtor = SyntheticTransitionEvent;
break;
case "scroll":
SyntheticEventCtor = SyntheticUIEvent;
break;
case "wheel":
SyntheticEventCtor = SyntheticWheelEvent;
break;
case "copy":
case "cut":
case "paste":
SyntheticEventCtor = SyntheticClipboardEvent;
break;
case "gotpointercapture":
case "lostpointercapture":
case "pointercancel":
case "pointerdown":
case "pointermove":
case "pointerout":
case "pointerover":
case "pointerup":
SyntheticEventCtor = SyntheticPointerEvent;
}
var inCapturePhase = (4 & eventSystemFlags) != 0, _listeners = function(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly) {
for(var reactEventName = inCapturePhase ? null !== reactName ? reactName + "Capture" : null : reactName, listeners = [], instance = targetFiber, lastHostComponent = null; null !== instance;){
var _instance2 = instance, stateNode = _instance2.stateNode; // Handle listeners that are on HostComponents (i.e. <div>)
if (5 === _instance2.tag && null !== stateNode && (lastHostComponent = stateNode, null !== reactEventName)) {
var listener = getListener(instance, reactEventName);
null != listener && listeners.push(createDispatchListener(instance, listener, lastHostComponent));
} // If we are only accumulating events for the target, then we don't
// continue to propagate through the React fiber tree to find other
// listeners.
if (accumulateTargetOnly) break;
instance = instance.return;
}
return listeners;
} // We should only use this function for:
(targetInst, reactName, nativeEvent.type, inCapturePhase, !inCapturePhase && // TODO: ideally, we'd eventually add all events from
// nonDelegatedEvents list in DOMPluginEventSystem.
// Then we can remove this special list.
// This is a breaking change that can wait until React 18.
"scroll" === domEventName);
if (_listeners.length > 0) {
// Intentionally create event lazily.
var _event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);
dispatchQueue.push({
event: _event,
listeners: _listeners
});
}
}
}(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags), (7 & eventSystemFlags) == 0) /**
* For almost every interaction we care about, there will be both a top-level
* `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
* we do not extract duplicate events. However, moving the mouse into the
* browser from outside will not fire a `mouseout` event. In this case, we use
* the `mouseover` top-level event.
*/ (function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
var win, from, to, isOverEvent = "mouseover" === domEventName || "pointerover" === domEventName, isOutEvent = "mouseout" === domEventName || "pointerout" === domEventName;
if (isOverEvent && (16 & eventSystemFlags) == 0) {
// If this is an over event with a target, we might have already dispatched
// the event in the out event of the other target. If this is replayed,
// then it's because we couldn't dispatch against this target previously
// so we have to do it now instead.
var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
if (related && (getClosestInstanceFromNode(related) || related[internalContainerInstanceKey])) return;
}
if (isOutEvent || isOverEvent) {
if (nativeEventTarget.window === nativeEventTarget) // `nativeEventTarget` is probably a window object.
win = nativeEventTarget;
else {
// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
var doc = nativeEventTarget.ownerDocument;
win = doc ? doc.defaultView || doc.parentWindow : window;
}
if (isOutEvent) {
var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
if (from = targetInst, null !== (to = _related ? getClosestInstanceFromNode(_related) : null)) {
var nearestMounted = getNearestMountedFiber(to);
(to !== nearestMounted || 5 !== to.tag && 6 !== to.tag) && (to = null);
}
} else // Moving to a node from outside the window.
from = null, to = targetInst;
if (from !== to) {
var dispatchQueue1, leaveEvent, enterEvent, from1, to1, common, SyntheticEventCtor = SyntheticMouseEvent, leaveEventType = "onMouseLeave", enterEventType = "onMouseEnter", eventTypePrefix = "mouse";
("pointerout" === domEventName || "pointerover" === domEventName) && (SyntheticEventCtor = SyntheticPointerEvent, leaveEventType = "onPointerLeave", enterEventType = "onPointerEnter", eventTypePrefix = "pointer");
var fromNode = null == from ? win : getNodeFromInstance(from), toNode = null == to ? win : getNodeFromInstance(to), leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + "leave", from, nativeEvent, nativeEventTarget);
leave.target = fromNode, leave.relatedTarget = toNode;
var enter = null; // We should only process this nativeEvent if we are processing
if (getClosestInstanceFromNode(nativeEventTarget) === targetInst) {
var enterEvent1 = new SyntheticEventCtor(enterEventType, eventTypePrefix + "enter", to, nativeEvent, nativeEventTarget);
enterEvent1.target = toNode, enterEvent1.relatedTarget = fromNode, enter = enterEvent1;
}
dispatchQueue1 = dispatchQueue, leaveEvent = leave, enterEvent = enter, from1 = from, to1 = to, common = from1 && to1 ? /**
* Return the lowest common ancestor of A and B, or null if they are in
* different trees.
*/ function(instA, instB) {
for(var nodeA = instA, nodeB = instB, depthA = 0, tempA = nodeA; tempA; tempA = getParent(tempA))depthA++;
for(var depthB = 0, tempB = nodeB; tempB; tempB = getParent(tempB))depthB++;
// If A is deeper, crawl up.
for(; depthA - depthB > 0;)nodeA = getParent(nodeA), depthA--;
// If B is deeper, crawl up.
for(; depthB - depthA > 0;)nodeB = getParent(nodeB), depthB--;
// Walk in lockstep until we find a match.
for(var depth = depthA; depth--;){
if (nodeA === nodeB || null !== nodeB && nodeA === nodeB.alternate) return nodeA;
nodeA = getParent(nodeA), nodeB = getParent(nodeB);
}
return null;
}(from1, to1) : null, null !== from1 && accumulateEnterLeaveListenersForEvent(dispatchQueue1, leaveEvent, from1, common, !1), null !== to1 && null !== enterEvent && accumulateEnterLeaveListenersForEvent(dispatchQueue1, enterEvent, to1, common, !0);
}
}
})(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags), /**
* This plugin creates an `onChange` event that normalizes change events
* across form elements. This event fires at a time when it's possible to
* change the element's value without seeing a flicker.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - select
*/ function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
var node, state, nodeName, nodeName1, getTargetInstFunc, handleEventFunc, targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
if ("select" === (nodeName = targetNode.nodeName && targetNode.nodeName.toLowerCase()) || "input" === nodeName && "file" === targetNode.type ? getTargetInstFunc = getTargetInstForChangeEvent : isTextInputElement(targetNode) ? isInputEventSupported ? getTargetInstFunc = getTargetInstForInputOrChangeEvent : (getTargetInstFunc = getTargetInstForInputEventPolyfill, handleEventFunc = handleEventsForInputEventPolyfill) : (nodeName1 = targetNode.nodeName) && "input" === nodeName1.toLowerCase() && ("checkbox" === targetNode.type || "radio" === targetNode.type) && (getTargetInstFunc = getTargetInstForClickEvent), getTargetInstFunc) {
var inst = getTargetInstFunc(domEventName, targetInst);
if (inst) {
createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);
return;
}
}
handleEventFunc && handleEventFunc(domEventName, targetNode, targetInst), "focusout" !== domEventName || !(state = (node = targetNode)._wrapperState) || !state.controlled || "number" !== node.type || // If controlled, assign the value attribute to the current value on blur
setDefaultValue(node, "number", node.value);
}(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget), /**
* This plugin creates an `onSelect` event that normalizes select events
* across form elements.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - contentEditable
*
* This differs from native browser implementations in the following ways:
* - Fires on contentEditable fields as well as inputs.
* - Fires for collapsed selection.
* - Fires after user input.
*/ function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {
var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
switch(domEventName){
// Track the input node that has focus.
case "focusin":
(isTextInputElement(targetNode) || "true" === targetNode.contentEditable) && (activeElement$1 = targetNode, activeElementInst$1 = targetInst, lastSelection = null);
break;
case "focusout":
activeElement$1 = null, activeElementInst$1 = null, lastSelection = null;
break;
// Don't fire the event while the user is dragging. This matches the
// semantics of the native select event.
case "mousedown":
mouseDown = !0;
break;
case "contextmenu":
case "mouseup":
case "dragend":
mouseDown = !1, constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
break;
// Chrome and IE fire non-standard event when selection is changed (and
// sometimes when it hasn't). IE's event fires out of order with respect
// to key and input events on deletion, so we discard it.
//
// Firefox doesn't support selectionchange, so check selection status
// after each key entry. The selection changes after keydown and before
// keyup, but we check on keydown as well in the case of holding down a
// key, when multiple keydown events are fired but only one keyup is.
// This is also our approach for IE handling, for the reason above.
case "selectionchange":
if (skipSelectionChangeEvent) break;
// falls through
case "keydown":
case "keyup":
constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
}
}(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget), /**
* @return {?object} A SyntheticCompositionEvent.
*/ function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
if (canUseCompositionEvent) eventType = /**
* Translate native top level events into event types.
*/ function(domEventName) {
switch(domEventName){
case "compositionstart":
return "onCompositionStart";
case "compositionend":
return "onCompositionEnd";
case "compositionupdate":
return "onCompositionUpdate";
}
}(domEventName);
else if (isComposing) isFallbackCompositionEnd(domEventName, nativeEvent) && (eventType = "onCompositionEnd");
else "keydown" === domEventName && 229 === nativeEvent.keyCode && (eventType = "onCompositionStart");
if (eventType) {
useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) && (isComposing || "onCompositionStart" !== eventType ? "onCompositionEnd" === eventType && isComposing && (fallbackData = getData()) : (root = nativeEventTarget, startText = getText(), isComposing = !0));
var eventType, fallbackData, listeners = accumulateTwoPhaseListeners(targetInst, eventType);
if (listeners.length > 0) {
var event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);
if (dispatchQueue.push({
event: event,
listeners: listeners
}), fallbackData) // Inject data generated from fallback path into the synthetic event.
// This matches the property of native CompositionEventInterface.
event.data = fallbackData;
else {
var customData = getDataFromCustomEvent(nativeEvent);
null !== customData && (event.data = customData);
}
}
}
}(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget), /**
* Extract a SyntheticInputEvent for `beforeInput`, based on either native
* `textInput` or fallback behavior.
*
* @return {?object} A SyntheticInputEvent.
*/ function(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {
// be fired.
if (chars = canUseTextInputEvent ? function(domEventName, nativeEvent) {
switch(domEventName){
case "compositionend":
return getDataFromCustomEvent(nativeEvent);
case "keypress":
if (32 !== nativeEvent.which) return null;
return hasSpaceKeypress = !0, " ";
case "textInput":
// Record the characters to be added to the DOM.
var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
// it at the keypress level and bail immediately. Android Chrome
// doesn't give us keycodes, so we need to ignore it.
if (" " === chars && hasSpaceKeypress) return null;
return chars;
default:
// For other native event types, do nothing.
return null;
}
}(domEventName, nativeEvent) : /**
* For browsers that do not provide the `textInput` event, extract the
* appropriate string to use for SyntheticInputEvent.
*/ function(domEventName, nativeEvent) {
// If we are currently composing (IME) and using a fallback to do so,
// try to extract the composed characters from the fallback object.
// If composition event is available, we extract a string only at
// compositionevent, otherwise extract it at fallback events.
if (isComposing) {
if ("compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {
var chars = getData();
return root = null, startText = null, fallbackText = null, isComposing = !1, chars;
}
return null;
}
switch(domEventName){
case "paste":
default:
// If a paste event occurs after a keypress, throw out the input
// chars. Paste events should not lead to BeforeInput events.
return null;
case "keypress":
/**
* As of v27, Firefox may fire keypress events even when no character
* will be inserted. A few possibilities:
*
* - `which` is `0`. Arrow keys, Esc key, etc.
*
* - `which` is the pressed key code, but no char is available.
* Ex: 'AltGr + d` in Polish. There is no modified character for
* this key combination and no character is inserted into the
* document, but FF fires the keypress for char code `100` anyway.
* No `input` event will occur.
*
* - `which` is the pressed key code, but a command combination is
* being used. Ex: `Cmd+C`. No character is inserted, and no
* `input` event will occur.
*/ if (!((nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
!(nativeEvent.ctrlKey && nativeEvent.altKey))) {
// IE fires the `keypress` event when a user types an emoji via
// Touch keyboard of Windows. In such a case, the `char` property
// holds an emoji character like `\uD83D\uDE0A`. Because its length
// is 2, the property `which` does not represent an emoji correctly.
// In such a case, we directly return the `char` property instead of
// using `which`.
if (nativeEvent.char && nativeEvent.char.length > 1) return nativeEvent.char;
if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
}
return null;
case "compositionend":
return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
}
}(domEventName, nativeEvent)) {
var chars, listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
if (listeners.length > 0) {
var event = new SyntheticCompositionEvent("onBeforeInput", "beforeinput", null, nativeEvent, nativeEventTarget);
dispatchQueue.push({
event: event,
listeners: listeners
}), event.data = chars;
}
}
}(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);
} // List of events that need to be individually attached to media elements.
(dispatchQueue = [], domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags), processDispatchQueue(dispatchQueue, eventSystemFlags));
});
}
function createDispatchListener(instance, listener, currentTarget) {
return {
instance: instance,
listener: listener,
currentTarget: currentTarget
};
}
// - BeforeInputEventPlugin
// - ChangeEventPlugin
// - SelectEventPlugin
// This is because we only process these plugins
// in the bubble phase, so we need to accumulate two
// phase event listeners (via emulation).
function accumulateTwoPhaseListeners(targetFiber, reactName) {
for(var captureName = reactName + "Capture", listeners = [], instance = targetFiber; null !== instance;){
var _instance3 = instance, stateNode = _instance3.stateNode; // Handle listeners that are on HostComponents (i.e. <div>)
if (5 === _instance3.tag && null !== stateNode) {
var captureListener = getListener(instance, captureName);
null != captureListener && listeners.unshift(createDispatchListener(instance, captureListener, stateNode));
var bubbleListener = getListener(instance, reactName);
null != bubbleListener && listeners.push(createDispatchListener(instance, bubbleListener, stateNode));
}
instance = instance.return;
}
return listeners;
}
function getParent(inst) {
if (null === inst) return null;
do inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
while (inst && 5 !== inst.tag)
return inst || null;
}
function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
for(var registrationName = event._reactName, listeners = [], instance = target; null !== instance && instance !== common;){
var _instance4 = instance, alternate = _instance4.alternate, stateNode = _instance4.stateNode, tag = _instance4.tag;
if (null !== alternate && alternate === common) break;
if (5 === tag && null !== stateNode) {
if (inCapturePhase) {
var captureListener = getListener(instance, registrationName);
null != captureListener && listeners.unshift(createDispatchListener(instance, captureListener, stateNode));
} else if (!inCapturePhase) {
var bubbleListener = getListener(instance, registrationName);
null != bubbleListener && listeners.push(createDispatchListener(instance, bubbleListener, stateNode));
}
}
instance = instance.return;
}
0 !== listeners.length && dispatchQueue.push({
event: event,
listeners: listeners
});
} // We should only use this function for:
function getListenerSetKey(domEventName, capture) {
return domEventName + "__" + (capture ? "capture" : "bubble");
}
var didWarnInvalidHydration = !1, DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML", SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning", SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning", AUTOFOCUS = "autoFocus", CHILDREN = "children", STYLE = "style", HTML$1 = "__html";
warnedUnknownTags = {
// There are working polyfills for <dialog>. Let people use it.
dialog: !0,
// Electron ships a custom <webview> tag to display external web content in
// an isolated frame and process.
// This tag is not present in non Electron environments such as JSDom which
// is often used for testing purposes.
// @see https://electronjs.org/docs/api/webview-tag
webview: !0
}, validatePropertiesInDevelopment = function(type, props) {
var type1, props1, type2, props2, type3, props3, eventRegistry;
isCustomComponent(type1 = type, props1 = props) || function(type, props) {
var invalidProps = [];
for(var key in props)!function(tagName, name) {
if (hasOwnProperty$1.call(warnedProperties, name) && warnedProperties[name]) return !0;
if (rARIACamel.test(name)) {
var ariaName = "aria-" + name.slice(4).toLowerCase(), correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null;
// DOM properties, then it is an invalid aria-* attribute.
if (null == correctName) return error("Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.", name), warnedProperties[name] = !0, !0;
// aria-* attributes should be lowercase; suggest the lowercase version.
if (name !== correctName) return error("Invalid ARIA attribute `%s`. Did you mean `%s`?", name, correctName), warnedProperties[name] = !0, !0;
}
if (rARIA.test(name)) {
var lowerCasedName = name.toLowerCase(), standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null;
// DOM properties, then it is an invalid aria-* attribute.
if (null == standardName) return warnedProperties[name] = !0, !1;
// aria-* attributes should be lowercase; suggest the lowercase version.
name !== standardName && (error("Unknown ARIA attribute `%s`. Did you mean `%s`?", name, standardName), warnedProperties[name] = !0);
}
return !0;
}(0, key) && invalidProps.push(key);
var unknownPropString = invalidProps.map(function(prop) {
return "`" + prop + "`";
}).join(", ");
1 === invalidProps.length ? error("Invalid aria prop %s on <%s> tag. For details, see https://reactjs.org/link/invalid-aria-props", unknownPropString, type) : invalidProps.length > 1 && error("Invalid aria props %s on <%s> tag. For details, see https://reactjs.org/link/invalid-aria-props", unknownPropString, type);
}(type1, props1), type2 = type, props2 = props, ("input" === type2 || "textarea" === type2 || "select" === type2) && (null == props2 || null !== props2.value || didWarnValueNull || (didWarnValueNull = !0, "select" === type2 && props2.multiple ? error("`value` prop on `%s` should not be null. Consider using an empty array when `multiple` is set to `true` to clear the component or `undefined` for uncontrolled components.", type2) : error("`value` prop on `%s` should not be null. Consider using an empty string to clear the component or `undefined` for uncontrolled components.", type2))), type3 = type, props3 = props, eventRegistry = {
registrationNameDependencies: registrationNameDependencies,
possibleRegistrationNames: possibleRegistrationNames
}, isCustomComponent(type3, props3) || warnUnknownProperties(type3, props3, eventRegistry);
}, // browsers. It adds spaces and sorts the properties in some
// non-alphabetical order. Handling that would require sorting CSS
// properties in the client & server versions or applying
// `expectedStyle` to a temporary DOM node to read its `style` attribute
// normalized. Since it only affects IE, we're skipping style warnings
// in that browser completely in favor of doing all that work.
// See https://github.com/facebook/react/issues/11807
canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode;
// It also can turn \u0000 into \uFFFD inside attributes.
// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
// If we have a mismatch, it might be caused by that.
// We will still patch up in this case but not fire the warning.
var NORMALIZE_NEWLINES_REGEX = /\r\n?/g, NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
function getOwnerDocumentFromRootContainer(rootContainerElement) {
return 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
}
function noop() {}
function trapClickOnNonInteractiveElement(node) {
// Mobile Safari does not fire properly bubble click events on
// non-interactive elements, which means delegated click listeners do not
// fire. The workaround for this bug involves attaching an empty click
// listener on the target node.
// https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
// Just set it using the onclick property so that we don't have to manage any
// bookkeeping for it. Not sure if we need to clear it when the listener is
// removed.
// TODO: Only do this for the relevant Safaris maybe?
node.onclick = noop;
}
function warnForUnmatchedText(textNode, text) {
warnForTextDifference(textNode.nodeValue, text);
}
function warnForDeletedHydratableElement(parentNode, child) {
!didWarnInvalidHydration && (didWarnInvalidHydration = !0, error("Did not expect server HTML to contain a <%s> in <%s>.", child.nodeName.toLowerCase(), parentNode.nodeName.toLowerCase()));
}
function warnForDeletedHydratableText(parentNode, child) {
!didWarnInvalidHydration && (didWarnInvalidHydration = !0, error('Did not expect server HTML to contain the text node "%s" in <%s>.', child.nodeValue, parentNode.nodeName.toLowerCase()));
}
function warnForInsertedHydratedElement(parentNode, tag, props) {
!didWarnInvalidHydration && (didWarnInvalidHydration = !0, error("Expected server HTML to contain a matching <%s> in <%s>.", tag, parentNode.nodeName.toLowerCase()));
}
function warnForInsertedHydratedText(parentNode, text) {
"" !== text && !didWarnInvalidHydration && (didWarnInvalidHydration = !0, error('Expected server HTML to contain a matching text node for "%s" in <%s>.', text, parentNode.nodeName.toLowerCase()));
}
normalizeMarkupForTextOrAttribute = function(markup) {
return ("string" == typeof markup ? markup : "" + markup).replace(NORMALIZE_NEWLINES_REGEX, "\n").replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
}, warnForTextDifference = function(serverText, clientText) {
if (!didWarnInvalidHydration) {
var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText), normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
normalizedServerText !== normalizedClientText && (didWarnInvalidHydration = !0, error('Text content did not match. Server: "%s" Client: "%s"', normalizedServerText, normalizedClientText));
}
}, warnForPropDifference = function(propName, serverValue, clientValue) {
if (!didWarnInvalidHydration) {
var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue), normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);
normalizedServerValue !== normalizedClientValue && (didWarnInvalidHydration = !0, error("Prop `%s` did not match. Server: %s Client: %s", propName, JSON.stringify(normalizedServerValue), JSON.stringify(normalizedClientValue)));
}
}, warnForExtraAttributes = function(attributeNames) {
if (!didWarnInvalidHydration) {
didWarnInvalidHydration = !0;
var names = [];
attributeNames.forEach(function(name) {
names.push(name);
}), error("Extra attributes from the server: %s", names);
}
}, warnForInvalidEventListener = function(registrationName, listener) {
!1 === listener ? error("Expected `%s` listener to be a function, instead got `false`.\n\nIf you used to conditionally omit it with %s={condition && value}, pass %s={condition ? value : undefined} instead.", registrationName, registrationName, registrationName) : error("Expected `%s` listener to be a function, instead got a value of `%s` type.", registrationName, typeof listener);
}, // can be used for comparison.
normalizeHTML = function(parent, html) {
// We could have created a separate document here to avoid
// re-initializing custom elements if they exist. But this breaks
// how <noscript> is being handled. So we use the same document.
// See the discussion in https://github.com/facebook/react/pull/11157.
var testElement = parent.namespaceURI === HTML_NAMESPACE ? parent.ownerDocument.createElement(parent.tagName) : parent.ownerDocument.createElementNS(parent.namespaceURI, parent.tagName);
return testElement.innerHTML = html, testElement.innerHTML;
};
var validateDOMNesting = function() {}, updatedAncestorInfo = function() {}, specialTags = [
"address",
"applet",
"area",
"article",
"aside",
"base",
"basefont",
"bgsound",
"blockquote",
"body",
"br",
"button",
"caption",
"center",
"col",
"colgroup",
"dd",
"details",
"dir",
"div",
"dl",
"dt",
"embed",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"frame",
"frameset",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"head",
"header",
"hgroup",
"hr",
"html",
"iframe",
"img",
"input",
"isindex",
"li",
"link",
"listing",
"main",
"marquee",
"menu",
"menuitem",
"meta",
"nav",
"noembed",
"noframes",
"noscript",
"object",
"ol",
"p",
"param",
"plaintext",
"pre",
"script",
"section",
"select",
"source",
"style",
"summary",
"table",
"tbody",
"td",
"template",
"textarea",
"tfoot",
"th",
"thead",
"title",
"tr",
"track",
"ul",
"wbr",
"xmp"
], inScopeTags = [
"applet",
"caption",
"html",
"table",
"td",
"th",
"marquee",
"object",
"template",
// TODO: Distinguish by namespace here -- for <title>, including it here
// errs on the side of fewer warnings
"foreignObject",
"desc",
"title"
], buttonScopeTags = inScopeTags.concat([
"button"
]), impliedEndTags = [
"dd",
"dt",
"li",
"option",
"optgroup",
"p",
"rp",
"rt"
], emptyAncestorInfo = {
current: null,
formTag: null,
aTagInScope: null,
buttonTagInScope: null,
nobrTagInScope: null,
pTagInButtonScope: null,
listItemTagAutoclosing: null,
dlItemTagAutoclosing: null
};
updatedAncestorInfo = function(oldInfo, tag) {
var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo), info = {
tag: tag
};
return -1 !== inScopeTags.indexOf(tag) && (ancestorInfo.aTagInScope = null, ancestorInfo.buttonTagInScope = null, ancestorInfo.nobrTagInScope = null), -1 !== buttonScopeTags.indexOf(tag) && (ancestorInfo.pTagInButtonScope = null), -1 !== specialTags.indexOf(tag) && "address" !== tag && "div" !== tag && "p" !== tag && (ancestorInfo.listItemTagAutoclosing = null, ancestorInfo.dlItemTagAutoclosing = null), ancestorInfo.current = info, "form" === tag && (ancestorInfo.formTag = info), "a" === tag && (ancestorInfo.aTagInScope = info), "button" === tag && (ancestorInfo.buttonTagInScope = info), "nobr" === tag && (ancestorInfo.nobrTagInScope = info), "p" === tag && (ancestorInfo.pTagInButtonScope = info), "li" === tag && (ancestorInfo.listItemTagAutoclosing = info), ("dd" === tag || "dt" === tag) && (ancestorInfo.dlItemTagAutoclosing = info), ancestorInfo;
};
/**
* Returns whether
*/ var isTagValidWithParent = function(tag, parentTag) {
// First, let's check if we're in an unusual parsing mode...
switch(parentTag){
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
case "select":
return "option" === tag || "optgroup" === tag || "#text" === tag;
case "optgroup":
return "option" === tag || "#text" === tag;
// Strictly speaking, seeing an <option> doesn't mean we're in a <select>
// but
case "option":
return "#text" === tag;
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
// No special behavior since these rules fall back to "in body" mode for
// all except special table nodes which cause bad parsing behavior anyway.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
case "tr":
return "th" === tag || "td" === tag || "style" === tag || "script" === tag || "template" === tag;
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
case "tbody":
case "thead":
case "tfoot":
return "tr" === tag || "style" === tag || "script" === tag || "template" === tag;
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
case "colgroup":
return "col" === tag || "template" === tag;
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
case "table":
return "caption" === tag || "colgroup" === tag || "tbody" === tag || "tfoot" === tag || "thead" === tag || "style" === tag || "script" === tag || "template" === tag;
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
case "head":
return "base" === tag || "basefont" === tag || "bgsound" === tag || "link" === tag || "meta" === tag || "title" === tag || "noscript" === tag || "noframes" === tag || "style" === tag || "script" === tag || "template" === tag;
// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
case "html":
return "head" === tag || "body" === tag || "frameset" === tag;
case "frameset":
return "frame" === tag;
case "#document":
return "html" === tag;
} // Probably in the "in body" parsing mode, so we outlaw only tag combos
// where the parsing rules cause implicit opens or closes to be added.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
switch(tag){
case "h1":
case "h2":
case "h3":
case "h4":
case "h5":
case "h6":
return "h1" !== parentTag && "h2" !== parentTag && "h3" !== parentTag && "h4" !== parentTag && "h5" !== parentTag && "h6" !== parentTag;
case "rp":
case "rt":
return -1 === impliedEndTags.indexOf(parentTag);
case "body":
case "caption":
case "col":
case "colgroup":
case "frameset":
case "frame":
case "head":
case "html":
case "tbody":
case "td":
case "tfoot":
case "th":
case "thead":
case "tr":
// These tags are only valid with a few parents that have special child
// parsing rules -- if we're down here, then none of those matched and
// so we allow it only if we don't know what the parent is, as all other
// cases are invalid.
return null == parentTag;
}
return !0;
}, findInvalidAncestorForTag = function(tag, ancestorInfo) {
switch(tag){
case "address":
case "article":
case "aside":
case "blockquote":
case "center":
case "details":
case "dialog":
case "dir":
case "div":
case "dl":
case "fieldset":
case "figcaption":
case "figure":
case "footer":
case "header":
case "hgroup":
case "main":
case "menu":
case "nav":
case "ol":
case "p":
case "section":
case "summary":
case "ul":
case "pre":
case "listing":
case "table":
case "hr":
case "xmp":
case "h1":
case "h2":
case "h3":
case "h4":
case "h5":
case "h6":
return ancestorInfo.pTagInButtonScope;
case "form":
return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
case "li":
return ancestorInfo.listItemTagAutoclosing;
case "dd":
case "dt":
return ancestorInfo.dlItemTagAutoclosing;
case "button":
return ancestorInfo.buttonTagInScope;
case "a":
// Spec says something about storing a list of markers, but it sounds
// equivalent to this check.
return ancestorInfo.aTagInScope;
case "nobr":
return ancestorInfo.nobrTagInScope;
}
return null;
}, didWarn$1 = {};
validateDOMNesting = function(childTag, childText, ancestorInfo) {
var parentInfo = (ancestorInfo = ancestorInfo || emptyAncestorInfo).current, parentTag = parentInfo && parentInfo.tag;
null != childText && (null != childTag && error("validateDOMNesting: when childText is passed, childTag should be null"), childTag = "#text");
var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo, invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo), invalidParentOrAncestor = invalidParent || invalidAncestor;
if (invalidParentOrAncestor) {
var ancestorTag = invalidParentOrAncestor.tag, warnKey = !!invalidParent + "|" + childTag + "|" + ancestorTag;
if (!didWarn$1[warnKey]) {
didWarn$1[warnKey] = !0;
var tagDisplayName = childTag, whitespaceInfo = "";
if ("#text" === childTag ? /\S/.test(childText) ? tagDisplayName = "Text nodes" : (tagDisplayName = "Whitespace text nodes", whitespaceInfo = " Make sure you don't have any extra whitespace between tags on each line of your source code.") : tagDisplayName = "<" + childTag + ">", invalidParent) {
var info = "";
"table" === ancestorTag && "tr" === childTag && (info += " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by the browser."), error("validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s", tagDisplayName, ancestorTag, whitespaceInfo, info);
} else error("validateDOMNesting(...): %s cannot appear as a descendant of <%s>.", tagDisplayName, ancestorTag);
}
}
}, SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
var eventsEnabled = null, selectionInformation = null;
function shouldAutoFocusHostComponent(type, props) {
switch(type){
case "button":
case "input":
case "select":
case "textarea":
return !!props.autoFocus;
}
return !1;
}
function shouldSetTextContent(type, props) {
return "textarea" === type || "option" === type || "noscript" === type || "string" == typeof props.children || "number" == typeof props.children || "object" == typeof props.dangerouslySetInnerHTML && null !== props.dangerouslySetInnerHTML && null != props.dangerouslySetInnerHTML.__html;
}
// if a component just imports ReactDOM (e.g. for findDOMNode).
// Some environments might not have setTimeout or clearTimeout.
var scheduleTimeout = "function" == typeof setTimeout ? setTimeout : void 0, cancelTimeout = "function" == typeof clearTimeout ? clearTimeout : void 0;
function clearContainer(container) {
if (1 === container.nodeType) container.textContent = "";
else if (9 === container.nodeType) {
var body = container.body;
null != body && (body.textContent = "");
}
} // -------------------
function getNextHydratable(node) {
// Skip non-hydratable nodes.
for(; null != node; node = node.nextSibling){
var nodeType = node.nodeType;
if (1 === nodeType || 3 === nodeType) break;
}
return node;
}
function getNextHydratableSibling(instance) {
return getNextHydratable(instance.nextSibling);
}
function getFirstHydratableChild(parentInstance) {
return getNextHydratable(parentInstance.firstChild);
}
// SuspenseInstance. I.e. if its previous sibling is a Comment with
// SUSPENSE_x_START_DATA. Otherwise, null.
function getParentSuspenseInstance(targetInstance) {
for(var node = targetInstance.previousSibling, depth = 0; node;){
if (8 === node.nodeType) {
var data = node.data;
if ("$" === data || "$!" === data || "$?" === data) {
if (0 === depth) return node;
depth--;
} else "/$" === data && depth++;
}
node = node.previousSibling;
}
return null;
}
var clientId = 0;
function makeClientIdInDEV(warnOnAccessInDEV) {
var id = "r:" + (clientId++).toString(36);
return {
toString: function() {
return warnOnAccessInDEV(), id;
},
valueOf: function() {
return warnOnAccessInDEV(), id;
}
};
}
var randomKey = Math.random().toString(36).slice(2), internalInstanceKey = "__reactFiber$" + randomKey, internalPropsKey = "__reactProps$" + randomKey, internalContainerInstanceKey = "__reactContainer$" + randomKey, internalEventHandlersKey = "__reactEvents$" + randomKey;
// If the target node is part of a hydrated or not yet rendered subtree, then
// this may also return a SuspenseComponent or HostRoot to indicate that.
// Conceptually the HostRoot fiber is a child of the Container node. So if you
// pass the Container node as the targetNode, you will not actually get the
// HostRoot back. To get to the HostRoot, you need to pass a child of it.
// The same thing applies to Suspense boundaries.
function getClosestInstanceFromNode(targetNode) {
var targetInst = targetNode[internalInstanceKey];
if (targetInst) // Don't return HostRoot or SuspenseComponent here.
return targetInst;
// If the direct event target isn't a React owned DOM node, we need to look
for(// to see if one of its parents is a React owned DOM node.
var parentNode = targetNode.parentNode; parentNode;){
if (// We'll check if this is a container root that could include
// React nodes in the future. We need to check this first because
// if we're a child of a dehydrated container, we need to first
// find that inner container before moving on to finding the parent
// instance. Note that we don't check this field on the targetNode
// itself because the fibers are conceptually between the container
// node and the first child. It isn't surrounding the container node.
// If it's not a container, we check if it's an instance.
targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
// Since this wasn't the direct target of the event, we might have
// stepped past dehydrated DOM nodes to get here. However they could
// also have been non-React nodes. We need to answer which one.
// If we the instance doesn't have any children, then there can't be
// a nested suspense boundary within it. So we can use this as a fast
// bailout. Most of the time, when people add non-React children to
// the tree, it is using a ref to a child-less DOM node.
// Normally we'd only need to check one of the fibers because if it
// has ever gone from having children to deleting them or vice versa
// it would have deleted the dehydrated boundary nested inside already.
// However, since the HostRoot starts out with an alternate it might
// have one on the alternate so we need to check in case this was a
// root.
var alternate = targetInst.alternate;
if (null !== targetInst.child || null !== alternate && null !== alternate.child) for(// Next we need to figure out if the node that skipped past is
// nested within a dehydrated boundary and if so, which one.
var suspenseInstance = getParentSuspenseInstance(targetNode); null !== suspenseInstance;){
// We found a suspense instance. That means that we haven't
// hydrated it yet. Even though we leave the comments in the
// DOM after hydrating, and there are boundaries in the DOM
// that could already be hydrated, we wouldn't have found them
// through this pass since if the target is hydrated it would
// have had an internalInstanceKey on it.
// Let's get the fiber associated with the SuspenseComponent
// as the deepest instance.
var targetSuspenseInst = suspenseInstance[internalInstanceKey];
if (targetSuspenseInst) return targetSuspenseInst;
// If we don't find a Fiber on the comment, it might be because
// we haven't gotten to hydrate it yet. There might still be a
// parent boundary that hasn't above this one so we need to find
// the outer most that is known.
suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent
// host component also hasn't hydrated yet. We can return it
// below since it will bail out on the isMounted check later.
}
return targetInst;
}
parentNode = (targetNode = parentNode).parentNode;
}
return null;
}
/**
* Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
* instance, or null if the node was not rendered by this React.
*/ function getInstanceFromNode(node) {
var inst = node[internalInstanceKey] || node[internalContainerInstanceKey];
return inst && (5 === inst.tag || 6 === inst.tag || 13 === inst.tag || 3 === inst.tag) ? inst : null;
}
/**
* Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
* DOM node.
*/ function getNodeFromInstance(inst) {
if (5 === inst.tag || 6 === inst.tag) // In Fiber this, is just the state node right now. We assume it will be
// a host component or host text.
return inst.stateNode;
// Without this first invariant, passing a non-DOM-component triggers the next
throw Error("getNodeFromInstance: Invalid argument.");
}
function getFiberCurrentPropsFromNode(node) {
return node[internalPropsKey] || null;
}
function getEventListenerSet(node) {
var elementListenerSet = node[internalEventHandlersKey];
return void 0 === elementListenerSet && (elementListenerSet = node[internalEventHandlersKey] = new Set()), elementListenerSet;
}
var loggedTypeFailures = {}, ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element) {
if (element) {
var owner = element._owner, stack = function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (null == type) return "";
if ("function" == typeof type) return describeNativeComponentFrame(type, !!((prototype = type.prototype) && prototype.isReactComponent));
if ("string" == typeof type) return describeBuiltInComponentFrame(type);
switch(type){
case REACT_SUSPENSE_TYPE:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if ("object" == typeof type) switch(type.$$typeof){
case REACT_FORWARD_REF_TYPE:
return describeNativeComponentFrame(type.render, !1);
case REACT_MEMO_TYPE:
// Memo may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
case REACT_BLOCK_TYPE:
return describeNativeComponentFrame(type._render, !1);
case REACT_LAZY_TYPE:
var prototype, payload = type._payload, init = type._init;
try {
// Lazy may contain any component type so we recursively resolve it.
return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
} catch (x) {}
}
return "";
}(element.type, element._source, owner ? owner.type : null);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
function checkPropTypes(typeSpecs, values, location, componentName, element) {
// $FlowFixMe This is okay but Flow doesn't know it.
var has = Function.call.bind(Object.prototype.hasOwnProperty);
for(var typeSpecName in typeSpecs)if (has(typeSpecs, typeSpecName)) {
var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
if ("function" != typeof typeSpecs[typeSpecName]) {
var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
throw err.name = "Invariant Violation", err;
}
error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (ex) {
error$1 = ex;
}
!error$1 || error$1 instanceof Error || (setCurrentlyValidatingElement(element), error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1), setCurrentlyValidatingElement(null)), error$1 instanceof Error && !(error$1.message in loggedTypeFailures) && (// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error$1.message] = !0, setCurrentlyValidatingElement(element), error("Failed %s type: %s", location, error$1.message), setCurrentlyValidatingElement(null));
}
}
var valueStack = [];
fiberStack = [];
var index = -1;
function createCursor(defaultValue) {
return {
current: defaultValue
};
}
function pop(cursor, fiber) {
if (index < 0) {
error("Unexpected pop.");
return;
}
fiber !== fiberStack[index] && error("Unexpected Fiber popped."), cursor.current = valueStack[index], valueStack[index] = null, fiberStack[index] = null, index--;
}
function push(cursor, value, fiber) {
valueStack[++index] = cursor.current, fiberStack[index] = fiber, cursor.current = value;
}
warnedAboutMissingGetChildContext = {};
var emptyContextObject = {};
Object.freeze(emptyContextObject);
var contextStackCursor = createCursor(emptyContextObject), didPerformWorkStackCursor = createCursor(!1), previousContext = emptyContextObject; // A cursor to a boolean indicating whether the context has changed.
function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
return didPushOwnContextIfProvider && isContextProvider(Component) ? previousContext : contextStackCursor.current;
}
function cacheContext(workInProgress, unmaskedContext, maskedContext) {
var instance = workInProgress.stateNode;
instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
}
function getMaskedContext(workInProgress, unmaskedContext) {
var type = workInProgress.type, contextTypes = type.contextTypes;
if (!contextTypes) return emptyContextObject;
// Avoid recreating masked context unless unmasked context has changed.
// Failing to do this will result in unnecessary calls to componentWillReceiveProps.
// This may trigger infinite loops if componentWillReceiveProps calls setState.
var instance = workInProgress.stateNode;
if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
var context = {};
for(var key in contextTypes)context[key] = unmaskedContext[key];
return checkPropTypes(contextTypes, context, "context", getComponentName(type) || "Unknown"), instance && cacheContext(workInProgress, unmaskedContext, context), context;
}
function hasContextChanged() {
return didPerformWorkStackCursor.current;
}
function isContextProvider(type) {
return null != type.childContextTypes;
}
function popContext(fiber) {
pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber);
}
function popTopLevelContextObject(fiber) {
pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber);
}
function pushTopLevelContextObject(fiber, context, didChange) {
if (contextStackCursor.current !== emptyContextObject) throw Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");
push(contextStackCursor, context, fiber), push(didPerformWorkStackCursor, didChange, fiber);
}
function processChildContext(fiber, type, parentContext) {
var instance = fiber.stateNode, childContextTypes = type.childContextTypes;
// It has only been added in Fiber to match the (unintentional) behavior in Stack.
if ("function" != typeof instance.getChildContext) {
var componentName = getComponentName(type) || "Unknown";
return warnedAboutMissingGetChildContext[componentName] || (warnedAboutMissingGetChildContext[componentName] = !0, error("%s.childContextTypes is specified but there is no getChildContext() method on the instance. You can either define getChildContext() on %s or remove childContextTypes from it.", componentName, componentName)), parentContext;
}
var childContext = instance.getChildContext();
for(var contextKey in childContext)if (!(contextKey in childContextTypes)) throw Error((getComponentName(type) || "Unknown") + '.getChildContext(): key "' + contextKey + '" is not defined in childContextTypes.');
return checkPropTypes(childContextTypes, childContext, "child context", getComponentName(type) || "Unknown"), _assign({}, parentContext, childContext);
}
function pushContextProvider(workInProgress) {
var instance = workInProgress.stateNode, memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // We push the context as early as possible to ensure stack integrity.
return(// Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
previousContext = contextStackCursor.current, push(contextStackCursor, memoizedMergedChildContext, workInProgress), push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress), !0);
}
function invalidateContextProvider(workInProgress, type, didChange) {
var instance = workInProgress.stateNode;
if (!instance) throw Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");
if (didChange) {
// Merge parent and own context.
// Skip this if we're not updating due to sCU.
// This avoids unnecessarily recomputing memoized values.
var mergedContext = processChildContext(workInProgress, type, previousContext);
instance.__reactInternalMemoizedMergedChildContext = mergedContext, // It is important to unwind the context in the reverse order.
pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, mergedContext, workInProgress), push(didPerformWorkStackCursor, didChange, workInProgress);
} else pop(didPerformWorkStackCursor, workInProgress), push(didPerformWorkStackCursor, didChange, workInProgress);
}
var rendererID = null, injectedHook = null, hasLoggedError = !1, isDevToolsPresent = "undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__;
// Provide explicit error message when production+profiling bundle of e.g.
// react-dom is used with production (non-profiling) bundle of
// scheduler/tracing
if (null == __interactionsRef || null == __interactionsRef.current) throw Error("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at https://reactjs.org/link/profiling");
var fakeCallbackNode = {}, requestPaint = void 0 !== unstable_requestPaint ? unstable_requestPaint : function() {}, syncQueue = null, immediateQueueCallbackNode = null, isFlushingSyncQueue = !1, initialTimeMs$1 = unstable_now(), now = initialTimeMs$1 < 10000 ? unstable_now : function() {
return unstable_now() - initialTimeMs$1;
}; // Except for NoPriority, these correspond to Scheduler priorities. We use
function getCurrentPriorityLevel() {
switch(unstable_getCurrentPriorityLevel()){
case unstable_ImmediatePriority:
return 99;
case unstable_UserBlockingPriority:
return 98;
case unstable_NormalPriority:
return 97;
case unstable_LowPriority:
return 96;
case unstable_IdlePriority:
return 95;
default:
throw Error("Unknown priority level.");
}
}
function reactPriorityToSchedulerPriority(reactPriorityLevel) {
switch(reactPriorityLevel){
case 99:
return unstable_ImmediatePriority;
case 98:
return unstable_UserBlockingPriority;
case 97:
return unstable_NormalPriority;
case 96:
return unstable_LowPriority;
case 95:
return unstable_IdlePriority;
default:
throw Error("Unknown priority level.");
}
}
function runWithPriority$1(reactPriorityLevel, fn) {
return unstable_runWithPriority(reactPriorityToSchedulerPriority(reactPriorityLevel), fn);
}
function scheduleCallback(reactPriorityLevel, callback, options) {
return unstable_scheduleCallback(reactPriorityToSchedulerPriority(reactPriorityLevel), callback, options);
}
function flushSyncCallbackQueue() {
if (null !== immediateQueueCallbackNode) {
var node = immediateQueueCallbackNode;
immediateQueueCallbackNode = null, unstable_cancelCallback(node);
}
flushSyncCallbackQueueImpl();
}
function flushSyncCallbackQueueImpl() {
if (!isFlushingSyncQueue && null !== syncQueue) {
// Prevent re-entrancy.
isFlushingSyncQueue = !0;
var i = 0;
try {
var _queue = syncQueue;
runWithPriority$1(99, function() {
for(; i < _queue.length; i++){
var callback = _queue[i];
do callback = callback(!0);
while (null !== callback)
}
}), syncQueue = null;
} catch (error) {
throw null !== syncQueue && (syncQueue = syncQueue.slice(i + 1)), unstable_scheduleCallback(unstable_ImmediatePriority, flushSyncCallbackQueue), error;
} finally{
isFlushingSyncQueue = !1;
}
}
}
// TODO: this is special because it gets imported during build.
var ReactVersion = "17.0.2", ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig, ReactStrictModeWarnings = {
recordUnsafeLifecycleWarnings: function(fiber, instance) {},
flushPendingUnsafeLifecycleWarnings: function() {},
recordLegacyContextWarning: function(fiber, instance) {},
flushLegacyContextWarning: function() {},
discardPendingWarnings: function() {}
}, findStrictRoot = function(fiber) {
for(var maybeStrictRoot = null, node = fiber; null !== node;)1 & node.mode && (maybeStrictRoot = node), node = node.return;
return maybeStrictRoot;
}, setToSortedString = function(set) {
var array = [];
return set.forEach(function(value) {
array.push(value);
}), array.sort().join(", ");
}, pendingComponentWillMountWarnings = [], pendingUNSAFE_ComponentWillMountWarnings = [], pendingComponentWillReceivePropsWarnings = [], pendingUNSAFE_ComponentWillReceivePropsWarnings = [], pendingComponentWillUpdateWarnings = [], pendingUNSAFE_ComponentWillUpdateWarnings = [], didWarnAboutUnsafeLifecycles = new Set();
ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function(fiber, instance) {
// Dedup strategy: Warn once per component.
!didWarnAboutUnsafeLifecycles.has(fiber.type) && ("function" == typeof instance.componentWillMount && // Don't warn about react-lifecycles-compat polyfilled components.
!0 !== instance.componentWillMount.__suppressDeprecationWarning && pendingComponentWillMountWarnings.push(fiber), 1 & fiber.mode && "function" == typeof instance.UNSAFE_componentWillMount && pendingUNSAFE_ComponentWillMountWarnings.push(fiber), "function" == typeof instance.componentWillReceiveProps && !0 !== instance.componentWillReceiveProps.__suppressDeprecationWarning && pendingComponentWillReceivePropsWarnings.push(fiber), 1 & fiber.mode && "function" == typeof instance.UNSAFE_componentWillReceiveProps && pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber), "function" == typeof instance.componentWillUpdate && !0 !== instance.componentWillUpdate.__suppressDeprecationWarning && pendingComponentWillUpdateWarnings.push(fiber), 1 & fiber.mode && "function" == typeof instance.UNSAFE_componentWillUpdate && pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber));
}, ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function() {
// We do an initial pass to gather component names
var componentWillMountUniqueNames = new Set();
pendingComponentWillMountWarnings.length > 0 && (pendingComponentWillMountWarnings.forEach(function(fiber) {
componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingComponentWillMountWarnings = []);
var UNSAFE_componentWillMountUniqueNames = new Set();
pendingUNSAFE_ComponentWillMountWarnings.length > 0 && (pendingUNSAFE_ComponentWillMountWarnings.forEach(function(fiber) {
UNSAFE_componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingUNSAFE_ComponentWillMountWarnings = []);
var componentWillReceivePropsUniqueNames = new Set();
pendingComponentWillReceivePropsWarnings.length > 0 && (pendingComponentWillReceivePropsWarnings.forEach(function(fiber) {
componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingComponentWillReceivePropsWarnings = []);
var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0 && (pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function(fiber) {
UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingUNSAFE_ComponentWillReceivePropsWarnings = []);
var componentWillUpdateUniqueNames = new Set();
pendingComponentWillUpdateWarnings.length > 0 && (pendingComponentWillUpdateWarnings.forEach(function(fiber) {
componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingComponentWillUpdateWarnings = []);
var UNSAFE_componentWillUpdateUniqueNames = new Set();
pendingUNSAFE_ComponentWillUpdateWarnings.length > 0 && (pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function(fiber) {
UNSAFE_componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutUnsafeLifecycles.add(fiber.type);
}), pendingUNSAFE_ComponentWillUpdateWarnings = []), UNSAFE_componentWillMountUniqueNames.size > 0 && error("Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n\nPlease update the following components: %s", setToSortedString(UNSAFE_componentWillMountUniqueNames)), UNSAFE_componentWillReceivePropsUniqueNames.size > 0 && error("Using UNSAFE_componentWillReceiveProps in strict mode is not recommended and may indicate bugs in your code. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n\nPlease update the following components: %s", setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames)), UNSAFE_componentWillUpdateUniqueNames.size > 0 && error("Using UNSAFE_componentWillUpdate in strict mode is not recommended and may indicate bugs in your code. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n\nPlease update the following components: %s", setToSortedString(UNSAFE_componentWillUpdateUniqueNames)), componentWillMountUniqueNames.size > 0 && warn("componentWillMount has been renamed, and is not recommended for use. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n* Rename componentWillMount to UNSAFE_componentWillMount to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", setToSortedString(componentWillMountUniqueNames)), componentWillReceivePropsUniqueNames.size > 0 && warn("componentWillReceiveProps has been renamed, and is not recommended for use. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", setToSortedString(componentWillReceivePropsUniqueNames)), componentWillUpdateUniqueNames.size > 0 && warn("componentWillUpdate has been renamed, and is not recommended for use. See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", setToSortedString(componentWillUpdateUniqueNames));
};
var pendingLegacyContextWarning = new Map(), didWarnAboutLegacyContext = new Set(); // Tracks components we have already warned about.
function resolveDefaultProps(Component, baseProps) {
if (Component && Component.defaultProps) {
// Resolve default props. Taken from ReactElement
var props = _assign({}, baseProps), defaultProps = Component.defaultProps;
for(var propName in defaultProps)void 0 === props[propName] && (props[propName] = defaultProps[propName]);
return props;
}
return baseProps;
}
ReactStrictModeWarnings.recordLegacyContextWarning = function(fiber, instance) {
var strictRoot = findStrictRoot(fiber);
if (null === strictRoot) {
error("Expected to find a StrictMode component in a strict mode tree. This error is likely caused by a bug in React. Please file an issue.");
return;
} // Dedup strategy: Warn once per component.
if (!didWarnAboutLegacyContext.has(fiber.type)) {
var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
(null != fiber.type.contextTypes || null != fiber.type.childContextTypes || null !== instance && "function" == typeof instance.getChildContext) && (void 0 === warningsForRoot && (warningsForRoot = [], pendingLegacyContextWarning.set(strictRoot, warningsForRoot)), warningsForRoot.push(fiber));
}
}, ReactStrictModeWarnings.flushLegacyContextWarning = function() {
pendingLegacyContextWarning.forEach(function(fiberArray, strictRoot) {
if (0 !== fiberArray.length) {
var firstFiber = fiberArray[0], uniqueNames = new Set();
fiberArray.forEach(function(fiber) {
uniqueNames.add(getComponentName(fiber.type) || "Component"), didWarnAboutLegacyContext.add(fiber.type);
});
var sortedNames = setToSortedString(uniqueNames);
try {
setCurrentFiber(firstFiber), error("Legacy context API has been detected within a strict-mode tree.\n\nThe old API will be supported in all 16.x releases, but applications using it should migrate to the new version.\n\nPlease update the following components: %s\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context", sortedNames);
} finally{
resetCurrentFiber();
}
}
});
}, ReactStrictModeWarnings.discardPendingWarnings = function() {
pendingComponentWillMountWarnings = [], pendingUNSAFE_ComponentWillMountWarnings = [], pendingComponentWillReceivePropsWarnings = [], pendingUNSAFE_ComponentWillReceivePropsWarnings = [], pendingComponentWillUpdateWarnings = [], pendingUNSAFE_ComponentWillUpdateWarnings = [], pendingLegacyContextWarning = new Map();
};
var valueCursor = createCursor(null);
// Use this to detect multiple renderers using the same context
rendererSigil = {};
var currentlyRenderingFiber = null, lastContextDependency = null, lastContextWithAllBitsObserved = null, isDisallowedContextReadInDEV = !1;
function resetContextDependencies() {
// This is called right before React yields execution, to ensure `readContext`
// cannot be called outside the render phase.
currentlyRenderingFiber = null, lastContextDependency = null, lastContextWithAllBitsObserved = null, isDisallowedContextReadInDEV = !1;
}
function pushProvider(providerFiber, nextValue) {
var context = providerFiber.type._context;
push(valueCursor, context._currentValue, providerFiber), context._currentValue = nextValue, void 0 !== context._currentRenderer && null !== context._currentRenderer && context._currentRenderer !== rendererSigil && error("Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."), context._currentRenderer = rendererSigil;
}
function popProvider(providerFiber) {
var currentValue = valueCursor.current;
pop(valueCursor, providerFiber), providerFiber.type._context._currentValue = currentValue;
}
function scheduleWorkOnParentPath(parent, renderLanes) {
for(// Update the child lanes of all the ancestors, including the alternates.
var node = parent; null !== node;){
var a, a1, alternate = node.alternate;
if ((node.childLanes & renderLanes) === renderLanes) {
if (null === alternate || (alternate.childLanes & renderLanes) === renderLanes) break;
a = alternate.childLanes, alternate.childLanes = a | renderLanes;
} else node.childLanes = node.childLanes | renderLanes, null !== alternate && (a1 = alternate.childLanes, alternate.childLanes = a1 | renderLanes);
node = node.return;
}
}
function prepareToReadContext(workInProgress, renderLanes) {
currentlyRenderingFiber = workInProgress, lastContextDependency = null, lastContextWithAllBitsObserved = null;
var a, dependencies = workInProgress.dependencies;
null !== dependencies && null !== dependencies.firstContext && (a = dependencies.lanes, (a & renderLanes) != 0 && (didReceiveUpdate = !0), dependencies.firstContext = null);
}
function readContext(context, observedBits) {
if (isDisallowedContextReadInDEV && error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."), lastContextWithAllBitsObserved === context) ;
else if (!1 === observedBits || 0 === observedBits) ;
else {
"number" != typeof observedBits || 1073741823 === observedBits ? (// Observe all updates.
lastContextWithAllBitsObserved = context, resolvedObservedBits = 1073741823) : resolvedObservedBits = observedBits;
var resolvedObservedBits, contextItem = {
context: context,
observedBits: resolvedObservedBits,
next: null
};
if (null === lastContextDependency) {
if (null === currentlyRenderingFiber) throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
// This is the first dependency for this component. Create a new list.
lastContextDependency = contextItem, currentlyRenderingFiber.dependencies = {
lanes: 0,
firstContext: contextItem,
responders: null
};
} else // Append a new context item.
lastContextDependency = lastContextDependency.next = contextItem;
}
return context._currentValue;
}
var hasForceUpdate = !1;
function initializeUpdateQueue(fiber) {
var queue = {
baseState: fiber.memoizedState,
firstBaseUpdate: null,
lastBaseUpdate: null,
shared: {
pending: null
},
effects: null
};
fiber.updateQueue = queue;
}
function cloneUpdateQueue(current, workInProgress) {
// Clone the update queue from current. Unless it's already a clone.
var queue = workInProgress.updateQueue, currentQueue = current.updateQueue;
queue === currentQueue && (workInProgress.updateQueue = {
baseState: currentQueue.baseState,
firstBaseUpdate: currentQueue.firstBaseUpdate,
lastBaseUpdate: currentQueue.lastBaseUpdate,
shared: currentQueue.shared,
effects: currentQueue.effects
});
}
function createUpdate(eventTime, lane) {
return {
eventTime: eventTime,
lane: lane,
tag: 0,
payload: null,
callback: null,
next: null
};
}
function enqueueUpdate(fiber, update) {
var updateQueue = fiber.updateQueue;
if (null !== updateQueue) {
var sharedQueue = updateQueue.shared, pending = sharedQueue.pending;
null === pending ? // This is the first update. Create a circular list.
update.next = update : (update.next = pending.next, pending.next = update), sharedQueue.pending = update, currentlyProcessingQueue !== sharedQueue || didWarnUpdateInsideUpdate || (error("An update (setState, replaceState, or forceUpdate) was scheduled from inside an update function. Update functions should be pure, with zero side-effects. Consider using componentDidUpdate or a callback."), didWarnUpdateInsideUpdate = !0);
}
}
function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
// Captured updates are updates that are thrown by a child during the render
// phase. They should be discarded if the render is aborted. Therefore,
// we should only put them on the work-in-progress queue, not the current one.
var queue = workInProgress.updateQueue, current = workInProgress.alternate; // Check if the work-in-progress queue is a clone.
if (null !== current) {
var currentQueue = current.updateQueue;
if (queue === currentQueue) {
// The work-in-progress queue is the same as current. This happens when
// we bail out on a parent fiber that then captures an error thrown by
// a child. Since we want to append the update only to the work-in
// -progress queue, we need to clone the updates. We usually clone during
// processUpdateQueue, but that didn't happen in this case because we
// skipped over the parent when we bailed out.
var newFirst = null, newLast = null, firstBaseUpdate = queue.firstBaseUpdate;
if (null !== firstBaseUpdate) {
// Loop through the updates and clone them.
var update = firstBaseUpdate;
do {
var clone = {
eventTime: update.eventTime,
lane: update.lane,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null
};
null === newLast ? newFirst = newLast = clone : (newLast.next = clone, newLast = clone), update = update.next;
}while (null !== update) // Append the captured update the end of the cloned list.
null === newLast ? newFirst = newLast = capturedUpdate : (newLast.next = capturedUpdate, newLast = capturedUpdate);
} else // There are no base updates.
newFirst = newLast = capturedUpdate;
workInProgress.updateQueue = queue = {
baseState: currentQueue.baseState,
firstBaseUpdate: newFirst,
lastBaseUpdate: newLast,
shared: currentQueue.shared,
effects: currentQueue.effects
};
return;
}
} // Append the update to the end of the list.
var lastBaseUpdate = queue.lastBaseUpdate;
null === lastBaseUpdate ? queue.firstBaseUpdate = capturedUpdate : lastBaseUpdate.next = capturedUpdate, queue.lastBaseUpdate = capturedUpdate;
}
function processUpdateQueue(workInProgress, props, instance, renderLanes) {
// This is always non-null on a ClassComponent or HostRoot
var queue = workInProgress.updateQueue;
hasForceUpdate = !1, currentlyProcessingQueue = queue.shared;
var firstBaseUpdate = queue.firstBaseUpdate, lastBaseUpdate = queue.lastBaseUpdate, pendingQueue = queue.shared.pending;
if (null !== pendingQueue) {
queue.shared.pending = null;
// and last so that it's non-circular.
var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
lastPendingUpdate.next = null, null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate, lastBaseUpdate = lastPendingUpdate;
// we need to transfer the updates to that queue, too. Because the base
// queue is a singly-linked list with no cycles, we can append to both
// lists and take advantage of structural sharing.
// TODO: Pass `current` as argument
var current = workInProgress.alternate;
if (null !== current) {
// This is always non-null on a ClassComponent or HostRoot
var currentQueue = current.updateQueue, currentLastBaseUpdate = currentQueue.lastBaseUpdate;
currentLastBaseUpdate !== lastBaseUpdate && (null === currentLastBaseUpdate ? currentQueue.firstBaseUpdate = firstPendingUpdate : currentLastBaseUpdate.next = firstPendingUpdate, currentQueue.lastBaseUpdate = lastPendingUpdate);
}
} // These values may change as we process the queue.
if (null !== firstBaseUpdate) {
for(// Iterate through the list of updates to compute the result.
var newState = queue.baseState, newLanes = 0, newBaseState = null, newFirstBaseUpdate = null, newLastBaseUpdate = null, update = firstBaseUpdate;;){
var updateLane = update.lane, updateEventTime = update.eventTime;
if ((renderLanes & updateLane) === updateLane) {
// This update does have sufficient priority.
if (null !== newLastBaseUpdate) {
var _clone = {
eventTime: updateEventTime,
// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane: 0,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null
};
newLastBaseUpdate = newLastBaseUpdate.next = _clone;
} // Process this update.
if (newState = function(workInProgress, queue, update, prevState, nextProps, instance) {
switch(update.tag){
case 1:
var payload = update.payload;
if ("function" == typeof payload) {
isDisallowedContextReadInDEV = !0;
var nextState = payload.call(instance, prevState, nextProps);
if (1 & workInProgress.mode) {
disableLogs();
try {
payload.call(instance, prevState, nextProps);
} finally{
reenableLogs();
}
}
return isDisallowedContextReadInDEV = !1, nextState;
} // State object
return payload;
case 3:
workInProgress.flags = -4097 & workInProgress.flags | /* */ 64;
// Intentional fallthrough
case 0:
var partialState, _payload = update.payload;
if ("function" == typeof _payload) {
if (isDisallowedContextReadInDEV = !0, partialState = _payload.call(instance, prevState, nextProps), 1 & workInProgress.mode) {
disableLogs();
try {
_payload.call(instance, prevState, nextProps);
} finally{
reenableLogs();
}
}
isDisallowedContextReadInDEV = !1;
} else // Partial state object
partialState = _payload;
if (null == partialState) break;
// Merge the partial state and the previous state.
return _assign({}, prevState, partialState);
case 2:
hasForceUpdate = !0;
}
return prevState;
}(workInProgress, 0, update, newState, props, instance), null !== update.callback) {
workInProgress.flags |= /* */ 32;
var effects = queue.effects;
null === effects ? queue.effects = [
update
] : effects.push(update);
}
} else {
// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
var clone = {
eventTime: updateEventTime,
lane: updateLane,
tag: update.tag,
payload: update.payload,
callback: update.callback,
next: null
};
null === newLastBaseUpdate ? (newFirstBaseUpdate = newLastBaseUpdate = clone, newBaseState = newState) : newLastBaseUpdate = newLastBaseUpdate.next = clone, newLanes |= updateLane;
}
if (null === (update = update.next)) {
if (null === (pendingQueue = queue.shared.pending)) break;
// An update was scheduled from inside a reducer. Add the new
// pending updates to the end of the list and keep processing.
var _lastPendingUpdate = pendingQueue, _firstPendingUpdate = _lastPendingUpdate.next; // Intentionally unsound. Pending updates form a circular list, but we
_lastPendingUpdate.next = null, update = _firstPendingUpdate, queue.lastBaseUpdate = _lastPendingUpdate, queue.shared.pending = null;
}
}
null === newLastBaseUpdate && (newBaseState = newState), queue.baseState = newBaseState, queue.firstBaseUpdate = newFirstBaseUpdate, queue.lastBaseUpdate = newLastBaseUpdate, // This should be fine because the only two other things that contribute to
// expiration time are props and context. We're already in the middle of the
// begin phase by the time we start processing the queue, so we've already
// dealt with the props. Context in components that specify
// shouldComponentUpdate is tricky; but we'll have to account for
// that regardless.
function(lane) {
workInProgressRootSkippedLanes |= lane;
}(newLanes), workInProgress.lanes = newLanes, workInProgress.memoizedState = newState;
}
currentlyProcessingQueue = null;
}
didWarnUpdateInsideUpdate = !1, currentlyProcessingQueue = null;
function commitUpdateQueue(finishedWork, finishedQueue, instance) {
// Commit the effects
var effects = finishedQueue.effects;
if (finishedQueue.effects = null, null !== effects) for(var i = 0; i < effects.length; i++){
var effect = effects[i], callback = effect.callback;
null !== callback && (effect.callback = null, function(callback, context) {
if ("function" != typeof callback) throw Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback);
callback.call(context);
}(callback, instance));
}
}
var fakeInternalInstance = {}, isArray = Array.isArray, emptyRefsObject = new React.Component().refs;
didWarnAboutStateAssignmentForComponent = new Set(), didWarnAboutUninitializedState = new Set(), didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set(), didWarnAboutLegacyLifecyclesAndDerivedState = new Set(), didWarnAboutDirectlyAssigningPropsToState = new Set(), didWarnAboutUndefinedDerivedState = new Set(), didWarnAboutContextTypeAndContextTypes = new Set(), didWarnAboutInvalidateContextType = new Set();
var didWarnOnInvalidCallback = new Set();
function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
var prevState = workInProgress.memoizedState;
if (1 & workInProgress.mode) {
disableLogs();
try {
// Invoke the function an extra time to help detect side-effects.
getDerivedStateFromProps(nextProps, prevState);
} finally{
reenableLogs();
}
}
var partialState = getDerivedStateFromProps(nextProps, prevState);
warnOnUndefinedDerivedState(ctor, partialState);
var memoizedState = null == partialState ? prevState : _assign({}, prevState, partialState);
workInProgress.memoizedState = memoizedState, 0 === workInProgress.lanes && (workInProgress.updateQueue.baseState = memoizedState);
}
warnOnInvalidCallback = function(callback, callerName) {
if (null !== callback && "function" != typeof callback) {
var key = callerName + "_" + callback;
didWarnOnInvalidCallback.has(key) || (didWarnOnInvalidCallback.add(key), error("%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.", callerName, callback));
}
}, warnOnUndefinedDerivedState = function(type, partialState) {
if (void 0 === partialState) {
var componentName = getComponentName(type) || "Component";
didWarnAboutUndefinedDerivedState.has(componentName) || (didWarnAboutUndefinedDerivedState.add(componentName), error("%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.", componentName));
}
}, // it causes problems. This is meant to give a nicer error message for
// ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
// ...)) which otherwise throws a "_processChildContext is not a function"
// exception.
Object.defineProperty(fakeInternalInstance, "_processChildContext", {
enumerable: !1,
value: function() {
throw Error("_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).");
}
}), Object.freeze(fakeInternalInstance);
var classComponentUpdater = {
isMounted: function(component) {
var owner = ReactCurrentOwner.current;
if (null !== owner && 1 === owner.tag) {
var instance = owner.stateNode;
instance._warnedAboutRefsInRender || error("%s is accessing isMounted inside its render() function. render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentName(owner.type) || "A component"), instance._warnedAboutRefsInRender = !0;
}
var fiber = get(component);
return !!fiber && getNearestMountedFiber(fiber) === fiber;
},
enqueueSetState: function(inst, payload, callback) {
var fiber = get(inst), eventTime = requestEventTime(), lane = requestUpdateLane(fiber), update = createUpdate(eventTime, lane);
update.payload = payload, null != callback && (warnOnInvalidCallback(callback, "setState"), update.callback = callback), enqueueUpdate(fiber, update), scheduleUpdateOnFiber(fiber, lane, eventTime);
},
enqueueReplaceState: function(inst, payload, callback) {
var fiber = get(inst), eventTime = requestEventTime(), lane = requestUpdateLane(fiber), update = createUpdate(eventTime, lane);
update.tag = 1, update.payload = payload, null != callback && (warnOnInvalidCallback(callback, "replaceState"), update.callback = callback), enqueueUpdate(fiber, update), scheduleUpdateOnFiber(fiber, lane, eventTime);
},
enqueueForceUpdate: function(inst, callback) {
var fiber = get(inst), eventTime = requestEventTime(), lane = requestUpdateLane(fiber), update = createUpdate(eventTime, lane);
update.tag = 2, null != callback && (warnOnInvalidCallback(callback, "forceUpdate"), update.callback = callback), enqueueUpdate(fiber, update), scheduleUpdateOnFiber(fiber, lane, eventTime);
}
};
function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
var instance = workInProgress.stateNode;
if ("function" == typeof instance.shouldComponentUpdate) {
if (1 & workInProgress.mode) {
disableLogs();
try {
// Invoke the function an extra time to help detect side-effects.
instance.shouldComponentUpdate(newProps, newState, nextContext);
} finally{
reenableLogs();
}
}
var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
return void 0 === shouldUpdate && error("%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component"), shouldUpdate;
}
return !ctor.prototype || !ctor.prototype.isPureReactComponent || !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
}
function adoptClassInstance(workInProgress, instance) {
instance.updater = classComponentUpdater, workInProgress.stateNode = instance, instance._reactInternals = workInProgress, instance._reactInternalInstance = fakeInternalInstance;
}
function constructClassInstance(workInProgress, ctor, props) {
var isLegacyContextConsumer = !1, unmaskedContext = emptyContextObject, context = emptyContextObject, contextType = ctor.contextType;
if ("contextType" in ctor && null !== contextType && (void 0 === contextType || contextType.$$typeof !== REACT_CONTEXT_TYPE || void 0 !== contextType._context) && !didWarnAboutInvalidateContextType.has(ctor)) {
didWarnAboutInvalidateContextType.add(ctor);
var addendum = "";
addendum = void 0 === contextType ? " However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file." : "object" != typeof contextType ? " However, it is set to a " + typeof contextType + "." : contextType.$$typeof === REACT_PROVIDER_TYPE ? " Did you accidentally pass the Context.Provider instead?" : void 0 !== contextType._context ? " Did you accidentally pass the Context.Consumer instead?" : " However, it is set to an object with keys {" + Object.keys(contextType).join(", ") + "}.", error("%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s", getComponentName(ctor) || "Component", addendum);
}
if ("object" == typeof contextType && null !== contextType ? context = readContext(contextType) : (unmaskedContext = getUnmaskedContext(workInProgress, ctor, !0), context = (isLegacyContextConsumer = null != ctor.contextTypes) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject), 1 & workInProgress.mode) {
disableLogs();
try {
new ctor(props, context); // eslint-disable-line no-new
} finally{
reenableLogs();
}
}
var instance = new ctor(props, context), state = workInProgress.memoizedState = null !== instance.state && void 0 !== instance.state ? instance.state : null;
if (adoptClassInstance(workInProgress, instance), "function" == typeof ctor.getDerivedStateFromProps && null === state) {
var componentName = getComponentName(ctor) || "Component";
didWarnAboutUninitializedState.has(componentName) || (didWarnAboutUninitializedState.add(componentName), error("`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, null === instance.state ? "null" : "undefined", componentName));
} // If new component APIs are defined, "unsafe" lifecycles won't be called.
// Warn about these lifecycles if they are present.
// Don't warn about react-lifecycles-compat polyfilled methods though.
if ("function" == typeof ctor.getDerivedStateFromProps || "function" == typeof instance.getSnapshotBeforeUpdate) {
var foundWillMountName = null, foundWillReceivePropsName = null, foundWillUpdateName = null;
if ("function" == typeof instance.componentWillMount && !0 !== instance.componentWillMount.__suppressDeprecationWarning ? foundWillMountName = "componentWillMount" : "function" == typeof instance.UNSAFE_componentWillMount && (foundWillMountName = "UNSAFE_componentWillMount"), "function" == typeof instance.componentWillReceiveProps && !0 !== instance.componentWillReceiveProps.__suppressDeprecationWarning ? foundWillReceivePropsName = "componentWillReceiveProps" : "function" == typeof instance.UNSAFE_componentWillReceiveProps && (foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps"), "function" == typeof instance.componentWillUpdate && !0 !== instance.componentWillUpdate.__suppressDeprecationWarning ? foundWillUpdateName = "componentWillUpdate" : "function" == typeof instance.UNSAFE_componentWillUpdate && (foundWillUpdateName = "UNSAFE_componentWillUpdate"), null !== foundWillMountName || null !== foundWillReceivePropsName || null !== foundWillUpdateName) {
var _componentName = getComponentName(ctor) || "Component", newApiName = "function" == typeof ctor.getDerivedStateFromProps ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName) || (didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName), error("Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\nThe above lifecycles should be removed. Learn more about this warning here:\nhttps://reactjs.org/link/unsafe-component-lifecycles", _componentName, newApiName, null !== foundWillMountName ? "\n " + foundWillMountName : "", null !== foundWillReceivePropsName ? "\n " + foundWillReceivePropsName : "", null !== foundWillUpdateName ? "\n " + foundWillUpdateName : ""));
}
}
return isLegacyContextConsumer && cacheContext(workInProgress, unmaskedContext, context), instance;
}
function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
var oldState = instance.state;
if ("function" == typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext), "function" == typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext), instance.state !== oldState) {
var componentName = getComponentName(workInProgress.type) || "Component";
didWarnAboutStateAssignmentForComponent.has(componentName) || (didWarnAboutStateAssignmentForComponent.add(componentName), error("%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", componentName)), classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
}
} // Invokes the mount life-cycles on a previously never rendered instance.
function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
instance = workInProgress.stateNode, name = getComponentName(ctor) || "Component", instance.render || (ctor.prototype && "function" == typeof ctor.prototype.render ? error("%s(...): No `render` method found on the returned component instance: did you accidentally return an object from the constructor?", name) : error("%s(...): No `render` method found on the returned component instance: you may have forgotten to define `render`.", name)), !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state || error("getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?", name), instance.getDefaultProps && !instance.getDefaultProps.isReactClassApproved && error("getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.", name), instance.propTypes && error("propTypes was defined as an instance property on %s. Use a static property to define propTypes instead.", name), instance.contextType && error("contextType was defined as an instance property on %s. Use a static property to define contextType instead.", name), instance.contextTypes && error("contextTypes was defined as an instance property on %s. Use a static property to define contextTypes instead.", name), ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor) && (didWarnAboutContextTypeAndContextTypes.add(ctor), error("%s declares both contextTypes and contextType static properties. The legacy contextTypes property will be ignored.", name)), "function" == typeof instance.componentShouldUpdate && error("%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", name), ctor.prototype && ctor.prototype.isPureReactComponent && void 0 !== instance.shouldComponentUpdate && error("%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component"), "function" == typeof instance.componentDidUnmount && error("%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?", name), "function" == typeof instance.componentDidReceiveProps && error("%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name), "function" == typeof instance.componentWillRecieveProps && error("%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name), "function" == typeof instance.UNSAFE_componentWillRecieveProps && error("%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name), hasMutatedProps = instance.props !== newProps, void 0 !== instance.props && hasMutatedProps && error("%s(...): When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.", name, name), instance.defaultProps && error("Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.", name, name), "function" != typeof instance.getSnapshotBeforeUpdate || "function" == typeof instance.componentDidUpdate || didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor) || (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor), error("%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor))), "function" == typeof instance.getDerivedStateFromProps && error("%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name), "function" == typeof instance.getDerivedStateFromError && error("%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name), "function" == typeof ctor.getSnapshotBeforeUpdate && error("%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.", name), (_state = instance.state) && ("object" != typeof _state || isArray(_state)) && error("%s.state: must be set to an object or null", name), "function" == typeof instance.getChildContext && "object" != typeof ctor.childContextTypes && error("%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().", name);
var instance, name, hasMutatedProps, _state, oldState, instance1 = workInProgress.stateNode;
instance1.props = newProps, instance1.state = workInProgress.memoizedState, instance1.refs = emptyRefsObject, initializeUpdateQueue(workInProgress);
var contextType = ctor.contextType;
if ("object" == typeof contextType && null !== contextType) instance1.context = readContext(contextType);
else {
var unmaskedContext = getUnmaskedContext(workInProgress, ctor, !0);
instance1.context = getMaskedContext(workInProgress, unmaskedContext);
}
if (instance1.state === newProps) {
var componentName = getComponentName(ctor) || "Component";
didWarnAboutDirectlyAssigningPropsToState.has(componentName) || (didWarnAboutDirectlyAssigningPropsToState.add(componentName), error("%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.", componentName));
}
1 & workInProgress.mode && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance1), ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance1), processUpdateQueue(workInProgress, newProps, instance1, renderLanes), instance1.state = workInProgress.memoizedState;
var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
"function" == typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps), instance1.state = workInProgress.memoizedState), "function" != typeof ctor.getDerivedStateFromProps && "function" != typeof instance1.getSnapshotBeforeUpdate && ("function" == typeof instance1.UNSAFE_componentWillMount || "function" == typeof instance1.componentWillMount) && (oldState = instance1.state, "function" == typeof instance1.componentWillMount && instance1.componentWillMount(), "function" == typeof instance1.UNSAFE_componentWillMount && instance1.UNSAFE_componentWillMount(), oldState !== instance1.state && (error("%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component"), classComponentUpdater.enqueueReplaceState(instance1, instance1.state, null)), // process them now.
processUpdateQueue(workInProgress, newProps, instance1, renderLanes), instance1.state = workInProgress.memoizedState), "function" == typeof instance1.componentDidMount && (workInProgress.flags |= /* */ 4);
}
var warnForMissingKey = function(child, returnFiber) {};
didWarnAboutMaps = !1, didWarnAboutGenerators = !1, didWarnAboutStringRefs = {}, /**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/ ownerHasKeyUseWarning = {}, ownerHasFunctionTypeWarning = {}, warnForMissingKey = function(child, returnFiber) {
if (null !== child && "object" == typeof child && child._store && !child._store.validated && null == child.key) {
if ("object" != typeof child._store) throw Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.");
child._store.validated = !0;
var componentName = getComponentName(returnFiber.type) || "Component";
!ownerHasKeyUseWarning[componentName] && (ownerHasKeyUseWarning[componentName] = !0, error('Each child in a list should have a unique "key" prop. See https://reactjs.org/link/warning-keys for more information.'));
}
};
var isArray$1 = Array.isArray;
function coerceRef(returnFiber, current, element) {
var mixedRef = element.ref;
if (null !== mixedRef && "function" != typeof mixedRef && "object" != typeof mixedRef) {
// TODO: Clean this up once we turn on the string ref warning for
// everyone, because the strict mode case will no longer be relevant
if (1 & returnFiber.mode && // We warn in ReactElement.js if owner and self are equal for string refs
// because these cannot be automatically converted to an arrow function
// using a codemod. Therefore, we don't have to warn about string refs again.
!(element._owner && element._self && element._owner.stateNode !== element._self)) {
var componentName = getComponentName(returnFiber.type) || "Component";
didWarnAboutStringRefs[componentName] || (error('A string ref, "%s", has been found within a strict mode tree. String refs are a source of potential bugs and should be avoided. We recommend using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', mixedRef), didWarnAboutStringRefs[componentName] = !0);
}
if (element._owner) {
var inst, owner = element._owner;
if (owner) {
if (1 !== owner.tag) throw Error("Function components cannot have string refs. We recommend using useRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref");
inst = owner.stateNode;
}
if (!inst) throw Error("Missing owner for string ref " + mixedRef + ". This error is likely caused by a bug in React. Please file an issue.");
var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
if (null !== current && null !== current.ref && "function" == typeof current.ref && current.ref._stringRef === stringRef) return current.ref;
var ref = function(value) {
var refs = inst.refs;
refs === emptyRefsObject && // This is a lazy pooled frozen object, so we need to initialize.
(refs = inst.refs = {}), null === value ? delete refs[stringRef] : refs[stringRef] = value;
};
return ref._stringRef = stringRef, ref;
}
if ("string" != typeof mixedRef) throw Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
if (!element._owner) throw Error("Element ref was specified as a string (" + mixedRef + ") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://reactjs.org/link/refs-must-have-owner for more information.");
}
return mixedRef;
}
function throwOnInvalidObjectType(returnFiber, newChild) {
if ("textarea" !== returnFiber.type) throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === Object.prototype.toString.call(newChild) ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild) + "). If you meant to render a collection of children, use an array instead.");
}
function warnOnFunctionType(returnFiber) {
var componentName = getComponentName(returnFiber.type) || "Component";
!ownerHasFunctionTypeWarning[componentName] && (ownerHasFunctionTypeWarning[componentName] = !0, error("Functions are not valid as a React child. This may happen if you return a Component instead of <Component /> from render. Or maybe you meant to call this function rather than return it."));
} // We avoid inlining this to avoid potential deopts from using try/catch.
// to be able to optimize each path individually by branching early. This needs
// a compiler or we can do it manually. Helpers that don't need this branching
// live outside of this function.
function ChildReconciler(shouldTrackSideEffects) {
function deleteChild(returnFiber, childToDelete) {
if (shouldTrackSideEffects) {
// At this point, the return fiber's effect list is empty except for
// deletions, so we can just append the deletion to the list. The remaining
// effects aren't added until the complete phase. Once we implement
// resuming, this may not be true.
var last = returnFiber.lastEffect;
null !== last ? (last.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete, childToDelete.nextEffect = null, childToDelete.flags = /* */ 8;
} // Deletions are added in reversed order so we add it to the front.
}
function deleteRemainingChildren(returnFiber, currentFirstChild) {
if (!shouldTrackSideEffects) // Noop.
return null;
// TODO: For the shouldClone case, this could be micro-optimized a bit by
for(// assuming that after the first child we've already added everything.
var childToDelete = currentFirstChild; null !== childToDelete;)deleteChild(returnFiber, childToDelete), childToDelete = childToDelete.sibling;
return null;
}
function mapRemainingChildren(returnFiber, currentFirstChild) {
for(// Add the remaining children to a temporary map so that we can find them by
// keys quickly. Implicit (null) keys get added to this set with their index
// instead.
var existingChildren = new Map(), existingChild = currentFirstChild; null !== existingChild;)null !== existingChild.key ? existingChildren.set(existingChild.key, existingChild) : existingChildren.set(existingChild.index, existingChild), existingChild = existingChild.sibling;
return existingChildren;
}
function useFiber(fiber, pendingProps) {
// We currently set sibling to null and index to 0 here because it is easy
// to forget to do before returning it. E.g. for the single child case.
var clone = createWorkInProgress(fiber, pendingProps);
return clone.index = 0, clone.sibling = null, clone;
}
function placeChild(newFiber, lastPlacedIndex, newIndex) {
if (newFiber.index = newIndex, !shouldTrackSideEffects) // Noop.
return lastPlacedIndex;
var current = newFiber.alternate;
if (null === current) return(// This is an insertion.
newFiber.flags = /* */ 2, lastPlacedIndex);
var oldIndex = current.index;
return oldIndex < lastPlacedIndex ? (// This is a move.
newFiber.flags = 2, lastPlacedIndex) : oldIndex;
}
function placeSingleChild(newFiber) {
return shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags = 2), newFiber;
}
function updateTextNode(returnFiber, current, textContent, lanes) {
if (null === current || 6 !== current.tag) {
// Insert
var created = createFiberFromText(textContent, returnFiber.mode, lanes);
return created.return = returnFiber, created;
}
// Update
var existing = useFiber(current, textContent);
return existing.return = returnFiber, existing;
}
function updateElement(returnFiber, current, element, lanes) {
if (null !== current && (current.elementType === element.type || // Keep this check inline so it only runs on the false path:
isCompatibleFamilyForHotReloading(current, element))) {
// Move based on index
var existing = useFiber(current, element.props);
return existing.ref = coerceRef(returnFiber, current, element), existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, existing;
} // Insert
var created = createFiberFromElement(element, returnFiber.mode, lanes);
return created.ref = coerceRef(returnFiber, current, element), created.return = returnFiber, created;
}
function updatePortal(returnFiber, current, portal, lanes) {
if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
// Insert
var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
return created.return = returnFiber, created;
}
// Update
var existing = useFiber(current, portal.children || []);
return existing.return = returnFiber, existing;
}
function updateFragment(returnFiber, current, fragment, lanes, key) {
if (null === current || 7 !== current.tag) {
// Insert
var created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);
return created.return = returnFiber, created;
}
// Update
var existing = useFiber(current, fragment);
return existing.return = returnFiber, existing;
}
function createChild(returnFiber, newChild, lanes) {
if ("string" == typeof newChild || "number" == typeof newChild) {
// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
return created.return = returnFiber, created;
}
if ("object" == typeof newChild && null !== newChild) {
switch(newChild.$$typeof){
case REACT_ELEMENT_TYPE:
var _created = createFiberFromElement(newChild, returnFiber.mode, lanes);
return _created.ref = coerceRef(returnFiber, null, newChild), _created.return = returnFiber, _created;
case REACT_PORTAL_TYPE:
var _created2 = createFiberFromPortal(newChild, returnFiber.mode, lanes);
return _created2.return = returnFiber, _created2;
}
if (isArray$1(newChild) || getIteratorFn(newChild)) {
var _created3 = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);
return _created3.return = returnFiber, _created3;
}
throwOnInvalidObjectType(returnFiber, newChild);
}
return "function" == typeof newChild && warnOnFunctionType(returnFiber), null;
}
function updateSlot(returnFiber, oldFiber, newChild, lanes) {
// Update the fiber if the keys match, otherwise return null.
var key = null !== oldFiber ? oldFiber.key : null;
if ("string" == typeof newChild || "number" == typeof newChild) return(// Text nodes don't have keys. If the previous node is implicitly keyed
// we can continue to replace it without aborting even if it is not a text
// node.
null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes));
if ("object" == typeof newChild && null !== newChild) {
switch(newChild.$$typeof){
case REACT_ELEMENT_TYPE:
if (newChild.key !== key) return null;
if (newChild.type === REACT_FRAGMENT_TYPE) return updateFragment(returnFiber, oldFiber, newChild.props.children, lanes, key);
return updateElement(returnFiber, oldFiber, newChild, lanes);
case REACT_PORTAL_TYPE:
if (newChild.key === key) return updatePortal(returnFiber, oldFiber, newChild, lanes);
return null;
}
if (isArray$1(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
throwOnInvalidObjectType(returnFiber, newChild);
}
return "function" == typeof newChild && warnOnFunctionType(returnFiber), null;
}
function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
if ("string" == typeof newChild || "number" == typeof newChild) return updateTextNode(returnFiber, existingChildren.get(newIdx) || null, "" + newChild, lanes);
if ("object" == typeof newChild && null !== newChild) {
switch(newChild.$$typeof){
case REACT_ELEMENT_TYPE:
var _matchedFiber = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null;
if (newChild.type === REACT_FRAGMENT_TYPE) return updateFragment(returnFiber, _matchedFiber, newChild.props.children, lanes, newChild.key);
return updateElement(returnFiber, _matchedFiber, newChild, lanes);
case REACT_PORTAL_TYPE:
return updatePortal(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, lanes);
}
if (isArray$1(newChild) || getIteratorFn(newChild)) return updateFragment(returnFiber, existingChildren.get(newIdx) || null, newChild, lanes, null);
throwOnInvalidObjectType(returnFiber, newChild);
}
return "function" == typeof newChild && warnOnFunctionType(returnFiber), null;
}
/**
* Warns if there is a duplicate or missing key
*/ function warnOnInvalidKey(child, knownKeys, returnFiber) {
if ("object" != typeof child || null === child) return knownKeys;
switch(child.$$typeof){
case REACT_ELEMENT_TYPE:
case REACT_PORTAL_TYPE:
warnForMissingKey(child, returnFiber);
var key = child.key;
if ("string" != typeof key) break;
if (null === knownKeys) {
(knownKeys = new Set()).add(key);
break;
}
if (!knownKeys.has(key)) {
knownKeys.add(key);
break;
}
error("Encountered two children with the same key, `%s`. Keys should be unique so that components maintain their identity across updates. Non-unique keys may cause children to be duplicated and/or omitted — the behavior is unsupported and could change in a future version.", key);
}
return knownKeys;
}
return(// itself. They will be added to the side-effect list as we pass through the
// children and the parent.
function(returnFiber, currentFirstChild, newChild, lanes) {
// This function is not recursive.
// If the top level item is an array, we treat it as a set of children,
// not as a fragment. Nested arrays on the other hand will be treated as
// fragment nodes. Recursion happens at the normal flow.
// Handle top level unkeyed fragments as if they were arrays.
// This leads to an ambiguity between <>{[...]}</> and <>...</>.
// We treat the ambiguous cases above the same.
var isUnkeyedTopLevelFragment = "object" == typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key;
isUnkeyedTopLevelFragment && (newChild = newChild.props.children);
var isObject = "object" == typeof newChild && null !== newChild;
if (isObject) switch(newChild.$$typeof){
case REACT_ELEMENT_TYPE:
return placeSingleChild(function(returnFiber, currentFirstChild, element, lanes) {
for(var key = element.key, child = currentFirstChild; null !== child;){
// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if (child.key === key) {
if (7 === child.tag) {
if (element.type === REACT_FRAGMENT_TYPE) {
deleteRemainingChildren(returnFiber, child.sibling);
var existing = useFiber(child, element.props.children);
return existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, existing;
}
} else if (child.elementType === element.type || // Keep this check inline so it only runs on the false path:
isCompatibleFamilyForHotReloading(child, element)) {
deleteRemainingChildren(returnFiber, child.sibling);
var _existing3 = useFiber(child, element.props);
return _existing3.ref = coerceRef(returnFiber, child, element), _existing3.return = returnFiber, _existing3._debugSource = element._source, _existing3._debugOwner = element._owner, _existing3;
}
// Didn't match.
deleteRemainingChildren(returnFiber, child);
break;
}
deleteChild(returnFiber, child), child = child.sibling;
}
if (element.type === REACT_FRAGMENT_TYPE) {
var created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);
return created.return = returnFiber, created;
}
var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
return _created4.ref = coerceRef(returnFiber, currentFirstChild, element), _created4.return = returnFiber, _created4;
}(returnFiber, currentFirstChild, newChild, lanes));
case REACT_PORTAL_TYPE:
return placeSingleChild(function(returnFiber, currentFirstChild, portal, lanes) {
for(var key = portal.key, child = currentFirstChild; null !== child;){
// TODO: If key === null and child.key === null, then this only applies to
// the first item in the list.
if (child.key === key) {
if (4 === child.tag && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
deleteRemainingChildren(returnFiber, child.sibling);
var existing = useFiber(child, portal.children || []);
return existing.return = returnFiber, existing;
}
deleteRemainingChildren(returnFiber, child);
break;
}
deleteChild(returnFiber, child), child = child.sibling;
}
var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
return created.return = returnFiber, created;
} // This API will tag the children with the side-effect of the reconciliation
(returnFiber, currentFirstChild, newChild, lanes));
}
if ("string" == typeof newChild || "number" == typeof newChild) return placeSingleChild(function(returnFiber, currentFirstChild, textContent, lanes) {
// There's no need to check for keys on text nodes since we don't have a
// way to define them.
if (null !== currentFirstChild && 6 === currentFirstChild.tag) {
// We already have an existing node so let's just update it and delete
// the rest.
deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
var existing = useFiber(currentFirstChild, textContent);
return existing.return = returnFiber, existing;
} // The existing first child is not a text node so we need to create one
// and delete the existing ones.
deleteRemainingChildren(returnFiber, currentFirstChild);
var created = createFiberFromText(textContent, returnFiber.mode, lanes);
return created.return = returnFiber, created;
}(returnFiber, currentFirstChild, "" + newChild, lanes));
if (isArray$1(newChild)) return function(returnFiber, currentFirstChild, newChildren, lanes) {
for(var knownKeys = null, i = 0; i < newChildren.length; i++)knownKeys = warnOnInvalidKey(newChildren[i], knownKeys, returnFiber);
for(// First, validate keys.
var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++){
oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
if (null === newFiber) {
// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
null === oldFiber && (oldFiber = nextOldFiber);
break;
}
shouldTrackSideEffects && oldFiber && null === newFiber.alternate && // We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber, oldFiber), lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? // TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = newFiber : // TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling = newFiber, previousNewFiber = newFiber, oldFiber = nextOldFiber;
}
if (newIdx === newChildren.length) return(// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild);
if (null === oldFiber) {
// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for(; newIdx < newChildren.length; newIdx++){
var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
null !== _newFiber && (lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? // TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = _newFiber : previousNewFiber.sibling = _newFiber, previousNewFiber = _newFiber);
}
return resultingFirstChild;
} // Add all children to a key map for quick lookups.
for(var existingChildren = mapRemainingChildren(returnFiber, oldFiber); newIdx < newChildren.length; newIdx++){
var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);
null !== _newFiber2 && (shouldTrackSideEffects && null !== _newFiber2.alternate && // The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(null === _newFiber2.key ? newIdx : _newFiber2.key), lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber2 : previousNewFiber.sibling = _newFiber2, previousNewFiber = _newFiber2);
}
return shouldTrackSideEffects && // Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function(child) {
return deleteChild(returnFiber, child);
}), resultingFirstChild;
}(returnFiber, currentFirstChild, newChild, lanes);
if (getIteratorFn(newChild)) return function(returnFiber, currentFirstChild, newChildrenIterable, lanes) {
// This is the same implementation as reconcileChildrenArray(),
// but using the iterator instead.
var iteratorFn = getIteratorFn(newChildrenIterable);
if ("function" != typeof iteratorFn) throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
"function" == typeof Symbol && // $FlowFixMe Flow doesn't know about toStringTag
"Generator" === newChildrenIterable[Symbol.toStringTag] && (didWarnAboutGenerators || error("Using Generators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. Keep in mind you might need to polyfill these features for older browsers."), didWarnAboutGenerators = !0), newChildrenIterable.entries === iteratorFn && (didWarnAboutMaps || error("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0);
// We'll get a different iterator later for the main pass.
var _newChildren = iteratorFn.call(newChildrenIterable);
if (_newChildren) for(var knownKeys = null, _step = _newChildren.next(); !_step.done; _step = _newChildren.next())knownKeys = warnOnInvalidKey(_step.value, knownKeys, returnFiber);
var newChildren = iteratorFn.call(newChildrenIterable);
if (null == newChildren) throw Error("An iterable object provided no iterator.");
for(var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()){
oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
if (null === newFiber) {
// TODO: This breaks on empty slots like null children. That's
// unfortunate because it triggers the slow path all the time. We need
// a better way to communicate whether this was a miss or null,
// boolean, undefined, etc.
null === oldFiber && (oldFiber = nextOldFiber);
break;
}
shouldTrackSideEffects && oldFiber && null === newFiber.alternate && // We matched the slot, but we didn't reuse the existing fiber, so we
// need to delete the existing child.
deleteChild(returnFiber, oldFiber), lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? // TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = newFiber : // TODO: Defer siblings if we're not at the right index for this slot.
// I.e. if we had null values before, then we want to defer this
// for each null value. However, we also don't want to call updateSlot
// with the previous one.
previousNewFiber.sibling = newFiber, previousNewFiber = newFiber, oldFiber = nextOldFiber;
}
if (step.done) return(// We've reached the end of the new children. We can delete the rest.
deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild);
if (null === oldFiber) {
// If we don't have any more existing children we can choose a fast path
// since the rest will all be insertions.
for(; !step.done; newIdx++, step = newChildren.next()){
var _newFiber3 = createChild(returnFiber, step.value, lanes);
null !== _newFiber3 && (lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx), null === previousNewFiber ? // TODO: Move out of the loop. This only happens for the first run.
resultingFirstChild = _newFiber3 : previousNewFiber.sibling = _newFiber3, previousNewFiber = _newFiber3);
}
return resultingFirstChild;
} // Add all children to a key map for quick lookups.
for(var existingChildren = mapRemainingChildren(returnFiber, oldFiber); !step.done; newIdx++, step = newChildren.next()){
var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);
null !== _newFiber4 && (shouldTrackSideEffects && null !== _newFiber4.alternate && // The new fiber is a work in progress, but if there exists a
// current, that means that we reused the fiber. We need to delete
// it from the child list so that we don't add it to the deletion
// list.
existingChildren.delete(null === _newFiber4.key ? newIdx : _newFiber4.key), lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber4 : previousNewFiber.sibling = _newFiber4, previousNewFiber = _newFiber4);
}
return shouldTrackSideEffects && // Any existing children that weren't consumed above were deleted. We need
// to add them to the deletion list.
existingChildren.forEach(function(child) {
return deleteChild(returnFiber, child);
}), resultingFirstChild;
}(returnFiber, currentFirstChild, newChild, lanes);
if (isObject && throwOnInvalidObjectType(returnFiber, newChild), "function" == typeof newChild && warnOnFunctionType(returnFiber), void 0 === newChild && !isUnkeyedTopLevelFragment) // If the new child is undefined, and the return fiber is a composite
// component, throw an error. If Fiber return types are disabled,
// we already threw above.
switch(returnFiber.tag){
case 1:
if (returnFiber.stateNode.render._isMockFunction) break;
// Intentionally fall through to the next case, which handles both
// functions and classes
// eslint-disable-next-lined no-fallthrough
case 22:
case 0:
case 11:
case 15:
throw Error((getComponentName(returnFiber.type) || "Component") + "(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.");
}
// Remaining cases are all treated as empty.
return deleteRemainingChildren(returnFiber, currentFirstChild);
});
}
var reconcileChildFibers = ChildReconciler(!0), mountChildFibers = ChildReconciler(!1), NO_CONTEXT = {}, contextStackCursor$1 = createCursor(NO_CONTEXT), contextFiberStackCursor = createCursor(NO_CONTEXT), rootInstanceStackCursor = createCursor(NO_CONTEXT);
function requiredContext(c) {
if (c === NO_CONTEXT) throw Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");
return c;
}
function getRootHostContainer() {
return requiredContext(rootInstanceStackCursor.current);
}
function pushHostContainer(fiber, nextRootInstance) {
// Push current root instance onto the stack;
// This allows us to reset root when portals are popped.
push(rootInstanceStackCursor, nextRootInstance, fiber), // This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor, fiber, fiber), // However, we can't just call getRootHostContext() and push it because
// we'd have a different number of entries on the stack depending on
// whether getRootHostContext() throws somewhere in renderer code or not.
// So we push an empty value first. This lets us safely unwind on errors.
push(contextStackCursor$1, NO_CONTEXT, fiber);
var nextRootContext = function(rootContainerInstance) {
var type, namespace, nodeType = rootContainerInstance.nodeType;
switch(nodeType){
case 9:
case 11:
type = 9 === nodeType ? "#document" : "#fragment";
var root = rootContainerInstance.documentElement;
namespace = root ? root.namespaceURI : getChildNamespace(null, "");
break;
default:
var container = 8 === nodeType ? rootContainerInstance.parentNode : rootContainerInstance;
namespace = getChildNamespace(container.namespaceURI || null, type = container.tagName);
}
var validatedTag = type.toLowerCase();
return {
namespace: namespace,
ancestorInfo: updatedAncestorInfo(null, validatedTag)
};
}(nextRootInstance); // Now that we know this function doesn't throw, replace it.
pop(contextStackCursor$1, fiber), push(contextStackCursor$1, nextRootContext, fiber);
}
function popHostContainer(fiber) {
pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber), pop(rootInstanceStackCursor, fiber);
}
function getHostContext() {
return requiredContext(contextStackCursor$1.current);
}
function pushHostContext(fiber) {
requiredContext(rootInstanceStackCursor.current);
var type, context = requiredContext(contextStackCursor$1.current), nextContext = (type = fiber.type, {
namespace: getChildNamespace(context.namespace, type),
ancestorInfo: updatedAncestorInfo(context.ancestorInfo, type)
});
context !== nextContext && (// This enables us to pop only Fibers that provide unique contexts.
push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber)); // Track the context and the Fiber that provided it.
}
function popHostContext(fiber) {
// Do not pop unless this Fiber provided the current context.
// pushHostContext() only pushes Fibers that provide unique contexts.
contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
}
var suspenseStackCursor = createCursor(0);
function findFirstSuspended(row) {
for(var node = row; null !== node;){
if (13 === node.tag) {
var state = node.memoizedState;
if (null !== state) {
var dehydrated = state.dehydrated;
if (null === dehydrated || "$?" === dehydrated.data || "$!" === dehydrated.data) return node;
}
} else if (19 === node.tag && // revealOrder undefined can't be trusted because it don't
// keep track of whether it suspended or not.
void 0 !== node.memoizedProps.revealOrder) {
if ((64 & node.flags) != 0) return node;
} else if (null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === row) break;
for(; null === node.sibling;){
if (null === node.return || node.return === row) return null;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
return null;
}
// This may have been an insertion or a hydration.
var hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
function deleteHydratableInstance(returnFiber, instance) {
switch(returnFiber.tag){
case 3:
parentContainer = returnFiber.stateNode.containerInfo, 1 === instance.nodeType ? warnForDeletedHydratableElement(parentContainer, instance) : 8 === instance.nodeType || warnForDeletedHydratableText(parentContainer, instance);
break;
case 5:
returnFiber.type, parentProps = returnFiber.memoizedProps, parentInstance = returnFiber.stateNode, !0 !== parentProps[SUPPRESS_HYDRATION_WARNING$1] && (1 === instance.nodeType ? warnForDeletedHydratableElement(parentInstance, instance) : 8 === instance.nodeType || warnForDeletedHydratableText(parentInstance, instance));
}
var fiber, parentContainer, parentType, parentProps, parentInstance, childToDelete = ((fiber = createFiber(5, null, null, 0)).elementType = "DELETED", fiber.type = "DELETED", fiber);
childToDelete.stateNode = instance, childToDelete.return = returnFiber, childToDelete.flags = 8, null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
}
function insertNonHydratedInstance(returnFiber, fiber) {
switch(fiber.flags = -1025 & fiber.flags | 2, returnFiber.tag){
case 3:
var parentContainer = returnFiber.stateNode.containerInfo;
switch(fiber.tag){
case 5:
var type = fiber.type;
fiber.pendingProps, warnForInsertedHydratedElement(parentContainer, type);
break;
case 6:
warnForInsertedHydratedText(parentContainer, fiber.pendingProps);
}
break;
case 5:
returnFiber.type;
var parentProps = returnFiber.memoizedProps, parentInstance = returnFiber.stateNode;
switch(fiber.tag){
case 5:
var _type = fiber.type;
fiber.pendingProps, !0 !== parentProps[SUPPRESS_HYDRATION_WARNING$1] && warnForInsertedHydratedElement(parentInstance, _type);
break;
case 6:
var _text = fiber.pendingProps;
!0 !== parentProps[SUPPRESS_HYDRATION_WARNING$1] && warnForInsertedHydratedText(parentInstance, _text);
break;
case 13:
parentProps[SUPPRESS_HYDRATION_WARNING$1];
}
break;
default:
return;
}
}
function tryHydrate(fiber, nextInstance) {
switch(fiber.tag){
case 5:
var type = fiber.type;
fiber.pendingProps;
var instance = 1 !== nextInstance.nodeType || type.toLowerCase() !== nextInstance.nodeName.toLowerCase() ? null : nextInstance;
if (null !== instance) return fiber.stateNode = instance, !0;
return !1;
case 6:
var textInstance = "" === fiber.pendingProps || 3 !== nextInstance.nodeType ? null : nextInstance;
if (null !== textInstance) return fiber.stateNode = textInstance, !0;
return !1;
default:
return !1;
}
}
function tryToClaimNextHydratableInstance(fiber) {
if (isHydrating) {
var nextInstance = nextHydratableInstance;
if (!nextInstance) {
// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber, fiber), isHydrating = !1, hydrationParentFiber = fiber;
return;
}
var firstAttemptedInstance = nextInstance;
if (!tryHydrate(fiber, nextInstance)) {
if (!// If we can't hydrate this instance let's try the next one.
// We use this as a heuristic. It's based on intuition and not data so it
// might be flawed or unnecessary.
(nextInstance = getNextHydratableSibling(firstAttemptedInstance)) || !tryHydrate(fiber, nextInstance)) {
// Nothing to hydrate. Make it an insertion.
insertNonHydratedInstance(hydrationParentFiber, fiber), isHydrating = !1, hydrationParentFiber = fiber;
return;
} // We matched the next one, we'll now assume that the first one was
// superfluous and we'll delete it. Since we can't eagerly delete it
// we'll have to schedule a deletion. To do that, this node needs a dummy
// fiber associated with it.
deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
}
hydrationParentFiber = fiber, nextHydratableInstance = getFirstHydratableChild(nextInstance);
}
}
function popToNextHostParent(fiber) {
for(var parent = fiber.return; null !== parent && 5 !== parent.tag && 3 !== parent.tag && 13 !== parent.tag;)parent = parent.return;
hydrationParentFiber = parent;
}
function popHydrationState(fiber) {
if (fiber !== hydrationParentFiber) // We're deeper than the current hydration context, inside an inserted
// tree.
return !1;
if (!isHydrating) return(// If we're not currently hydrating but we're in a hydration context, then
// we were an insertion and now need to pop up reenter hydration of our
// siblings.
popToNextHostParent(fiber), isHydrating = !0, !1);
var type = fiber.type; // If we have any remaining hydratable nodes, we need to delete them now.
// We only do this deeper than head and body since they tend to have random
// other nodes in them. We also ignore components with pure text content in
// side of them.
// TODO: Better heuristic.
if (5 !== fiber.tag || "head" !== type && "body" !== type && !shouldSetTextContent(type, fiber.memoizedProps)) for(var nextInstance = nextHydratableInstance; nextInstance;)deleteHydratableInstance(fiber, nextInstance), nextInstance = getNextHydratableSibling(nextInstance);
return popToNextHostParent(fiber), nextHydratableInstance = 13 === fiber.tag ? function(fiber) {
var suspenseState = fiber.memoizedState, suspenseInstance = null !== suspenseState ? suspenseState.dehydrated : null;
if (!suspenseInstance) throw Error("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue.");
return function(suspenseInstance) {
for(var node = suspenseInstance.nextSibling, depth = 0; node;){
if (8 === node.nodeType) {
var data = node.data;
if ("/$" === data) {
if (0 === depth) return getNextHydratableSibling(node);
depth--;
} else ("$" === data || "$!" === data || "$?" === data) && depth++;
}
node = node.nextSibling;
} // TODO: Warn, we didn't find the end comment boundary.
return null;
} // Returns the SuspenseInstance if this node is a direct child of a
(suspenseInstance);
}(fiber) : hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null, !0;
}
function resetHydrationState() {
hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
}
// and should be reset before starting a new render.
// This tracks which mutable sources need to be reset after a render.
var workInProgressSources = [];
function resetWorkInProgressVersions() {
for(var i = 0; i < workInProgressSources.length; i++)workInProgressSources[i]._workInProgressVersionPrimary = null;
workInProgressSources.length = 0;
}
function setWorkInProgressVersion(mutableSource, version) {
mutableSource._workInProgressVersionPrimary = version, workInProgressSources.push(mutableSource);
}
// Used to detect multiple renderers using the same mutable source.
rendererSigil$1 = {};
var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher, ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;
didWarnAboutUseOpaqueIdentifier = {}, didWarnAboutMismatchedHooksForComponent = new Set();
// These are set right before calling the component.
var renderLanes = 0, currentlyRenderingFiber$1 = null, currentHook = null, workInProgressHook = null, didScheduleRenderPhaseUpdate = !1, didScheduleRenderPhaseUpdateDuringThisPass = !1, currentHookNameInDev = null, hookTypesDev = null, hookTypesUpdateIndexDev = -1, ignorePreviousDependencies = !1; // The work-in-progress fiber. I've named it differently to distinguish it from
function mountHookTypesDev() {
var hookName = currentHookNameInDev;
null === hookTypesDev ? hookTypesDev = [
hookName
] : hookTypesDev.push(hookName);
}
function updateHookTypesDev() {
var hookName = currentHookNameInDev;
null !== hookTypesDev && hookTypesDev[++hookTypesUpdateIndexDev] !== hookName && function(currentHookName) {
var componentName = getComponentName(currentlyRenderingFiber$1.type);
if (!didWarnAboutMismatchedHooksForComponent.has(componentName) && (didWarnAboutMismatchedHooksForComponent.add(componentName), null !== hookTypesDev)) {
for(var table = "", i = 0; i <= hookTypesUpdateIndexDev; i++){
// lol @ IE not supporting String#repeat
for(var oldHookName = hookTypesDev[i], newHookName = i === hookTypesUpdateIndexDev ? currentHookName : oldHookName, row = i + 1 + ". " + oldHookName; row.length < 30;)row += " ";
row += newHookName + "\n", table += row;
}
error("React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n Previous render Next render\n ------------------------------------------------------\n%s ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
}
}(hookName);
}
function checkDepsAreArrayDev(deps) {
null == deps || Array.isArray(deps) || // Verify deps, but only on mount to avoid extra checks.
// It's unlikely their type would change as usually you define them inline.
error("%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.", currentHookNameInDev, typeof deps);
}
function throwInvalidHookError() {
throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
}
function areHookInputsEqual(nextDeps, prevDeps) {
if (ignorePreviousDependencies) // Only true when this component is being hot reloaded.
return !1;
if (null === prevDeps) return error("%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.", currentHookNameInDev), !1;
// Don't bother comparing lengths in prod because these arrays should be
// passed inline.
nextDeps.length !== prevDeps.length && error("The final argument passed to %s changed size between renders. The order and size of this array must remain constant.\n\nPrevious: %s\nIncoming: %s", currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + nextDeps.join(", ") + "]");
for(var i = 0; i < prevDeps.length && i < nextDeps.length; i++)if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
return !0;
}
function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
renderLanes = nextRenderLanes, currentlyRenderingFiber$1 = workInProgress, hookTypesDev = null !== current ? current._debugHookTypes : null, hookTypesUpdateIndexDev = -1, ignorePreviousDependencies = null !== current && current.type !== workInProgress.type, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.lanes = 0, null !== current && null !== current.memoizedState ? ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV : null !== hookTypesDev ? // This dispatcher handles an edge case where a component is updating,
// but no stateful hooks have been used.
// We want to match the production code behavior (which will use HooksDispatcherOnMount),
// but with the extra DEV validation to ensure hooks ordering hasn't changed.
// This dispatcher does that.
ReactCurrentDispatcher$1.current = HooksDispatcherOnMountWithHookTypesInDEV : ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
var children = Component(props, secondArg); // Check if there was a render phase update
if (didScheduleRenderPhaseUpdateDuringThisPass) {
// Keep rendering in a loop for as long as render phase updates continue to
// be scheduled. Use a counter to prevent infinite loops.
var numberOfReRenders = 0;
do {
if (didScheduleRenderPhaseUpdateDuringThisPass = !1, !(numberOfReRenders < 25)) throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
numberOfReRenders += 1, // Even when hot reloading, allow dependencies to stabilize
// after first render to prevent infinite render phase updates.
ignorePreviousDependencies = !1, currentHook = null, workInProgressHook = null, workInProgress.updateQueue = null, // Also validate hook order for cascading updates.
hookTypesUpdateIndexDev = -1, ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV, children = Component(props, secondArg);
}while (didScheduleRenderPhaseUpdateDuringThisPass)
} // We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current = ContextOnlyDispatcher, workInProgress._debugHookTypes = hookTypesDev;
// hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
if (renderLanes = 0, currentlyRenderingFiber$1 = null, currentHook = null, workInProgressHook = null, currentHookNameInDev = null, hookTypesDev = null, hookTypesUpdateIndexDev = -1, didScheduleRenderPhaseUpdate = !1, didRenderTooFewHooks) throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
return children;
}
function bailoutHooks(current, workInProgress, lanes) {
var set;
workInProgress.updateQueue = current.updateQueue, workInProgress.flags &= -517, set = current.lanes, current.lanes = set & ~lanes;
}
function resetHooksAfterThrow() {
if (// We can assume the previous dispatcher is always this one, since we set it
// at the beginning of the render phase and there's no re-entrancy.
ReactCurrentDispatcher$1.current = ContextOnlyDispatcher, didScheduleRenderPhaseUpdate) {
for(// There were render phase updates. These are only valid for this render
// phase, which we are now aborting. Remove the updates from the queues so
// they do not persist to the next render. Do not remove updates from hooks
// that weren't processed.
//
// Only reset the updates from the queue if it has a clone. If it does
// not have a clone, that means it wasn't processed, and the updates were
// scheduled before we entered the render phase.
var hook = currentlyRenderingFiber$1.memoizedState; null !== hook;){
var queue = hook.queue;
null !== queue && (queue.pending = null), hook = hook.next;
}
didScheduleRenderPhaseUpdate = !1;
}
renderLanes = 0, currentlyRenderingFiber$1 = null, currentHook = null, workInProgressHook = null, hookTypesDev = null, hookTypesUpdateIndexDev = -1, currentHookNameInDev = null, isUpdatingOpaqueValueInRenderPhase = !1, didScheduleRenderPhaseUpdateDuringThisPass = !1;
}
function mountWorkInProgressHook() {
var hook = {
memoizedState: null,
baseState: null,
baseQueue: null,
queue: null,
next: null
};
return null === workInProgressHook ? // This is the first hook in the list
currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook : // Append to the end of the list
workInProgressHook = workInProgressHook.next = hook, workInProgressHook;
}
function updateWorkInProgressHook() {
if (null === currentHook) {
var nextCurrentHook, nextWorkInProgressHook, current = currentlyRenderingFiber$1.alternate;
nextCurrentHook = null !== current ? current.memoizedState : null;
} else nextCurrentHook = currentHook.next;
if (null !== (nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber$1.memoizedState : workInProgressHook.next)) nextWorkInProgressHook = // There's already a work-in-progress. Reuse it.
(workInProgressHook = nextWorkInProgressHook).next, currentHook = nextCurrentHook;
else {
// Clone from the current hook.
if (null === nextCurrentHook) throw Error("Rendered more hooks than during the previous render.");
var newHook = {
memoizedState: (currentHook = nextCurrentHook).memoizedState,
baseState: currentHook.baseState,
baseQueue: currentHook.baseQueue,
queue: currentHook.queue,
next: null
};
null === workInProgressHook ? // This is the first hook in the list.
currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook : // Append to the end of the list.
workInProgressHook = workInProgressHook.next = newHook;
}
return workInProgressHook;
}
function basicStateReducer(state, action) {
// $FlowFixMe: Flow doesn't like mixed types
return "function" == typeof action ? action(state) : action;
}
function mountReducer(reducer, initialArg, init) {
var initialState, hook = mountWorkInProgressHook();
hook.memoizedState = hook.baseState = initialState = void 0 !== init ? init(initialArg) : initialArg;
var queue = hook.queue = {
pending: null,
dispatch: null,
lastRenderedReducer: reducer,
lastRenderedState: initialState
}, dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
return [
hook.memoizedState,
dispatch
];
}
function updateReducer(reducer, initialArg, init) {
var hook = updateWorkInProgressHook(), queue = hook.queue;
if (null === queue) throw Error("Should have a queue. This is likely a bug in React. Please file an issue.");
queue.lastRenderedReducer = reducer;
var current = currentHook, baseQueue = current.baseQueue, pendingQueue = queue.pending; // The last rebase update that is NOT part of the base state.
if (null !== pendingQueue) {
// We have new updates that haven't been processed yet.
// We'll add them to the base queue.
if (null !== baseQueue) {
// Merge the pending queue and the base queue.
var baseFirst = baseQueue.next, pendingFirst = pendingQueue.next;
baseQueue.next = pendingFirst, pendingQueue.next = baseFirst;
}
current.baseQueue !== baseQueue && // Internal invariant that should never happen, but feasibly could in
// the future if we implement resuming, or some form of that.
error("Internal error: Expected work-in-progress queue to be a clone. This is a bug in React."), current.baseQueue = baseQueue = pendingQueue, queue.pending = null;
}
if (null !== baseQueue) {
// We have a queue to process.
var first = baseQueue.next, newState = current.baseState, newBaseState = null, newBaseQueueFirst = null, newBaseQueueLast = null, update = first;
do {
var updateLane = update.lane;
if ((renderLanes & updateLane) === updateLane) {
// This update does have sufficient priority.
if (null !== newBaseQueueLast) {
var _clone = {
// This update is going to be committed so we never want uncommit
// it. Using NoLane works because 0 is a subset of all bitmasks, so
// this will never be skipped by the check above.
lane: 0,
action: update.action,
eagerReducer: update.eagerReducer,
eagerState: update.eagerState,
next: null
};
newBaseQueueLast = newBaseQueueLast.next = _clone;
} // Process this update.
// If this update was processed eagerly, and its reducer matches the
// current reducer, we can use the eagerly computed state.
newState = update.eagerReducer === reducer ? update.eagerState : reducer(newState, update.action);
} else {
// Priority is insufficient. Skip this update. If this is the first
// skipped update, the previous update/state is the new base
// update/state.
var clone = {
lane: updateLane,
action: update.action,
eagerReducer: update.eagerReducer,
eagerState: update.eagerState,
next: null
};
null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = clone, newBaseState = newState) : newBaseQueueLast = newBaseQueueLast.next = clone, // TODO: Don't need to accumulate this. Instead, we can remove
// renderLanes from the original lanes.
currentlyRenderingFiber$1.lanes = currentlyRenderingFiber$1.lanes | updateLane, function(lane) {
workInProgressRootSkippedLanes |= lane;
}(updateLane);
}
update = update.next;
}while (null !== update && update !== first)
null === newBaseQueueLast ? newBaseState = newState : newBaseQueueLast.next = newBaseQueueFirst, objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0), hook.memoizedState = newState, hook.baseState = newBaseState, hook.baseQueue = newBaseQueueLast, queue.lastRenderedState = newState;
}
var dispatch = queue.dispatch;
return [
hook.memoizedState,
dispatch
];
}
function rerenderReducer(reducer, initialArg, init) {
var hook = updateWorkInProgressHook(), queue = hook.queue;
if (null === queue) throw Error("Should have a queue. This is likely a bug in React. Please file an issue.");
queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
// work-in-progress hook.
var dispatch = queue.dispatch, lastRenderPhaseUpdate = queue.pending, newState = hook.memoizedState;
if (null !== lastRenderPhaseUpdate) {
// The queue doesn't persist past this render pass.
queue.pending = null;
var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next, update = firstRenderPhaseUpdate;
do newState = reducer(newState, update.action), update = update.next;
while (update !== firstRenderPhaseUpdate) // Mark that the fiber performed work, but only if the new state is
objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0), hook.memoizedState = newState, null === hook.baseQueue && (hook.baseState = newState), queue.lastRenderedState = newState;
}
return [
newState,
dispatch
];
}
function readFromUnsubcribedMutableSource(root, source, getSnapshot) {
null == source._currentPrimaryRenderer ? source._currentPrimaryRenderer = rendererSigil$1 : source._currentPrimaryRenderer !== rendererSigil$1 && error("Detected multiple renderers concurrently rendering the same mutable source. This is currently unsupported.");
var subset, version = (0, source._getVersion)(source._source), isSafeToReadFromSource = !1, currentRenderVersion = source._workInProgressVersionPrimary; // Is it safe for this component to read from this source during the current render?
if (null !== currentRenderVersion ? // It's safe to read if the store hasn't been mutated since the last time
// we read something.
isSafeToReadFromSource = currentRenderVersion === version : // If there's no version, then this is the first time we've read from the
// source during the current render pass, so we need to do a bit more work.
// What we need to determine is if there are any hooks that already
// subscribed to the source, and if so, whether there are any pending
// mutations that haven't been synchronized yet.
//
// If there are no pending mutations, then `root.mutableReadLanes` will be
// empty, and we know we can safely read.
//
// If there *are* pending mutations, we may still be able to safely read
// if the currently rendering lanes are inclusive of the pending mutation
// lanes, since that guarantees that the value we're about to read from
// the source is consistent with the values that we read during the most
// recent mutation.
(isSafeToReadFromSource = (renderLanes & (subset = root.mutableReadLanes)) === subset) && // If it's safe to read from this source during the current render,
// store the version in case other components read from it.
// A changed version number will let those components know to throw and restart the render.
setWorkInProgressVersion(source, version), isSafeToReadFromSource) {
var snapshot = getSnapshot(source._source);
return "function" == typeof snapshot && error("Mutable source should not return a function as the snapshot value. Functions may close over mutable values and cause tearing."), snapshot;
}
throw workInProgressSources.push(source), Error("Cannot read from mutable source during the current render without tearing. This is a bug in React. Please file an issue.");
}
function useMutableSource(hook, source, getSnapshot, subscribe) {
var root = workInProgressRoot;
if (null === root) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
var getVersion = source._getVersion, version = getVersion(source._source), dispatcher = ReactCurrentDispatcher$1.current, _dispatcher$useState = dispatcher.useState(function() {
return readFromUnsubcribedMutableSource(root, source, getSnapshot);
}), currentSnapshot = _dispatcher$useState[0], setSnapshot = _dispatcher$useState[1], snapshot = currentSnapshot, stateHook = workInProgressHook, memoizedState = hook.memoizedState, refs = memoizedState.refs, prevGetSnapshot = refs.getSnapshot, prevSource = memoizedState.source, prevSubscribe = memoizedState.subscribe, fiber = currentlyRenderingFiber$1;
//
// If either the source or the subscription have changed we can't can't trust the update queue.
// Maybe the source changed in a way that the old subscription ignored but the new one depends on.
//
// If the getSnapshot function changed, we also shouldn't rely on the update queue.
// It's possible that the underlying source was mutated between the when the last "change" event fired,
// and when the current render (with the new getSnapshot function) is processed.
//
// In both cases, we need to throw away pending updates (since they are no longer relevant)
// and treat reading from the source as we do in the mount case.
if (hook.memoizedState = {
refs: refs,
source: source,
subscribe: subscribe
}, dispatcher.useEffect(function() {
if (refs.getSnapshot = getSnapshot, // but this hook recreates the queue in certain cases to avoid updates from stale sources.
// handleChange() below needs to reference the dispatch function without re-subscribing,
// so we use a ref to ensure that it always has the latest version.
refs.setSnapshot = setSnapshot, !objectIs(version, getVersion(source._source))) {
var maybeNewSnapshot = getSnapshot(source._source);
"function" == typeof maybeNewSnapshot && error("Mutable source should not return a function as the snapshot value. Functions may close over mutable values and cause tearing."), objectIs(snapshot, maybeNewSnapshot) || (setSnapshot(maybeNewSnapshot), markRootMutableRead(root, requestUpdateLane(fiber))), // there may be state updates already scheduled from the old source.
// Entangle the updates so that they render in the same batch.
function(root, entangledLanes) {
root.entangledLanes |= entangledLanes;
for(var entanglements = root.entanglements, lanes = entangledLanes; lanes > 0;){
var index = pickArbitraryLaneIndex(lanes), lane = 1 << index;
entanglements[index] |= entangledLanes, lanes &= ~lane;
}
}(root, root.mutableReadLanes);
}
}, [
getSnapshot,
source,
subscribe
]), dispatcher.useEffect(function() {
var unsubscribe = subscribe(source._source, function() {
var latestGetSnapshot = refs.getSnapshot, latestSetSnapshot = refs.setSnapshot;
try {
latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
var lane = requestUpdateLane(fiber);
markRootMutableRead(root, lane);
} catch (error) {
// A selector might throw after a source mutation.
// e.g. it might try to read from a part of the store that no longer exists.
// In this case we should still schedule an update with React.
// Worst case the selector will throw again and then an error boundary will handle it.
latestSetSnapshot(function() {
throw error;
});
}
});
return "function" != typeof unsubscribe && error("Mutable source subscribe function must return an unsubscribe function."), unsubscribe;
}, [
source,
subscribe
]), !objectIs(prevGetSnapshot, getSnapshot) || !objectIs(prevSource, source) || !objectIs(prevSubscribe, subscribe)) {
// Create a new queue and setState method,
// So if there are interleaved updates, they get pushed to the older queue.
// When this becomes current, the previous queue and dispatch method will be discarded,
// including any interleaving updates that occur.
var newQueue = {
pending: null,
dispatch: null,
lastRenderedReducer: basicStateReducer,
lastRenderedState: snapshot
};
newQueue.dispatch = setSnapshot = dispatchAction.bind(null, currentlyRenderingFiber$1, newQueue), stateHook.queue = newQueue, stateHook.baseQueue = null, stateHook.memoizedState = stateHook.baseState = snapshot = readFromUnsubcribedMutableSource(root, source, getSnapshot);
}
return snapshot;
}
function mountMutableSource(source, getSnapshot, subscribe) {
var hook = mountWorkInProgressHook();
return hook.memoizedState = {
refs: {
getSnapshot: getSnapshot,
setSnapshot: null
},
source: source,
subscribe: subscribe
}, useMutableSource(hook, source, getSnapshot, subscribe);
}
function updateMutableSource(source, getSnapshot, subscribe) {
return useMutableSource(updateWorkInProgressHook(), source, getSnapshot, subscribe);
}
function mountState(initialState) {
var hook = mountWorkInProgressHook();
"function" == typeof initialState && // $FlowFixMe: Flow doesn't like mixed types
(initialState = initialState()), hook.memoizedState = hook.baseState = initialState;
var queue = hook.queue = {
pending: null,
dispatch: null,
lastRenderedReducer: basicStateReducer,
lastRenderedState: initialState
}, dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
return [
hook.memoizedState,
dispatch
];
}
function pushEffect(tag, create, destroy, deps) {
var effect = {
tag: tag,
create: create,
destroy: destroy,
deps: deps,
// Circular
next: null
}, componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
if (null === componentUpdateQueue) componentUpdateQueue = {
lastEffect: null
}, currentlyRenderingFiber$1.updateQueue = componentUpdateQueue, componentUpdateQueue.lastEffect = effect.next = effect;
else {
var lastEffect = componentUpdateQueue.lastEffect;
if (null === lastEffect) componentUpdateQueue.lastEffect = effect.next = effect;
else {
var firstEffect = lastEffect.next;
lastEffect.next = effect, effect.next = firstEffect, componentUpdateQueue.lastEffect = effect;
}
}
return effect;
}
function mountRef(initialValue) {
var hook = mountWorkInProgressHook(), ref = {
current: initialValue
};
return Object.seal(ref), hook.memoizedState = ref, ref;
}
function updateRef(initialValue) {
return updateWorkInProgressHook().memoizedState;
}
function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
var hook = mountWorkInProgressHook();
currentlyRenderingFiber$1.flags |= fiberFlags, hook.memoizedState = pushEffect(/* */ 1 | hookFlags, create, void 0, void 0 === deps ? null : deps);
}
function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
var hook = updateWorkInProgressHook(), nextDeps = void 0 === deps ? null : deps, destroy = void 0;
if (null !== currentHook) {
var prevEffect = currentHook.memoizedState;
if (destroy = prevEffect.destroy, null !== nextDeps && areHookInputsEqual(nextDeps, prevEffect.deps)) {
pushEffect(hookFlags, create, destroy, nextDeps);
return;
}
}
currentlyRenderingFiber$1.flags |= fiberFlags, hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, nextDeps);
}
function mountEffect(create, deps) {
return "undefined" != typeof jest && warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1), mountEffectImpl(516, /* */ 4, create, deps);
}
function updateEffect(create, deps) {
return "undefined" != typeof jest && warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1), updateEffectImpl(516, 4, create, deps);
}
function mountLayoutEffect(create, deps) {
return mountEffectImpl(4, /* */ 2, create, deps);
}
function updateLayoutEffect(create, deps) {
return updateEffectImpl(4, 2, create, deps);
}
function imperativeHandleEffect(create, ref) {
return "function" == typeof ref ? (ref(create()), function() {
ref(null);
}) : null != ref ? (ref.hasOwnProperty("current") || error("Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(ref).join(", ") + "}"), ref.current = create(), function() {
ref.current = null;
}) : void 0;
}
function mountImperativeHandle(ref, create, deps) {
"function" != typeof create && error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
var effectDeps = null != deps ? deps.concat([
ref
]) : null;
return mountEffectImpl(4, 2, imperativeHandleEffect.bind(null, create, ref), effectDeps);
}
function updateImperativeHandle(ref, create, deps) {
"function" != typeof create && error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
var effectDeps = null != deps ? deps.concat([
ref
]) : null;
return updateEffectImpl(4, 2, imperativeHandleEffect.bind(null, create, ref), effectDeps);
}
function mountDebugValue(value, formatterFn) {
// This hook is normally a no-op.
// The react-debug-hooks package injects its own implementation
// so that e.g. DevTools can display custom hook values.
}
function mountCallback(callback, deps) {
return mountWorkInProgressHook().memoizedState = [
callback,
void 0 === deps ? null : deps
], callback;
}
function updateCallback(callback, deps) {
var hook = updateWorkInProgressHook(), nextDeps = void 0 === deps ? null : deps, prevState = hook.memoizedState;
return null !== prevState && null !== nextDeps && areHookInputsEqual(nextDeps, prevState[1]) ? prevState[0] : (hook.memoizedState = [
callback,
nextDeps
], callback);
}
function mountMemo(nextCreate, deps) {
var hook = mountWorkInProgressHook(), nextValue = nextCreate();
return hook.memoizedState = [
nextValue,
void 0 === deps ? null : deps
], nextValue;
}
function updateMemo(nextCreate, deps) {
var hook = updateWorkInProgressHook(), nextDeps = void 0 === deps ? null : deps, prevState = hook.memoizedState;
if (null !== prevState && null !== nextDeps && areHookInputsEqual(nextDeps, prevState[1])) return prevState[0];
var nextValue = nextCreate();
return hook.memoizedState = [
nextValue,
nextDeps
], nextValue;
}
function mountDeferredValue(value) {
var _mountState = mountState(value), prevValue = _mountState[0], setValue = _mountState[1];
return mountEffect(function() {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally{
ReactCurrentBatchConfig$1.transition = prevTransition;
}
}, [
value
]), prevValue;
}
function updateDeferredValue(value) {
var _updateState = updateReducer(basicStateReducer), prevValue = _updateState[0], setValue = _updateState[1];
return updateEffect(function() {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally{
ReactCurrentBatchConfig$1.transition = prevTransition;
}
}, [
value
]), prevValue;
}
function rerenderDeferredValue(value) {
var _rerenderState = rerenderReducer(basicStateReducer), prevValue = _rerenderState[0], setValue = _rerenderState[1];
return updateEffect(function() {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setValue(value);
} finally{
ReactCurrentBatchConfig$1.transition = prevTransition;
}
}, [
value
]), prevValue;
}
function startTransition(setPending, callback) {
var priorityLevel = getCurrentPriorityLevel();
runWithPriority$1(priorityLevel < 98 ? 98 : priorityLevel, function() {
setPending(!0);
}), runWithPriority$1(priorityLevel > 97 ? 97 : priorityLevel, function() {
var prevTransition = ReactCurrentBatchConfig$1.transition;
ReactCurrentBatchConfig$1.transition = 1;
try {
setPending(!1), callback();
} finally{
ReactCurrentBatchConfig$1.transition = prevTransition;
}
});
}
function mountTransition() {
var _mountState2 = mountState(!1), isPending = _mountState2[0], setPending = _mountState2[1], start = startTransition.bind(null, setPending); // The `start` method can be stored on a ref, since `setPending`
return mountRef(start), [
start,
isPending
];
}
function updateTransition() {
var isPending = updateReducer(basicStateReducer)[0];
return [
updateRef().current,
isPending
];
}
function rerenderTransition() {
var isPending = rerenderReducer(basicStateReducer)[0];
return [
updateRef().current,
isPending
];
}
var isUpdatingOpaqueValueInRenderPhase = !1;
function warnOnOpaqueIdentifierAccessInDEV(fiber) {
// TODO: Should warn in effects and callbacks, too
var name = getComponentName(fiber.type) || "Unknown";
isRendering && !didWarnAboutUseOpaqueIdentifier[name] && (error("The object passed back from useOpaqueIdentifier is meant to be passed through to attributes only. Do not read the value directly."), didWarnAboutUseOpaqueIdentifier[name] = !0);
}
function mountOpaqueIdentifier() {
var makeId = makeClientIdInDEV.bind(null, warnOnOpaqueIdentifierAccessInDEV.bind(null, currentlyRenderingFiber$1));
if (isHydrating) {
var attemptToReadValue, didUpgrade = !1, fiber = currentlyRenderingFiber$1, id = {
$$typeof: REACT_OPAQUE_ID_TYPE,
toString: attemptToReadValue = function() {
throw didUpgrade || (// Only upgrade once. This works even inside the render phase because
// the update is added to a shared queue, which outlasts the
// in-progress render.
didUpgrade = !0, isUpdatingOpaqueValueInRenderPhase = !0, setId(makeId()), isUpdatingOpaqueValueInRenderPhase = !1, warnOnOpaqueIdentifierAccessInDEV(fiber)), Error("The object passed back from useOpaqueIdentifier is meant to be passed through to attributes only. Do not read the value directly.");
},
valueOf: attemptToReadValue
}, setId = mountState(id)[1];
return (2 & currentlyRenderingFiber$1.mode) == 0 && (currentlyRenderingFiber$1.flags |= 516, pushEffect(5, function() {
setId(makeId());
}, void 0, null)), id;
}
var _id = makeId();
return mountState(_id), _id;
}
function updateOpaqueIdentifier() {
return updateReducer(basicStateReducer)[0];
}
function rerenderOpaqueIdentifier() {
return rerenderReducer(basicStateReducer)[0];
}
function dispatchAction(fiber, queue, action) {
"function" == typeof arguments[3] && error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
var eventTime = requestEventTime(), lane = requestUpdateLane(fiber), update = {
lane: lane,
action: action,
eagerReducer: null,
eagerState: null,
next: null
}, pending = queue.pending;
null === pending ? // This is the first update. Create a circular list.
update.next = update : (update.next = pending.next, pending.next = update), queue.pending = update;
var alternate = fiber.alternate;
if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) // This is a render phase update. Stash it in a lazily-created map of
// queue -> linked list of updates. After this render pass, we'll restart
// and apply the stashed updates on top of the work-in-progress hook.
didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = !0;
else {
if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes)) {
// The queue is currently empty, which means we can eagerly compute the
// next state before entering the render phase. If the new state is the
// same as the current state, we may be able to bail out entirely.
var prevDispatcher, lastRenderedReducer = queue.lastRenderedReducer;
if (null !== lastRenderedReducer) {
prevDispatcher = ReactCurrentDispatcher$1.current, ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
var currentState = queue.lastRenderedState, eagerState = lastRenderedReducer(currentState, action);
if (// it, on the update object. If the reducer hasn't changed by the
// time we enter the render phase, then the eager state can be used
// without calling the reducer again.
update.eagerReducer = lastRenderedReducer, update.eagerState = eagerState, objectIs(eagerState, currentState)) // Fast path. We can bail out without scheduling React to re-render.
// It's still possible that we'll need to rebase this update later,
// if the component re-renders for a different reason and by that
// time the reducer has changed.
return;
} catch (error) {
// Suppress the error. It will throw again in the render phase.
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
}
}
"undefined" != typeof jest && (warnIfNotScopedWithMatchingAct(fiber), warnIfNotCurrentlyActingUpdatesInDev(fiber)), scheduleUpdateOnFiber(fiber, lane, eventTime);
}
}
var ContextOnlyDispatcher = {
readContext: readContext,
useCallback: throwInvalidHookError,
useContext: throwInvalidHookError,
useEffect: throwInvalidHookError,
useImperativeHandle: throwInvalidHookError,
useLayoutEffect: throwInvalidHookError,
useMemo: throwInvalidHookError,
useReducer: throwInvalidHookError,
useRef: throwInvalidHookError,
useState: throwInvalidHookError,
useDebugValue: throwInvalidHookError,
useDeferredValue: throwInvalidHookError,
useTransition: throwInvalidHookError,
useMutableSource: throwInvalidHookError,
useOpaqueIdentifier: throwInvalidHookError,
unstable_isNewReconciler: !1
}, HooksDispatcherOnMountInDEV = null, HooksDispatcherOnMountWithHookTypesInDEV = null, HooksDispatcherOnUpdateInDEV = null, HooksDispatcherOnRerenderInDEV = null, InvalidNestedHooksDispatcherOnMountInDEV = null, InvalidNestedHooksDispatcherOnUpdateInDEV = null, InvalidNestedHooksDispatcherOnRerenderInDEV = null, warnInvalidContextAccess = function() {
error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
}, warnInvalidHookAccess = function() {
error("Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://reactjs.org/link/rules-of-hooks");
};
HooksDispatcherOnMountInDEV = {
readContext: function(context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", mountHookTypesDev(), checkDepsAreArrayDev(deps), mountCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", mountHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", mountHookTypesDev(), checkDepsAreArrayDev(deps), mountEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", mountHookTypesDev(), checkDepsAreArrayDev(deps), mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", mountHookTypesDev(), checkDepsAreArrayDev(deps), mountLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", mountHookTypesDev(), checkDepsAreArrayDev(deps);
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", mountHookTypesDev(), mountRef(initialValue);
},
useState: function(initialState) {
currentHookNameInDev = "useState", mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", mountHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", mountHookTypesDev(), mountDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", mountHookTypesDev(), mountTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", mountHookTypesDev(), mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", mountHookTypesDev(), mountOpaqueIdentifier();
},
unstable_isNewReconciler: !1
}, HooksDispatcherOnMountWithHookTypesInDEV = {
readContext: function(context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", updateHookTypesDev(), mountCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", updateHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", updateHookTypesDev(), mountEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", updateHookTypesDev(), mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", updateHookTypesDev(), mountLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", updateHookTypesDev(), mountRef(initialValue);
},
useState: function(initialState) {
currentHookNameInDev = "useState", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", updateHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", updateHookTypesDev(), mountDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", updateHookTypesDev(), mountTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", updateHookTypesDev(), mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", updateHookTypesDev(), mountOpaqueIdentifier();
},
unstable_isNewReconciler: !1
}, HooksDispatcherOnUpdateInDEV = {
readContext: function(context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", updateHookTypesDev(), updateCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", updateHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", updateHookTypesDev(), updateEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", updateHookTypesDev(), updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", updateHookTypesDev(), updateLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", updateHookTypesDev(), updateRef();
},
useState: function(initialState) {
currentHookNameInDev = "useState", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(basicStateReducer);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", updateHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", updateHookTypesDev(), updateDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", updateHookTypesDev(), updateTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", updateHookTypesDev(), updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", updateHookTypesDev(), updateReducer(basicStateReducer)[0];
},
unstable_isNewReconciler: !1
}, HooksDispatcherOnRerenderInDEV = {
readContext: function(context, observedBits) {
return readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", updateHookTypesDev(), updateCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", updateHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", updateHookTypesDev(), updateEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", updateHookTypesDev(), updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", updateHookTypesDev(), updateLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return updateMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return rerenderReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", updateHookTypesDev(), updateRef();
},
useState: function(initialState) {
currentHookNameInDev = "useState", updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnRerenderInDEV;
try {
return rerenderReducer(basicStateReducer);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", updateHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", updateHookTypesDev(), rerenderDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", updateHookTypesDev(), rerenderTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", updateHookTypesDev(), updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", updateHookTypesDev(), rerenderReducer(basicStateReducer)[0];
},
unstable_isNewReconciler: !1
}, InvalidNestedHooksDispatcherOnMountInDEV = {
readContext: function(context, observedBits) {
return warnInvalidContextAccess(), readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", warnInvalidHookAccess(), mountHookTypesDev(), mountCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", warnInvalidHookAccess(), mountHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", warnInvalidHookAccess(), mountHookTypesDev(), mountEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", warnInvalidHookAccess(), mountHookTypesDev(), mountImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", warnInvalidHookAccess(), mountHookTypesDev(), mountLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", warnInvalidHookAccess(), mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", warnInvalidHookAccess(), mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", warnInvalidHookAccess(), mountHookTypesDev(), mountRef(initialValue);
},
useState: function(initialState) {
currentHookNameInDev = "useState", warnInvalidHookAccess(), mountHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
try {
return mountState(initialState);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", warnInvalidHookAccess(), mountHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", warnInvalidHookAccess(), mountHookTypesDev(), mountDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", warnInvalidHookAccess(), mountHookTypesDev(), mountTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", warnInvalidHookAccess(), mountHookTypesDev(), mountMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", warnInvalidHookAccess(), mountHookTypesDev(), mountOpaqueIdentifier();
},
unstable_isNewReconciler: !1
}, InvalidNestedHooksDispatcherOnUpdateInDEV = {
readContext: function(context, observedBits) {
return warnInvalidContextAccess(), readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", warnInvalidHookAccess(), updateHookTypesDev(), updateCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", warnInvalidHookAccess(), updateHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", warnInvalidHookAccess(), updateHookTypesDev(), updateEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", warnInvalidHookAccess(), updateHookTypesDev(), updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", warnInvalidHookAccess(), updateHookTypesDev(), updateLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", warnInvalidHookAccess(), updateHookTypesDev(), updateRef();
},
useState: function(initialState) {
currentHookNameInDev = "useState", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateReducer(basicStateReducer);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", warnInvalidHookAccess(), updateHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", warnInvalidHookAccess(), updateHookTypesDev(), updateDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", warnInvalidHookAccess(), updateHookTypesDev(), updateTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", warnInvalidHookAccess(), updateHookTypesDev(), updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", warnInvalidHookAccess(), updateHookTypesDev(), updateReducer(basicStateReducer)[0];
},
unstable_isNewReconciler: !1
}, InvalidNestedHooksDispatcherOnRerenderInDEV = {
readContext: function(context, observedBits) {
return warnInvalidContextAccess(), readContext(context, observedBits);
},
useCallback: function(callback, deps) {
return currentHookNameInDev = "useCallback", warnInvalidHookAccess(), updateHookTypesDev(), updateCallback(callback, deps);
},
useContext: function(context, observedBits) {
return currentHookNameInDev = "useContext", warnInvalidHookAccess(), updateHookTypesDev(), readContext(context, observedBits);
},
useEffect: function(create, deps) {
return currentHookNameInDev = "useEffect", warnInvalidHookAccess(), updateHookTypesDev(), updateEffect(create, deps);
},
useImperativeHandle: function(ref, create, deps) {
return currentHookNameInDev = "useImperativeHandle", warnInvalidHookAccess(), updateHookTypesDev(), updateImperativeHandle(ref, create, deps);
},
useLayoutEffect: function(create, deps) {
return currentHookNameInDev = "useLayoutEffect", warnInvalidHookAccess(), updateHookTypesDev(), updateLayoutEffect(create, deps);
},
useMemo: function(create, deps) {
currentHookNameInDev = "useMemo", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return updateMemo(create, deps);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useReducer: function(reducer, initialArg, init) {
currentHookNameInDev = "useReducer", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return rerenderReducer(reducer, initialArg, init);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useRef: function(initialValue) {
return currentHookNameInDev = "useRef", warnInvalidHookAccess(), updateHookTypesDev(), updateRef();
},
useState: function(initialState) {
currentHookNameInDev = "useState", warnInvalidHookAccess(), updateHookTypesDev();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
try {
return rerenderReducer(basicStateReducer);
} finally{
ReactCurrentDispatcher$1.current = prevDispatcher;
}
},
useDebugValue: function(value, formatterFn) {
return currentHookNameInDev = "useDebugValue", warnInvalidHookAccess(), updateHookTypesDev(), mountDebugValue();
},
useDeferredValue: function(value) {
return currentHookNameInDev = "useDeferredValue", warnInvalidHookAccess(), updateHookTypesDev(), rerenderDeferredValue(value);
},
useTransition: function() {
return currentHookNameInDev = "useTransition", warnInvalidHookAccess(), updateHookTypesDev(), rerenderTransition();
},
useMutableSource: function(source, getSnapshot, subscribe) {
return currentHookNameInDev = "useMutableSource", warnInvalidHookAccess(), updateHookTypesDev(), updateMutableSource(source, getSnapshot, subscribe);
},
useOpaqueIdentifier: function() {
return currentHookNameInDev = "useOpaqueIdentifier", warnInvalidHookAccess(), updateHookTypesDev(), rerenderReducer(basicStateReducer)[0];
},
unstable_isNewReconciler: !1
};
var commitTime = 0, profilerStartTime = -1;
function startProfilerTimer(fiber) {
profilerStartTime = unstable_now(), fiber.actualStartTime < 0 && (fiber.actualStartTime = unstable_now());
}
function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
if (profilerStartTime >= 0) {
var elapsedTime = unstable_now() - profilerStartTime;
fiber.actualDuration += elapsedTime, overrideBaseTime && (fiber.selfBaseDuration = elapsedTime), profilerStartTime = -1;
}
}
function transferActualDuration(fiber) {
for(// Transfer time spent rendering these children so we don't lose it
// after we rerender. This is used as a helper in special cases
// where we should count the work of multiple passes.
var child = fiber.child; child;)fiber.actualDuration += child.actualDuration, child = child.sibling;
}
var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner, didReceiveUpdate = !1;
function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
null === current ? // If this is a fresh new component that hasn't been rendered yet, we
// won't update its child set by applying minimal side-effects. Instead,
// we will add them all to the child before it gets rendered. That means
// we can optimize this reconciliation pass by not tracking side-effects.
workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes) : // If the current child is the same as the work in progress, it means that
// we haven't yet started any work on these children. Therefore, we use
// the clone algorithm to create a copy of all the current children.
// If we had any progressed work already, that is invalid at this point so
// let's throw it out.
workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
}
function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var nextChildren, innerPropTypes = Component.propTypes;
innerPropTypes && checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component));
}
var render = Component.render, ref = workInProgress.ref;
if (prepareToReadContext(workInProgress, renderLanes), ReactCurrentOwner$1.current = workInProgress, isRendering = !0, nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes), 1 & workInProgress.mode) {
disableLogs();
try {
nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);
} finally{
reenableLogs();
}
}
return (isRendering = !1, null === current || didReceiveUpdate) ? (workInProgress.flags |= /* */ 1, reconcileChildren(current, workInProgress, nextChildren, renderLanes), workInProgress.child) : (bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)) // React DevTools reads this flag.
;
}
function updateMemoComponent(current, workInProgress, Component, nextProps, updateLanes, renderLanes) {
if (null === current) {
var type, type1 = Component.type;
if ("function" == typeof (type = type1) && !shouldConstruct$1(type) && void 0 === type.defaultProps && null === Component.compare && // SimpleMemoComponent codepath doesn't resolve outer props either.
void 0 === Component.defaultProps) {
var resolvedType = type1;
return resolvedType = resolveFunctionForHotReloading(type1), // and with only the default shallow comparison, we upgrade it
// to a SimpleMemoComponent to allow fast path updates.
workInProgress.tag = 15, workInProgress.type = resolvedType, validateFunctionComponentInDev(workInProgress, type1), updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, updateLanes, renderLanes);
}
var innerPropTypes = type1.propTypes;
innerPropTypes && // Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type1));
var child = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);
return child.ref = workInProgress.ref, child.return = workInProgress, workInProgress.child = child, child;
}
var _type = Component.type, _innerPropTypes = _type.propTypes;
_innerPropTypes && // Inner memo component props aren't currently validated in createElement.
// We could move it there, but we'd still need this for lazy code path.
checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type));
var currentChild = current.child; // This is always exactly one child
if ((updateLanes & renderLanes) == 0) {
// This will be the props with resolved defaultProps,
// unlike current.memoizedProps which will be the unresolved ones.
var prevProps = currentChild.memoizedProps, compare = Component.compare; // Default to shallow comparison
if ((compare = null !== compare ? compare : shallowEqual)(prevProps, nextProps) && current.ref === workInProgress.ref) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
} // React DevTools reads this flag.
workInProgress.flags |= 1;
var newChild = createWorkInProgress(currentChild, nextProps);
return newChild.ref = workInProgress.ref, newChild.return = workInProgress, workInProgress.child = newChild, newChild;
}
function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, updateLanes, renderLanes) {
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var outerMemoType = workInProgress.elementType;
if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
// We warn when you define propTypes on lazy()
// so let's just skip over it to find memo() outer wrapper.
// Inner props for memo are validated later.
var lazyComponent = outerMemoType, payload = lazyComponent._payload, init = lazyComponent._init;
try {
outerMemoType = init(payload);
} catch (x) {
outerMemoType = null;
} // Inner propTypes will be validated in the function component path.
var outerPropTypes = outerMemoType && outerMemoType.propTypes;
outerPropTypes && checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType));
}
}
if (null !== current && shallowEqual(current.memoizedProps, nextProps) && current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
workInProgress.type === current.type) {
if (didReceiveUpdate = !1, (renderLanes & updateLanes) == 0) return(// The pending lanes were cleared at the beginning of beginWork. We're
// about to bail out, but there might be other lanes that weren't
// included in the current render. Usually, the priority level of the
// remaining updates is accumlated during the evaluation of the
// component (i.e. when processing the update queue). But since since
// we're bailing out early *without* evaluating the component, we need
// to account for it here, too. Reset to the value of the current fiber.
// NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
// because a MemoComponent fiber does not have hooks or an update queue;
// rather, it wraps around an inner component, which may or may not
// contains hooks.
// TODO: Move the reset at in beginWork out of the common path so that
// this is no longer necessary.
workInProgress.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes));
(/* */ 16384 & current.flags) != 0 && // This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
(didReceiveUpdate = !0);
}
return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
}
function updateOffscreenComponent(current, workInProgress, renderLanes) {
var nextBaseLanes, _subtreeRenderLanes, nextProps = workInProgress.pendingProps, nextChildren = nextProps.children, prevState = null !== current ? current.memoizedState : null;
if ("hidden" === nextProps.mode || "unstable-defer-without-hiding" === nextProps.mode) {
if ((4 & workInProgress.mode) == 0) workInProgress.memoizedState = {
baseLanes: 0
}, pushRenderLanes(workInProgress, renderLanes);
else {
if ((1073741824 & renderLanes) == 0) return nextBaseLanes = null !== prevState ? prevState.baseLanes | renderLanes : renderLanes, markSpawnedWork(1073741824), workInProgress.lanes = workInProgress.childLanes = 1073741824, workInProgress.memoizedState = {
baseLanes: nextBaseLanes
}, // to avoid a push/pop misalignment.
pushRenderLanes(workInProgress, nextBaseLanes), null;
else workInProgress.memoizedState = {
baseLanes: 0
}, pushRenderLanes(workInProgress, null !== prevState ? prevState.baseLanes : renderLanes);
}
} else null !== prevState ? (_subtreeRenderLanes = prevState.baseLanes | renderLanes, workInProgress.memoizedState = null) : // We weren't previously hidden, and we still aren't, so there's nothing
// special to do. Need to push to the stack regardless, though, to avoid
// a push/pop misalignment.
_subtreeRenderLanes = renderLanes, pushRenderLanes(workInProgress, _subtreeRenderLanes);
return reconcileChildren(current, workInProgress, nextChildren, renderLanes), workInProgress.child;
} // Note: These happen to have identical begin phases, for now. We shouldn't hold
function markRef(current, workInProgress) {
var ref = workInProgress.ref;
(null === current && null !== ref || null !== current && current.ref !== ref) && // Schedule a Ref effect
(workInProgress.flags |= /* */ 128);
}
function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var context, nextChildren, innerPropTypes = Component.propTypes;
innerPropTypes && checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component));
}
var unmaskedContext = getUnmaskedContext(workInProgress, Component, !0);
if (context = getMaskedContext(workInProgress, unmaskedContext), prepareToReadContext(workInProgress, renderLanes), ReactCurrentOwner$1.current = workInProgress, isRendering = !0, nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes), 1 & workInProgress.mode) {
disableLogs();
try {
nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);
} finally{
reenableLogs();
}
}
return (isRendering = !1, null === current || didReceiveUpdate) ? (workInProgress.flags |= 1, reconcileChildren(current, workInProgress, nextChildren, renderLanes), workInProgress.child) : (bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)) // React DevTools reads this flag.
;
}
function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
if (workInProgress.type !== workInProgress.elementType) {
// Lazy component props can't be validated in createElement
// because they're only guaranteed to be resolved here.
var hasContext, shouldUpdate, innerPropTypes = Component.propTypes;
innerPropTypes && checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component));
}
isContextProvider(Component) ? (hasContext = !0, pushContextProvider(workInProgress)) : hasContext = !1, prepareToReadContext(workInProgress, renderLanes), null === workInProgress.stateNode ? (null !== current && (// A class component without an instance only mounts if it suspended
// inside a non-concurrent tree, in an inconsistent state. We want to
// treat it like a new mount, even though an empty version of it already
// committed. Disconnect the alternate pointers.
current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2), constructClassInstance(workInProgress, Component, nextProps), mountClassInstance(workInProgress, Component, nextProps, renderLanes), shouldUpdate = !0) : // In a resume, we'll already have an instance we can reuse.
shouldUpdate = null === current ? function(workInProgress, ctor, newProps, renderLanes) {
var instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps;
instance.props = oldProps;
var oldContext = instance.context, contextType = ctor.contextType, nextContext = emptyContextObject;
if ("object" == typeof contextType && null !== contextType) nextContext = readContext(contextType);
else {
var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, !0);
nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
}
var getDerivedStateFromProps = ctor.getDerivedStateFromProps, hasNewLifecycles = "function" == typeof getDerivedStateFromProps || "function" == typeof instance.getSnapshotBeforeUpdate;
hasNewLifecycles || "function" != typeof instance.UNSAFE_componentWillReceiveProps && "function" != typeof instance.componentWillReceiveProps || oldProps === newProps && oldContext === nextContext || callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext), hasForceUpdate = !1;
var oldState = workInProgress.memoizedState, newState = instance.state = oldState;
if (processUpdateQueue(workInProgress, newProps, instance, renderLanes), newState = workInProgress.memoizedState, oldProps === newProps && oldState === newState && !hasContextChanged() && !hasForceUpdate) return "function" == typeof instance.componentDidMount && (workInProgress.flags |= 4), !1;
"function" == typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps), newState = workInProgress.memoizedState);
var shouldUpdate = hasForceUpdate || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
return shouldUpdate ? (hasNewLifecycles || "function" != typeof instance.UNSAFE_componentWillMount && "function" != typeof instance.componentWillMount || ("function" == typeof instance.componentWillMount && instance.componentWillMount(), "function" == typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" == typeof instance.componentDidMount && (workInProgress.flags |= 4)) : ("function" == typeof instance.componentDidMount && (workInProgress.flags |= 4), // memoized state to indicate that this work can be reused.
workInProgress.memoizedProps = newProps, workInProgress.memoizedState = newState), // if shouldComponentUpdate returns false.
instance.props = newProps, instance.state = newState, instance.context = nextContext, shouldUpdate;
} // Invokes the update life-cycles and returns false if it shouldn't rerender.
(workInProgress, Component, nextProps, renderLanes) : function(current, workInProgress, ctor, newProps, renderLanes) {
var instance = workInProgress.stateNode;
cloneUpdateQueue(current, workInProgress);
var unresolvedOldProps = workInProgress.memoizedProps, oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
instance.props = oldProps;
var unresolvedNewProps = workInProgress.pendingProps, oldContext = instance.context, contextType = ctor.contextType, nextContext = emptyContextObject;
if ("object" == typeof contextType && null !== contextType) nextContext = readContext(contextType);
else {
var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, !0);
nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
}
var getDerivedStateFromProps = ctor.getDerivedStateFromProps, hasNewLifecycles = "function" == typeof getDerivedStateFromProps || "function" == typeof instance.getSnapshotBeforeUpdate;
hasNewLifecycles || "function" != typeof instance.UNSAFE_componentWillReceiveProps && "function" != typeof instance.componentWillReceiveProps || unresolvedOldProps === unresolvedNewProps && oldContext === nextContext || callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext), hasForceUpdate = !1;
var oldState = workInProgress.memoizedState, newState = instance.state = oldState;
if (processUpdateQueue(workInProgress, newProps, instance, renderLanes), newState = workInProgress.memoizedState, unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !hasForceUpdate) return "function" == typeof instance.componentDidUpdate && (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) && (workInProgress.flags |= 4), "function" == typeof instance.getSnapshotBeforeUpdate && (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) && (workInProgress.flags |= /* */ 256), !1;
"function" == typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps), newState = workInProgress.memoizedState);
var shouldUpdate = hasForceUpdate || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
return shouldUpdate ? (hasNewLifecycles || "function" != typeof instance.UNSAFE_componentWillUpdate && "function" != typeof instance.componentWillUpdate || ("function" == typeof instance.componentWillUpdate && instance.componentWillUpdate(newProps, newState, nextContext), "function" == typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext)), "function" == typeof instance.componentDidUpdate && (workInProgress.flags |= 4), "function" == typeof instance.getSnapshotBeforeUpdate && (workInProgress.flags |= 256)) : ("function" == typeof instance.componentDidUpdate && (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) && (workInProgress.flags |= 4), "function" == typeof instance.getSnapshotBeforeUpdate && (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) && (workInProgress.flags |= 256), // memoized props/state to indicate that this work can be reused.
workInProgress.memoizedProps = newProps, workInProgress.memoizedState = newState), // if shouldComponentUpdate returns false.
instance.props = newProps, instance.state = newState, instance.context = nextContext, shouldUpdate;
}(current, workInProgress, Component, nextProps, renderLanes);
var nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes), inst = workInProgress.stateNode;
return shouldUpdate && inst.props !== nextProps && (didWarnAboutReassigningProps || error("It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component"), didWarnAboutReassigningProps = !0), nextUnitOfWork;
}
function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
// Refs should update even if shouldComponentUpdate returns false
markRef(current, workInProgress);
var nextChildren, nextChildren1, didCaptureError = (64 & workInProgress.flags) != 0;
if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
var instance = workInProgress.stateNode; // Rerender
if (ReactCurrentOwner$1.current = workInProgress, didCaptureError && "function" != typeof Component.getDerivedStateFromError) // If we captured an error, but getDerivedStateFromError is not defined,
// unmount all the children. componentDidCatch will schedule an update to
// re-render a fallback. This is temporary until we migrate everyone to
// the new API.
// TODO: Warn in a future release.
nextChildren1 = null, profilerStartTime = -1;
else {
if (isRendering = !0, nextChildren1 = instance.render(), 1 & workInProgress.mode) {
disableLogs();
try {
instance.render();
} finally{
reenableLogs();
}
}
isRendering = !1;
} // React DevTools reads this flag.
return (workInProgress.flags |= 1, null !== current && didCaptureError) ? (nextChildren = nextChildren1, // This function is fork of reconcileChildren. It's used in cases where we
// want to reconcile without matching against the existing set. This has the
// effect of all current children being unmounted; even if the type and key
// are the same, the old child is unmounted and a new child is created.
//
// To do this, we're going to go through the reconcile algorithm twice. In
// the first pass, we schedule a deletion for all the current children by
// passing null.
workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes), // pass null in place of where we usually pass the current child set. This has
// the effect of remounting all children regardless of whether their
// identities match.
workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes)) : reconcileChildren(current, workInProgress, nextChildren1, renderLanes), // TODO: Restructure so we never read values from the instance.
workInProgress.memoizedState = instance.state, hasContext && invalidateContextProvider(workInProgress, Component, !0), workInProgress.child;
}
function pushHostRootContext(workInProgress) {
var root = workInProgress.stateNode;
root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && // Should always be set
pushTopLevelContextObject(workInProgress, root.context, !1), pushHostContainer(workInProgress, root.containerInfo);
}
function validateFunctionComponentInDev(workInProgress, Component) {
if (Component && Component.childContextTypes && error("%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component"), null !== workInProgress.ref) {
var info = "", ownerName = getCurrentFiberOwnerNameInDevOrNull();
ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`.");
var warningKey = ownerName || workInProgress._debugID || "", debugSource = workInProgress._debugSource;
debugSource && (warningKey = debugSource.fileName + ":" + debugSource.lineNumber), didWarnAboutFunctionRefs[warningKey] || (didWarnAboutFunctionRefs[warningKey] = !0, error("Function components cannot be given refs. Attempts to access this ref will fail. Did you mean to use React.forwardRef()?%s", info));
}
if ("function" == typeof Component.getDerivedStateFromProps) {
var _componentName3 = getComponentName(Component) || "Unknown";
didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] || (error("%s: Function components do not support getDerivedStateFromProps.", _componentName3), didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = !0);
}
if ("object" == typeof Component.contextType && null !== Component.contextType) {
var _componentName4 = getComponentName(Component) || "Unknown";
didWarnAboutContextTypeOnFunctionComponent[_componentName4] || (error("%s: Function components do not support contextType.", _componentName4), didWarnAboutContextTypeOnFunctionComponent[_componentName4] = !0);
}
}
didWarnAboutBadClass = {}, didWarnAboutModulePatternComponent = {}, didWarnAboutContextTypeOnFunctionComponent = {}, didWarnAboutGetDerivedStateOnFunctionComponent = {}, didWarnAboutFunctionRefs = {}, didWarnAboutReassigningProps = !1, didWarnAboutRevealOrder = {}, didWarnAboutTailOptions = {};
var SUSPENDED_MARKER = {
dehydrated: null,
retryLane: 0
};
function mountSuspenseOffscreenState(renderLanes) {
return {
baseLanes: renderLanes
};
}
function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
return {
baseLanes: prevOffscreenState.baseLanes | renderLanes
};
} // TODO: Probably should inline this back
function getRemainingWorkInPrimaryTree(current, renderLanes) {
// TODO: Should not remove render lanes that were pinged during this render
return current.childLanes & ~renderLanes;
}
function updateSuspenseComponent(current, workInProgress, renderLanes) {
var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
shouldSuspendImpl(workInProgress) && (workInProgress.flags |= 64);
var suspenseContext = suspenseStackCursor.current, showFallback = !1;
if ((64 & workInProgress.flags) == 0 && (suspenseContext1 = suspenseContext, // If we're already showing a fallback, there are cases where we need to
// remain on that fallback regardless of whether the content has resolved.
// For example, SuspenseList coordinates when nested content appears.
null !== (current1 = current) && null === current1.memoizedState ? 1 : (2 & suspenseContext1) == 0 // Not currently showing content. Consult the Suspense context.
)) // Attempting the main content
(null === current || null !== current.memoizedState) && void 0 !== nextProps.fallback && !0 !== nextProps.unstable_avoidThisFallback && (suspenseContext |= 1);
else // Something in this boundary's subtree already suspended. Switch to
// rendering the fallback children.
showFallback = !0, workInProgress.flags &= -65;
// boundary's children. This involves some custom reconcilation logic. Two
// main reasons this is so complicated.
//
// First, Legacy Mode has different semantics for backwards compatibility. The
// primary tree will commit in an inconsistent state, so when we do the
// second pass to render the fallback, we do some exceedingly, uh, clever
// hacks to make that not totally break. Like transferring effects and
// deletions from hidden tree. In Concurrent Mode, it's much simpler,
// because we bailout on the primary tree completely and leave it in its old
// state, no effects. Same as what we do for Offscreen (except that
// Offscreen doesn't have the first render pass).
//
// Second is hydration. During hydration, the Suspense fiber has a slightly
// different layout, where the child points to a dehydrated fragment, which
// contains the DOM rendered by the server.
//
// Third, even if you set all that aside, Suspense is like error boundaries in
// that we first we try to render one tree, and if that fails, we render again
// and switch to a different tree. Like a try/catch block. So we have to track
// which branch we're currently rendering. Ideally we would model this using
// a stack.
if (push(suspenseStackCursor, suspenseContext &= 1, workInProgress), null === current) {
// Initial mount
// If we're currently hydrating, try to hydrate this boundary.
// But only if this has a fallback.
void 0 !== nextProps.fallback && tryToClaimNextHydratableInstance(workInProgress);
var suspenseContext1, current1, workInProgress1, renderLanes1, workInProgress2, primaryChildren, renderLanes2, primaryChildFragment, nextPrimaryChildren = nextProps.children, nextFallbackChildren = nextProps.fallback;
if (showFallback) {
var fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
return workInProgress.child.memoizedState = mountSuspenseOffscreenState(renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, fallbackFragment;
}
if ("number" != typeof nextProps.unstable_expectedLoadTime) {
return workInProgress2 = workInProgress, primaryChildren = nextPrimaryChildren, renderLanes2 = renderLanes, (primaryChildFragment = createFiberFromOffscreen({
mode: "visible",
children: primaryChildren
}, workInProgress2.mode, renderLanes2, null)).return = workInProgress2, workInProgress2.child = primaryChildFragment, primaryChildFragment;
}
// This is a CPU-bound tree. Skip this tree and show a placeholder to
// unblock the surrounding content. Then immediately retry after the
// initial commit.
var _fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);
return workInProgress.child.memoizedState = mountSuspenseOffscreenState(renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, // get it started back up to attempt the next item. While in terms of
// priority this work has the same priority as this current render, it's
// not part of the same transition once the transition has committed. If
// it's sync, we still want to yield so that it can be painted.
// Conceptually, this is really the same as pinging. We can use any
// RetryLane even if it's the one currently rendering since we're leaving
// it behind on this node.
workInProgress.lanes = /* */ 33554432, markSpawnedWork(33554432), _fallbackFragment;
}
if (null !== current.memoizedState) {
if (showFallback) {
var _nextFallbackChildren2 = nextProps.fallback, _fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextProps.children, _nextFallbackChildren2, renderLanes), _primaryChildFragment3 = workInProgress.child, prevOffscreenState = current.child.memoizedState;
return _primaryChildFragment3.memoizedState = null === prevOffscreenState ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes), _primaryChildFragment3.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, _fallbackChildFragment;
}
var _primaryChildFragment4 = updateSuspensePrimaryChildren(current, workInProgress, nextProps.children, renderLanes);
return workInProgress.memoizedState = null, _primaryChildFragment4;
}
// The current tree is not already showing a fallback.
if (showFallback) {
// Timed out.
var _nextFallbackChildren3 = nextProps.fallback, _fallbackChildFragment2 = updateSuspenseFallbackChildren(current, workInProgress, nextProps.children, _nextFallbackChildren3, renderLanes), _primaryChildFragment5 = workInProgress.child, _prevOffscreenState = current.child.memoizedState;
return _primaryChildFragment5.memoizedState = null === _prevOffscreenState ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(_prevOffscreenState, renderLanes), _primaryChildFragment5.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes), // fallback children.
workInProgress.memoizedState = SUSPENDED_MARKER, _fallbackChildFragment2;
}
var _primaryChildFragment6 = updateSuspensePrimaryChildren(current, workInProgress, nextProps.children, renderLanes);
return workInProgress.memoizedState = null, _primaryChildFragment6;
}
function mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {
var primaryChildFragment, fallbackChildFragment, mode = workInProgress.mode, progressedPrimaryFragment = workInProgress.child, primaryChildProps = {
mode: "hidden",
children: primaryChildren
};
return (2 & mode) == 0 && null !== progressedPrimaryFragment ? (// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
(primaryChildFragment = progressedPrimaryFragment).childLanes = 0, primaryChildFragment.pendingProps = primaryChildProps, 8 & workInProgress.mode && (// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration = 0, primaryChildFragment.actualStartTime = -1, primaryChildFragment.selfBaseDuration = 0, primaryChildFragment.treeBaseDuration = 0)) : primaryChildFragment = createFiberFromOffscreen(primaryChildProps, mode, 0, null), fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null), primaryChildFragment.return = workInProgress, fallbackChildFragment.return = workInProgress, primaryChildFragment.sibling = fallbackChildFragment, workInProgress.child = primaryChildFragment, fallbackChildFragment;
}
function updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {
var currentPrimaryChildFragment = current.child, currentFallbackChildFragment = currentPrimaryChildFragment.sibling, primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, {
mode: "visible",
children: primaryChildren
});
return (2 & workInProgress.mode) == 0 && (primaryChildFragment.lanes = renderLanes), primaryChildFragment.return = workInProgress, primaryChildFragment.sibling = null, null !== currentFallbackChildFragment && (// Delete the fallback child fragment
currentFallbackChildFragment.nextEffect = null, currentFallbackChildFragment.flags = 8, workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChildFragment), workInProgress.child = primaryChildFragment, primaryChildFragment;
}
function updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {
var primaryChildFragment, fallbackChildFragment, mode = workInProgress.mode, currentPrimaryChildFragment = current.child, currentFallbackChildFragment = currentPrimaryChildFragment.sibling, primaryChildProps = {
mode: "hidden",
children: primaryChildren
};
if (// In legacy mode, we commit the primary tree as if it successfully
// completed, even though it's in an inconsistent state.
(2 & mode) == 0 && // Make sure we're on the second pass, i.e. the primary child fragment was
// already cloned. In legacy mode, the only case where this isn't true is
// when DevTools forces us to display a fallback; we skip the first render
// pass entirely and go straight to rendering the fallback. (In Concurrent
// Mode, SuspenseList can also trigger this scenario, but this is a legacy-
// only codepath.)
workInProgress.child !== currentPrimaryChildFragment) {
(primaryChildFragment = workInProgress.child).childLanes = 0, primaryChildFragment.pendingProps = primaryChildProps, 8 & workInProgress.mode && (// Reset the durations from the first pass so they aren't included in the
// final amounts. This seems counterintuitive, since we're intentionally
// not measuring part of the render phase, but this makes it match what we
// do in Concurrent Mode.
primaryChildFragment.actualDuration = 0, primaryChildFragment.actualStartTime = -1, primaryChildFragment.selfBaseDuration = currentPrimaryChildFragment.selfBaseDuration, primaryChildFragment.treeBaseDuration = currentPrimaryChildFragment.treeBaseDuration);
// However, since we're going to remain on the fallback, we no longer want
// to delete it. So we need to remove it from the list. Deletions are stored
// on the same list as effects. We want to keep the effects from the primary
// tree. So we copy the primary child fragment's effect list, which does not
// include the fallback deletion effect.
var progressedLastEffect = primaryChildFragment.lastEffect;
null !== progressedLastEffect ? (workInProgress.firstEffect = primaryChildFragment.firstEffect, workInProgress.lastEffect = progressedLastEffect, progressedLastEffect.nextEffect = null) : // TODO: Reset this somewhere else? Lol legacy mode is so weird.
workInProgress.firstEffect = workInProgress.lastEffect = null;
} else primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, primaryChildProps);
return null !== currentFallbackChildFragment ? fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren) : (fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null), // mounted but this is a new fiber.
fallbackChildFragment.flags |= 2), fallbackChildFragment.return = workInProgress, primaryChildFragment.return = workInProgress, primaryChildFragment.sibling = fallbackChildFragment, workInProgress.child = primaryChildFragment, fallbackChildFragment;
}
function scheduleWorkOnFiber(fiber, renderLanes) {
a = fiber.lanes, fiber.lanes = a | renderLanes;
var a, a1, alternate = fiber.alternate;
null !== alternate && (a1 = alternate.lanes, alternate.lanes = a1 | renderLanes), scheduleWorkOnParentPath(fiber.return, renderLanes);
}
function validateSuspenseListNestedChild(childSlot, index) {
var isArray = Array.isArray(childSlot), isIterable = !isArray && "function" == typeof getIteratorFn(childSlot);
if (isArray || isIterable) {
var type = isArray ? "array" : "iterable";
return error("A nested %s was passed to row #%s in <SuspenseList />. Wrap it in an additional SuspenseList to configure its revealOrder: <SuspenseList revealOrder=...> ... <SuspenseList revealOrder=...>{%s}</SuspenseList> ... </SuspenseList>", type, index, type), !1;
}
return !0;
}
function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode, lastEffectBeforeRendering) {
var renderState = workInProgress.memoizedState;
null === renderState ? workInProgress.memoizedState = {
isBackwards: isBackwards,
rendering: null,
renderingStartTime: 0,
last: lastContentRow,
tail: tail,
tailMode: tailMode,
lastEffect: lastEffectBeforeRendering
} : (// We can reuse the existing object from previous renders.
renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.lastEffect = lastEffectBeforeRendering);
} // This can end up rendering this component multiple passes.
// The first pass splits the children fibers into two sets. A head and tail.
// We first render the head. If anything is in fallback state, we do another
// pass through beginWork to rerender all children (including the tail) with
// the force suspend context. If the first render didn't have anything in
// in fallback state. Then we render each row in the tail one-by-one.
// That happens in the completeWork phase without going back to beginWork.
function updateSuspenseListComponent(current, workInProgress, renderLanes) {
var nextProps = workInProgress.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail, newChildren = nextProps.children;
!function(revealOrder) {
if (void 0 !== revealOrder && "forwards" !== revealOrder && "backwards" !== revealOrder && "together" !== revealOrder && !didWarnAboutRevealOrder[revealOrder]) {
if (didWarnAboutRevealOrder[revealOrder] = !0, "string" == typeof revealOrder) switch(revealOrder.toLowerCase()){
case "together":
case "forwards":
case "backwards":
error('"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.', revealOrder, revealOrder.toLowerCase());
break;
case "forward":
case "backward":
error('"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.', revealOrder, revealOrder.toLowerCase());
break;
default:
error('"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
}
else error('%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
}
}(revealOrder), void 0 === tailMode || didWarnAboutTailOptions[tailMode] || ("collapsed" !== tailMode && "hidden" !== tailMode ? (didWarnAboutTailOptions[tailMode] = !0, error('"%s" is not a supported value for tail on <SuspenseList />. Did you mean "collapsed" or "hidden"?', tailMode)) : "forwards" !== revealOrder && "backwards" !== revealOrder && (didWarnAboutTailOptions[tailMode] = !0, error('<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?', tailMode))), function(children, revealOrder) {
if (("forwards" === revealOrder || "backwards" === revealOrder) && null != children && !1 !== children) {
if (Array.isArray(children)) {
for(var i = 0; i < children.length; i++)if (!validateSuspenseListNestedChild(children[i], i)) return;
} else {
var iteratorFn = getIteratorFn(children);
if ("function" == typeof iteratorFn) {
var childrenIterator = iteratorFn.call(children);
if (childrenIterator) for(var step = childrenIterator.next(), _i = 0; !step.done; step = childrenIterator.next()){
if (!validateSuspenseListNestedChild(step.value, _i)) return;
_i++;
}
} else error('A single row was passed to a <SuspenseList revealOrder="%s" />. This is not useful since it needs multiple rows. Did you mean to pass multiple children or an array?', revealOrder);
}
}
}(newChildren, revealOrder), reconcileChildren(current, workInProgress, newChildren, renderLanes);
var suspenseContext = suspenseStackCursor.current;
if ((2 & suspenseContext) != 0 ? (suspenseContext = 1 & suspenseContext | 2, workInProgress.flags |= 64) : (null !== current && (64 & current.flags) != 0 && // If we previously forced a fallback, we need to schedule work
// on any nested boundaries to let them know to try to render
// again. This is the same as context updating.
function(workInProgress, firstChild, renderLanes) {
for(// Mark any Suspense boundaries with fallbacks as having work to do.
// If they were previously forced into fallbacks, they may now be able
// to unblock.
var node = firstChild; null !== node;){
if (13 === node.tag) null !== node.memoizedState && scheduleWorkOnFiber(node, renderLanes);
else if (19 === node.tag) // If the tail is hidden there might not be an Suspense boundaries
// to schedule work on. In this case we have to schedule it on the
// list itself.
// We don't have to traverse to the children of the list since
// the list will propagate the change when it rerenders.
scheduleWorkOnFiber(node, renderLanes);
else if (null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === workInProgress) return;
for(; null === node.sibling;){
if (null === node.return || node.return === workInProgress) return;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
}(workInProgress, workInProgress.child, renderLanes), suspenseContext &= 1), push(suspenseStackCursor, suspenseContext, workInProgress), (2 & workInProgress.mode) == 0) // In legacy mode, SuspenseList doesn't work so we just
// use make it a noop by treating it as the default revealOrder.
workInProgress.memoizedState = null;
else switch(revealOrder){
case "forwards":
var tail, lastContentRow = function(firstChild) {
for(// This is going to find the last row among these children that is already
// showing content on the screen, as opposed to being in fallback state or
// new. If a row has multiple Suspense boundaries, any of them being in the
// fallback state, counts as the whole row being in a fallback state.
// Note that the "rows" will be workInProgress, but any nested children
// will still be current since we haven't rendered them yet. The mounted
// order may not be the same as the new order. We use the new order.
var row = firstChild, lastContentRow = null; null !== row;){
var currentRow = row.alternate; // New rows can't be content rows.
null !== currentRow && null === findFirstSuspended(currentRow) && (lastContentRow = row), row = row.sibling;
}
return lastContentRow;
}(workInProgress.child);
null === lastContentRow ? (// The whole list is part of the tail.
// TODO: We could fast path by just rendering the tail now.
tail = workInProgress.child, workInProgress.child = null) : (// Disconnect the tail rows after the content row.
// We're going to render them separately later.
tail = lastContentRow.sibling, lastContentRow.sibling = null), initSuspenseListRenderState(workInProgress, !1, tail, lastContentRow, tailMode, workInProgress.lastEffect);
break;
case "backwards":
// We're going to find the first row that has existing content.
// At the same time we're going to reverse the list of everything
// we pass in the meantime. That's going to be our tail in reverse
// order.
var _tail = null, row = workInProgress.child;
for(workInProgress.child = null; null !== row;){
var currentRow = row.alternate; // New rows can't be content rows.
if (null !== currentRow && null === findFirstSuspended(currentRow)) {
// This is the beginning of the main content.
workInProgress.child = row;
break;
}
var nextRow = row.sibling;
row.sibling = _tail, _tail = row, row = nextRow;
} // TODO: If workInProgress.child is null, we can continue on the tail immediately.
initSuspenseListRenderState(workInProgress, !0, _tail, null, tailMode, workInProgress.lastEffect);
break;
case "together":
initSuspenseListRenderState(workInProgress, !1, null, null, void 0, workInProgress.lastEffect);
break;
default:
// The default reveal order is the same as not having
// a boundary.
workInProgress.memoizedState = null;
}
return workInProgress.child;
}
var hasWarnedAboutUsingNoValuePropOnContextProvider = !1, hasWarnedAboutUsingContextAsConsumer = !1;
function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
return (null !== current && // Reuse previous dependencies
(workInProgress.dependencies = current.dependencies), profilerStartTime = -1, function(lane) {
workInProgressRootSkippedLanes |= lane;
}(workInProgress.lanes), (renderLanes & workInProgress.childLanes) != 0) ? (!// This fiber doesn't have work, but its subtree does. Clone the child
// fibers and continue.
function(current, workInProgress) {
if (null !== current && workInProgress.child !== current.child) throw Error("Resuming work not yet implemented.");
if (null !== workInProgress.child) {
var currentChild = workInProgress.child, newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
for(workInProgress.child = newChild, newChild.return = workInProgress; null !== currentChild.sibling;)currentChild = currentChild.sibling, (newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps)).return = workInProgress;
newChild.sibling = null;
}
} // Reset a workInProgress child set to prepare it for a second pass.
(current, workInProgress), workInProgress.child) : null;
}
function beginWork(current, workInProgress, renderLanes) {
var updateLanes = workInProgress.lanes;
if (workInProgress._debugNeedsRemount && null !== current) // This will restart the begin phase with a new fiber.
return function(current, oldWorkInProgress, newWorkInProgress) {
var returnFiber = oldWorkInProgress.return;
if (null === returnFiber) throw Error("Cannot swap the root fiber.");
// Disconnect from the old current.
if (// It will get deleted.
current.alternate = null, oldWorkInProgress.alternate = null, newWorkInProgress.index = oldWorkInProgress.index, newWorkInProgress.sibling = oldWorkInProgress.sibling, newWorkInProgress.return = oldWorkInProgress.return, newWorkInProgress.ref = oldWorkInProgress.ref, oldWorkInProgress === returnFiber.child) returnFiber.child = newWorkInProgress;
else {
var prevSibling = returnFiber.child;
if (null === prevSibling) throw Error("Expected parent to have a child.");
for(; prevSibling.sibling !== oldWorkInProgress;)if (null === (prevSibling = prevSibling.sibling)) throw Error("Expected to find the previous sibling.");
prevSibling.sibling = newWorkInProgress;
} // Delete the old fiber and place the new one.
// Since the old fiber is disconnected, we have to schedule it manually.
var last = returnFiber.lastEffect;
return null !== last ? (last.nextEffect = current, returnFiber.lastEffect = current) : returnFiber.firstEffect = returnFiber.lastEffect = current, current.nextEffect = null, current.flags = 8, newWorkInProgress.flags |= 2, newWorkInProgress;
}(current, workInProgress, createFiberFromTypeAndProps(workInProgress.type, workInProgress.key, workInProgress.pendingProps, workInProgress._debugOwner || null, workInProgress.mode, workInProgress.lanes));
if (null !== current) {
if (current.memoizedProps !== workInProgress.pendingProps || hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
workInProgress.type !== current.type) // If props or context changed, mark the fiber as having performed work.
// This may be unset if the props are determined to be equal later (memo).
didReceiveUpdate = !0;
else if ((renderLanes & updateLanes) != 0) // This is a special case that only exists for legacy mode.
// See https://github.com/facebook/react/pull/19216.
didReceiveUpdate = (16384 & current.flags) != 0;
else {
// the begin phase. There's still some bookkeeping we that needs to be done
// in this optimized path, mostly pushing stuff onto the stack.
switch(didReceiveUpdate = !1, workInProgress.tag){
case 3:
pushHostRootContext(workInProgress), resetHydrationState();
break;
case 5:
pushHostContext(workInProgress);
break;
case 1:
isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
break;
case 4:
pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
break;
case 10:
var newValue = workInProgress.memoizedProps.value;
pushProvider(workInProgress, newValue);
break;
case 12:
(renderLanes & workInProgress.childLanes) != 0 && (workInProgress.flags |= 4);
// These are reset during render to allow the DevTools commit hook a chance to read them,
var stateNode = workInProgress.stateNode;
stateNode.effectDuration = 0, stateNode.passiveEffectDuration = 0;
break;
case 13:
if (null !== workInProgress.memoizedState) {
if ((renderLanes & workInProgress.child.childLanes) != 0) // The primary children have pending work. Use the normal path
// to attempt to render the primary children again.
return updateSuspenseComponent(current, workInProgress, renderLanes);
// The primary child fragment does not have pending work marked
// on it
newContext1 = 1 & suspenseStackCursor.current, push(suspenseStackCursor, newContext1, workInProgress); // The primary children do not have pending work with sufficient
// priority. Bailout.
var newContext, newContext1, child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
if (null !== child) // The fallback children have pending work. Skip over the
// primary children and work on the fallback.
return child.sibling;
return null;
}
newContext = 1 & suspenseStackCursor.current, push(suspenseStackCursor, newContext, workInProgress);
break;
case 19:
var newContext2, didSuspendBefore = (64 & current.flags) != 0, _hasChildWork = (renderLanes & workInProgress.childLanes) != 0;
if (didSuspendBefore) {
if (_hasChildWork) // If something was in fallback state last time, and we have all the
// same children then we're still in progressive loading state.
// Something might get unblocked by state updates or retries in the
// tree which will affect the tail. So we need to use the normal
// path to compute the correct tail.
return updateSuspenseListComponent(current, workInProgress, renderLanes);
// If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
workInProgress.flags |= 64;
} // If nothing suspended before and we're rendering the same children,
// then the tail doesn't matter. Anything new that suspends will work
// in the "together" mode, so we can continue from the state we had.
var renderState = workInProgress.memoizedState;
if (null !== renderState && (// Reset to the "together" mode in case we've started a different
// update in the past but didn't complete it.
renderState.rendering = null, renderState.tail = null, renderState.lastEffect = null), newContext2 = suspenseStackCursor.current, push(suspenseStackCursor, newContext2, workInProgress), !_hasChildWork) // If none of the children had any work, that means that none of
// them got retried so they'll still be blocked in the same way
// as before. We can fast bail out.
return null;
break;
case 23:
case 24:
return(// Need to check if the tree still needs to be deferred. This is
// almost identical to the logic used in the normal update path,
// so we'll just enter that. The only difference is we'll bail out
// at the next level instead of this one, because the child props
// have not changed. Which is fine.
// TODO: Probably should refactor `beginWork` to split the bailout
// path from the normal path. I'm tempted to do a labeled break here
// but I won't :)
workInProgress.lanes = 0, updateOffscreenComponent(current, workInProgress, renderLanes));
}
return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
}
} else didReceiveUpdate = !1;
// Before entering the begin phase, clear pending update priority.
switch(// TODO: This assumes that we're about to evaluate the component and process
// the update queue. However, there's an exception: SimpleMemoComponent
// sometimes bails out later in the begin phase. This indicates that we should
// move this assignment out of the common path and into each branch.
workInProgress.lanes = 0, workInProgress.tag){
case 2:
return function(_current, workInProgress, Component, renderLanes) {
null !== _current && (// An indeterminate component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
var context, value, props = workInProgress.pendingProps, unmaskedContext = getUnmaskedContext(workInProgress, Component, !1);
if (context = getMaskedContext(workInProgress, unmaskedContext), prepareToReadContext(workInProgress, renderLanes), Component.prototype && "function" == typeof Component.prototype.render) {
var componentName = getComponentName(Component) || "Unknown";
didWarnAboutBadClass[componentName] || (error("The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName), didWarnAboutBadClass[componentName] = !0);
}
// Support for module components is deprecated and is removed behind a flag.
// Whether or not it would crash later, we want to show a good message in DEV first.
if (1 & workInProgress.mode && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null), isRendering = !0, ReactCurrentOwner$1.current = workInProgress, value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes), isRendering = !1, workInProgress.flags |= 1, "object" == typeof value && null !== value && "function" == typeof value.render && void 0 === value.$$typeof) {
var _componentName = getComponentName(Component) || "Unknown";
didWarnAboutModulePatternComponent[_componentName] || (error("The <%s /> component appears to be a function component that returns a class instance. Change %s to a class that extends React.Component instead. If you can't use a class try assigning the prototype on the function as a workaround. `%s.prototype = React.Component.prototype`. Don't use an arrow function since it cannot be called with `new` by React.", _componentName, _componentName, _componentName), didWarnAboutModulePatternComponent[_componentName] = !0);
}
if (// Run these checks in production only if the flag is off.
// Eventually we'll delete this branch altogether.
"object" == typeof value && null !== value && "function" == typeof value.render && void 0 === value.$$typeof) {
var _componentName2 = getComponentName(Component) || "Unknown";
didWarnAboutModulePatternComponent[_componentName2] || (error("The <%s /> component appears to be a function component that returns a class instance. Change %s to a class that extends React.Component instead. If you can't use a class try assigning the prototype on the function as a workaround. `%s.prototype = React.Component.prototype`. Don't use an arrow function since it cannot be called with `new` by React.", _componentName2, _componentName2, _componentName2), didWarnAboutModulePatternComponent[_componentName2] = !0), workInProgress.tag = 1, workInProgress.memoizedState = null, workInProgress.updateQueue = null;
// During mounting we don't know the child context yet as the instance doesn't exist.
// We will invalidate the child context in finishClassComponent() right after rendering.
var hasContext = !1;
isContextProvider(Component) ? (hasContext = !0, pushContextProvider(workInProgress)) : hasContext = !1, workInProgress.memoizedState = null !== value.state && void 0 !== value.state ? value.state : null, initializeUpdateQueue(workInProgress);
var getDerivedStateFromProps = Component.getDerivedStateFromProps;
return "function" == typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props), adoptClassInstance(workInProgress, value), mountClassInstance(workInProgress, Component, props, renderLanes), finishClassComponent(null, workInProgress, Component, !0, hasContext, renderLanes);
}
if (// Proceed under the assumption that this is a function component
workInProgress.tag = 0, 1 & workInProgress.mode) {
disableLogs();
try {
value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);
} finally{
reenableLogs();
}
}
return reconcileChildren(null, workInProgress, value, renderLanes), validateFunctionComponentInDev(workInProgress, Component), workInProgress.child;
}(current, workInProgress, workInProgress.type, renderLanes);
case 16:
var elementType = workInProgress.elementType;
return function(_current, workInProgress, elementType, updateLanes, renderLanes) {
null !== _current && (// A lazy component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
_current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
var child, props = workInProgress.pendingProps, payload = elementType._payload, Component = (0, elementType._init)(payload);
workInProgress.type = Component;
var resolvedTag = workInProgress.tag = function(Component) {
if ("function" == typeof Component) return +!!shouldConstruct$1(Component);
if (null != Component) {
var $$typeof = Component.$$typeof;
if ($$typeof === REACT_FORWARD_REF_TYPE) return 11;
if ($$typeof === REACT_MEMO_TYPE) return 14;
}
return 2;
} // This is used to create an alternate fiber to do work on.
(Component), resolvedProps = resolveDefaultProps(Component, props);
switch(resolvedTag){
case 0:
return validateFunctionComponentInDev(workInProgress, Component), workInProgress.type = Component = resolveFunctionForHotReloading(Component), updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);
case 1:
return workInProgress.type = Component = resolveFunctionForHotReloading(Component), updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);
case 11:
return workInProgress.type = Component = resolveForwardRefForHotReloading(Component), updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);
case 14:
if (workInProgress.type !== workInProgress.elementType) {
var outerPropTypes = Component.propTypes;
outerPropTypes && checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component));
}
return updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateLanes, renderLanes);
}
var hint = "";
throw null !== Component && "object" == typeof Component && Component.$$typeof === REACT_LAZY_TYPE && (hint = " Did you wrap a component in React.lazy() more than once?"), Error("Element type is invalid. Received a promise that resolves to: " + Component + ". Lazy element type must resolve to a class or function." + hint);
}(current, workInProgress, elementType, updateLanes, renderLanes);
case 0:
var _Component = workInProgress.type, unresolvedProps = workInProgress.pendingProps, resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
return updateFunctionComponent(current, workInProgress, _Component, resolvedProps, renderLanes);
case 1:
var _Component2 = workInProgress.type, _unresolvedProps = workInProgress.pendingProps, _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);
return updateClassComponent(current, workInProgress, _Component2, _resolvedProps, renderLanes);
case 3:
return function(current, workInProgress, renderLanes) {
pushHostRootContext(workInProgress);
var updateQueue = workInProgress.updateQueue;
if (null === current || null === updateQueue) throw Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue.");
var nextProps = workInProgress.pendingProps, prevState = workInProgress.memoizedState, prevChildren = null !== prevState ? prevState.element : null;
cloneUpdateQueue(current, workInProgress), processUpdateQueue(workInProgress, nextProps, null, renderLanes);
// being called "element".
var nextChildren = workInProgress.memoizedState.element;
if (nextChildren === prevChildren) return resetHydrationState(), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
var root = workInProgress.stateNode;
if (root.hydrate && (nextHydratableInstance = getFirstHydratableChild(workInProgress.stateNode.containerInfo), hydrationParentFiber = workInProgress, isHydrating = !0, 1)) {
var mutableSourceEagerHydrationData = root.mutableSourceEagerHydrationData;
if (null != mutableSourceEagerHydrationData) for(var i = 0; i < mutableSourceEagerHydrationData.length; i += 2)setWorkInProgressVersion(mutableSourceEagerHydrationData[i], mutableSourceEagerHydrationData[i + 1]);
var child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);
workInProgress.child = child;
for(var node = child; node;)// Mark each child as hydrating. This is a fast path to know whether this
// tree is part of a hydrating tree. This is used to determine if a child
// node has fully mounted yet, and for scheduling event replaying.
// Conceptually this is similar to Placement in that a new subtree is
// inserted into the React tree here. It just happens to not need DOM
// mutations because it already exists.
node.flags = -3 & node.flags | /* */ 1024, node = node.sibling;
} else // Otherwise reset hydration state in case we aborted and resumed another
// root.
reconcileChildren(current, workInProgress, nextChildren, renderLanes), resetHydrationState();
return workInProgress.child;
}(current, workInProgress, renderLanes);
case 5:
return pushHostContext(workInProgress), null === current && tryToClaimNextHydratableInstance(workInProgress), type1 = workInProgress.type, nextProps = workInProgress.pendingProps, prevProps = null !== current ? current.memoizedProps : null, nextChildren = nextProps.children, shouldSetTextContent(type1, nextProps) ? // We special case a direct text child of a host node. This is a common
// case. We won't handle it as a reified child. We will instead handle
// this in the host environment that also has access to this prop. That
// avoids allocating another HostText fiber and traversing it.
nextChildren = null : null !== prevProps && shouldSetTextContent(type1, prevProps) && // If we're switching from a direct text child to a normal child, or to
// empty, we need to schedule the text content to be reset.
(workInProgress.flags |= /* */ 16), markRef(current, workInProgress), reconcileChildren(current, workInProgress, nextChildren, renderLanes), workInProgress.child;
case 6:
return null === current && tryToClaimNextHydratableInstance(workInProgress), null;
case 13:
return updateSuspenseComponent(current, workInProgress, renderLanes);
case 4:
return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), nextChildren1 = workInProgress.pendingProps, null === current ? // Portals are special because we don't append the children during mount
// but at commit. Therefore we need to track insertions which the normal
// flow doesn't do during mount. This doesn't happen at the root because
// the root always starts with a "current" with a null child.
// TODO: Consider unifying this with how the root works.
workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren1, renderLanes) : reconcileChildren(current, workInProgress, nextChildren1, renderLanes), workInProgress.child;
case 11:
var type = workInProgress.type, _unresolvedProps2 = workInProgress.pendingProps, _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);
return updateForwardRef(current, workInProgress, type, _resolvedProps2, renderLanes);
case 7:
return nextChildren2 = workInProgress.pendingProps, reconcileChildren(current, workInProgress, nextChildren2, renderLanes), workInProgress.child;
case 8:
return nextChildren3 = workInProgress.pendingProps.children, reconcileChildren(current, workInProgress, nextChildren3, renderLanes), workInProgress.child;
case 12:
return workInProgress.flags |= 4, (stateNode1 = workInProgress.stateNode).effectDuration = 0, stateNode1.passiveEffectDuration = 0, nextChildren4 = workInProgress.pendingProps.children, reconcileChildren(current, workInProgress, nextChildren4, renderLanes), workInProgress.child;
case 10:
return function(current, workInProgress, renderLanes) {
var context = workInProgress.type._context, newProps = workInProgress.pendingProps, oldProps = workInProgress.memoizedProps, newValue = newProps.value;
"value" in newProps || hasWarnedAboutUsingNoValuePropOnContextProvider || (hasWarnedAboutUsingNoValuePropOnContextProvider = !0, error("The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"));
var providerPropTypes = workInProgress.type.propTypes;
if (providerPropTypes && checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider"), pushProvider(workInProgress, newValue), null !== oldProps) {
var changedBits = function(context, newValue, oldValue) {
if (objectIs(oldValue, newValue)) // No change
return 0;
var changedBits = "function" == typeof context._calculateChangedBits ? context._calculateChangedBits(oldValue, newValue) : 1073741823;
return (1073741823 & changedBits) !== changedBits && error("calculateChangedBits: Expected the return value to be a 31-bit integer. Instead received: %s", changedBits), 0 | changedBits;
}(context, newValue, oldProps.value);
if (0 === changedBits) // No change. Bailout early if children are the same.
{
if (oldProps.children === newProps.children && !hasContextChanged()) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
} else // The context value changed. Search for matching consumers and schedule
// them to update.
!function(workInProgress, context, changedBits, renderLanes) {
var fiber = workInProgress.child;
for(null !== fiber && // Set the return pointer of the child to the work-in-progress fiber.
(fiber.return = workInProgress); null !== fiber;){
var nextFiber = void 0, list = fiber.dependencies; // Visit this fiber.
if (null !== list) {
nextFiber = fiber.child;
for(var dependency = list.firstContext; null !== dependency;){
// Check if the context matches.
if (dependency.context === context && (dependency.observedBits & changedBits) != 0) {
// Match! Schedule an update on this fiber.
if (1 === fiber.tag) {
// Schedule a force update on the work-in-progress.
var a, a1, update = createUpdate(-1, pickArbitraryLane(renderLanes));
update.tag = 2, // update to the current fiber, too, which means it will persist even if
// this render is thrown away. Since it's a race condition, not sure it's
// worth fixing.
enqueueUpdate(fiber, update);
}
fiber.lanes = fiber.lanes | renderLanes;
var alternate = fiber.alternate;
null !== alternate && (a = alternate.lanes, alternate.lanes = a | renderLanes), scheduleWorkOnParentPath(fiber.return, renderLanes), a1 = list.lanes, list.lanes = a1 | renderLanes;
break;
}
dependency = dependency.next;
}
} else // Don't scan deeper if this is a matching provider
nextFiber = 10 === fiber.tag && fiber.type === workInProgress.type ? null : fiber.child;
if (null !== nextFiber) // Set the return pointer of the child to the work-in-progress fiber.
nextFiber.return = fiber;
else for(// No child. Traverse to next sibling.
nextFiber = fiber; null !== nextFiber;){
if (nextFiber === workInProgress) {
// We're back to the root of this subtree. Exit.
nextFiber = null;
break;
}
var sibling = nextFiber.sibling;
if (null !== sibling) {
// Set the return pointer of the sibling to the work-in-progress fiber.
sibling.return = nextFiber.return, nextFiber = sibling;
break;
} // No more siblings. Traverse up.
nextFiber = nextFiber.return;
}
fiber = nextFiber;
}
}(workInProgress, context, changedBits, renderLanes);
}
return reconcileChildren(current, workInProgress, newProps.children, renderLanes), workInProgress.child;
}(current, workInProgress, renderLanes);
case 9:
return current1 = current, workInProgress1 = workInProgress, renderLanes1 = renderLanes, void 0 === (context = workInProgress1.type)._context ? context === context.Consumer || hasWarnedAboutUsingContextAsConsumer || (hasWarnedAboutUsingContextAsConsumer = !0, error("Rendering <Context> directly is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")) : context = context._context, "function" != typeof (render = (newProps = workInProgress1.pendingProps).children) && error("A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."), prepareToReadContext(workInProgress1, renderLanes1), newValue1 = readContext(context, newProps.unstable_observedBits), ReactCurrentOwner$1.current = workInProgress1, isRendering = !0, newChildren = render(newValue1), isRendering = !1, workInProgress1.flags |= 1, reconcileChildren(current1, workInProgress1, newChildren, renderLanes1), workInProgress1.child;
case 14:
var _type2 = workInProgress.type, _resolvedProps3 = resolveDefaultProps(_type2, workInProgress.pendingProps);
if (workInProgress.type !== workInProgress.elementType) {
var outerPropTypes = _type2.propTypes;
outerPropTypes && checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2));
}
return _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3), updateMemoComponent(current, workInProgress, _type2, _resolvedProps3, updateLanes, renderLanes);
case 15:
return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, updateLanes, renderLanes);
case 17:
var current1, workInProgress1, renderLanes1, newChildren, context, newProps, render, newValue1, type1, nextProps, prevProps, nextChildren, nextChildren1, nextChildren2, nextChildren3, stateNode1, nextChildren4, hasContext, _Component3 = workInProgress.type, _unresolvedProps4 = workInProgress.pendingProps, _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);
return null !== current && (// An incomplete component only mounts if it suspended inside a non-
// concurrent tree, in an inconsistent state. We want to treat it like
// a new mount, even though an empty version of it already committed.
// Disconnect the alternate pointers.
current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2), workInProgress.tag = 1, isContextProvider(_Component3) ? (hasContext = !0, pushContextProvider(workInProgress)) : hasContext = !1, prepareToReadContext(workInProgress, renderLanes), constructClassInstance(workInProgress, _Component3, _resolvedProps4), mountClassInstance(workInProgress, _Component3, _resolvedProps4, renderLanes), finishClassComponent(null, workInProgress, _Component3, !0, hasContext, renderLanes);
case 19:
return updateSuspenseListComponent(current, workInProgress, renderLanes);
case 20:
case 21:
case 22:
break;
case 23:
case 24:
return updateOffscreenComponent(current, workInProgress, renderLanes);
}
throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
}
function markUpdate(workInProgress) {
// Tag the fiber with an update effect. This turns a Placement into
// a PlacementAndUpdate.
workInProgress.flags |= 4;
}
function markRef$1(workInProgress) {
workInProgress.flags |= 128;
}
function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
if (!isHydrating) switch(renderState.tailMode){
case "hidden":
for(// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
var tailNode = renderState.tail, lastTailNode = null; null !== tailNode;)null !== tailNode.alternate && (lastTailNode = tailNode), tailNode = tailNode.sibling;
// Next we're simply going to delete all insertions after the
// last rendered item.
null === lastTailNode ? // All remaining items in the tail are insertions.
renderState.tail = null : // Detach the insertion after the last node that was already
// inserted.
lastTailNode.sibling = null;
break;
case "collapsed":
for(// Any insertions at the end of the tail list after this point
// should be invisible. If there are already mounted boundaries
// anything before them are not considered for collapsing.
// Therefore we need to go through the whole tail to find if
// there are any.
var _tailNode = renderState.tail, _lastTailNode = null; null !== _tailNode;)null !== _tailNode.alternate && (_lastTailNode = _tailNode), _tailNode = _tailNode.sibling;
// Next we're simply going to delete all insertions after the
// last rendered item.
null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : // We suspended during the head. We want to show at least one
// row at the tail. So we'll keep on and cut off the rest.
renderState.tail.sibling = null : // Detach the insertion after the last node that was already
// inserted.
_lastTailNode.sibling = null;
}
}
function completeWork(current, workInProgress, renderLanes) {
var newProps = workInProgress.pendingProps;
switch(workInProgress.tag){
case 2:
case 16:
case 15:
case 0:
case 11:
case 7:
case 8:
case 12:
case 9:
case 14:
return null;
case 1:
case 17:
return isContextProvider(workInProgress.type) && popContext(workInProgress), null;
case 3:
popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), resetWorkInProgressVersions();
var fiberRoot = workInProgress.stateNode;
return fiberRoot.pendingContext && (fiberRoot.context = fiberRoot.pendingContext, fiberRoot.pendingContext = null), null !== current && null !== current.child || (popHydrationState(workInProgress) ? // If we hydrated, then we'll need to schedule an update for
// the commit side-effects on the root.
markUpdate(workInProgress) : fiberRoot.hydrate || // Schedule an effect to clear this container at the start of the next commit.
// This handles the case of React rendering into a container with previous children.
// It's also safe to do for updates too, because current.child would only be null
// if the previous render was null (so the the container would already be empty).
(workInProgress.flags |= 256)), updateHostContainer(workInProgress), null;
case 5:
popHostContext(workInProgress);
var rootContainerInstance = getRootHostContainer(), type = workInProgress.type;
if (null !== current && null != workInProgress.stateNode) updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance), current.ref !== workInProgress.ref && markRef$1(workInProgress);
else {
if (!newProps) {
if (null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
// This can happen when we abort work.
return null;
}
var currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
if (popHydrationState(workInProgress)) {
// TODO: Move this and createInstance step into the beginPhase
// to consolidate.
if (instance = workInProgress.stateNode, type1 = workInProgress.type, props = workInProgress.memoizedProps, rootContainerInstance1 = 0, hostContext = currentHostContext, hostInst = workInProgress, instance[internalInstanceKey] = hostInst, node = instance, props1 = props, node[internalPropsKey] = props1, workInProgress.updateQueue = updatePayload = function(domElement, tag, rawProps, parentNamespace, rootContainerElement) {
switch(suppressHydrationWarning = !0 === rawProps[SUPPRESS_HYDRATION_WARNING], isCustomComponentTag = isCustomComponent(tag, rawProps), validatePropertiesInDevelopment(tag, rawProps), tag){
case "dialog":
listenToNonDelegatedEvent("cancel", domElement), listenToNonDelegatedEvent("close", domElement);
break;
case "iframe":
case "object":
case "embed":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent("load", domElement);
break;
case "video":
case "audio":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for(var isCustomComponentTag, extraAttributeNames, i = 0; i < mediaEventTypes.length; i++)listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
break;
case "source":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent("error", domElement);
break;
case "img":
case "image":
case "link":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement);
break;
case "details":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent("toggle", domElement);
break;
case "input":
initWrapperState(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "option":
validateProps(domElement, rawProps);
break;
case "select":
initWrapperState$1(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "textarea":
initWrapperState$2(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
}
assertValidProps(tag, rawProps), extraAttributeNames = new Set();
for(var attributes = domElement.attributes, _i = 0; _i < attributes.length; _i++)switch(attributes[_i].name.toLowerCase()){
// Built-in SSR attribute is allowed
case "data-reactroot":
// Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
case "value":
case "checked":
case "selected":
break;
default:
// Intentionally use the original name.
// See discussion in https://github.com/facebook/react/pull/10676.
extraAttributeNames.add(attributes[_i].name);
}
var updatePayload = null;
for(var propKey in rawProps)if (rawProps.hasOwnProperty(propKey)) {
var nextProp = rawProps[propKey];
if (propKey === CHILDREN) // For text content children we compare against textContent. This
// might match additional HTML that is hidden when we read it using
// textContent. E.g. "foo" will match "f<span>oo</span>" but that still
// satisfies our requirement. Our requirement is not to produce perfect
// HTML and attributes. Ideally we should preserve structure but it's
// ok not to if the visible content is still enough to indicate what
// even listeners these nodes might be wired up to.
// TODO: Warn if there is more than a single textNode as a child.
// TODO: Should we use domElement.firstChild.nodeValue to compare?
"string" == typeof nextProp ? domElement.textContent !== nextProp && (suppressHydrationWarning || warnForTextDifference(domElement.textContent, nextProp), updatePayload = [
CHILDREN,
nextProp
]) : "number" == typeof nextProp && domElement.textContent !== "" + nextProp && (suppressHydrationWarning || warnForTextDifference(domElement.textContent, nextProp), updatePayload = [
CHILDREN,
"" + nextProp
]);
else if (registrationNameDependencies.hasOwnProperty(propKey)) null != nextProp && ("function" != typeof nextProp && warnForInvalidEventListener(propKey, nextProp), "onScroll" === propKey && listenToNonDelegatedEvent("scroll", domElement));
else if (// Convince Flow we've calculated it (it's DEV-only in this method.)
"boolean" == typeof isCustomComponentTag) {
// Validate that the properties correspond to their expected values.
var serverValue = void 0, propertyInfo = getPropertyInfo(propKey);
if (suppressHydrationWarning) ;
else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING || // Controlled attributes are not validated
// TODO: Only ignore them on controlled tags.
"value" === propKey || "checked" === propKey || "selected" === propKey) ;
else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var serverHTML = domElement.innerHTML, nextHtml = nextProp ? nextProp[HTML$1] : void 0;
if (null != nextHtml) {
var expectedHTML = normalizeHTML(domElement, nextHtml);
expectedHTML !== serverHTML && warnForPropDifference(propKey, serverHTML, expectedHTML);
}
} else if (propKey === STYLE) {
if (// $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey), canDiffStyleForHydrationWarning) {
var expectedStyle = /**
* Operations for dealing with CSS properties.
*/ /**
* This creates a string that is expected to be equivalent to the style
* attribute generated by server-side rendering. It by-passes warnings and
* security checks so it's not safe to use this value for anything other than
* comparison. It is only used in DEV for SSR validation.
*/ function(styles) {
var serialized = "", delimiter = "";
for(var styleName in styles)if (styles.hasOwnProperty(styleName)) {
var styleValue = styles[styleName];
if (null != styleValue) {
var isCustomProperty = 0 === styleName.indexOf("--");
serialized += delimiter + (isCustomProperty ? styleName : styleName.replace(uppercasePattern, "-$1").toLowerCase().replace(msPattern, "-ms-")) + ":", serialized += dangerousStyleValue(styleName, styleValue, isCustomProperty), delimiter = ";";
}
}
return serialized || null;
}(nextProp);
expectedStyle !== (serverValue = domElement.getAttribute("style")) && warnForPropDifference(propKey, serverValue, expectedStyle);
}
} else if (isCustomComponentTag) // $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase()), serverValue = getValueForAttribute(domElement, propKey, nextProp), nextProp !== serverValue && warnForPropDifference(propKey, serverValue, nextProp);
else if (!shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) && !shouldRemoveAttribute(propKey, nextProp, propertyInfo, isCustomComponentTag)) {
var isMismatchDueToBadCasing = !1;
if (null !== propertyInfo) // $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propertyInfo.attributeName), serverValue = /**
* Get the value for a property on a node. Only used in DEV for SSR validation.
* The "expected" argument is used as a hint of what the expected value is.
* Some properties have multiple equivalent values.
*/ function(node, name, expected, propertyInfo) {
if (propertyInfo.mustUseProperty) return node[propertyInfo.propertyName];
propertyInfo.sanitizeURL && // If we haven't fully disabled javascript: URLs, and if
// the hydration is successful of a javascript: URL, we
// still want to warn on the client.
sanitizeURL("" + expected);
var attributeName = propertyInfo.attributeName, stringValue = null;
if (4 === propertyInfo.type) {
if (node.hasAttribute(attributeName)) {
var value = node.getAttribute(attributeName);
return "" === value || (shouldRemoveAttribute(name, expected, propertyInfo, !1) ? value : value === "" + expected ? expected : value);
}
} else if (node.hasAttribute(attributeName)) {
if (shouldRemoveAttribute(name, expected, propertyInfo, !1)) // We had an attribute but shouldn't have had one, so read it
// for the error message.
return node.getAttribute(attributeName);
if (3 === propertyInfo.type) // If this was a boolean, it doesn't matter what the value is
// the fact that we have it is the same as the expected.
return expected;
// Even if this property uses a namespace we use getAttribute
// because we assume its namespaced name is the same as our config.
// To use getAttributeNS we need the local name which we don't have
// in our config atm.
stringValue = node.getAttribute(attributeName);
}
return shouldRemoveAttribute(name, expected, propertyInfo, !1) ? null === stringValue ? expected : stringValue : stringValue === "" + expected ? expected : stringValue;
}(domElement, propKey, nextProp, propertyInfo);
else {
var ownNamespace = parentNamespace;
if (ownNamespace === HTML_NAMESPACE && (ownNamespace = getIntrinsicNamespace(tag)), ownNamespace === HTML_NAMESPACE) // $FlowFixMe - Should be inferred as not undefined.
extraAttributeNames.delete(propKey.toLowerCase());
else {
var standardName = function(propName) {
var lowerCasedName = propName.toLowerCase();
return possibleStandardNames.hasOwnProperty(lowerCasedName) && possibleStandardNames[lowerCasedName] || null;
}(propKey);
null !== standardName && standardName !== propKey && (// If an SVG prop is supplied with bad casing, it will
// be successfully parsed from HTML, but will produce a mismatch
// (and would be incorrectly rendered on the client).
// However, we already warn about bad casing elsewhere.
// So we'll skip the misleading extra mismatch warning in this case.
isMismatchDueToBadCasing = !0, extraAttributeNames.delete(standardName)), extraAttributeNames.delete(propKey);
}
serverValue = getValueForAttribute(domElement, propKey, nextProp);
}
nextProp === serverValue || isMismatchDueToBadCasing || warnForPropDifference(propKey, serverValue, nextProp);
}
}
}
switch(extraAttributeNames.size > 0 && !suppressHydrationWarning && // $FlowFixMe - Should be inferred as not undefined.
warnForExtraAttributes(extraAttributeNames), tag){
case "input":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement), postMountWrapper(domElement, rawProps, !0);
break;
case "textarea":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement), postMountWrapper$3(domElement);
break;
case "select":
case "option":
break;
default:
"function" == typeof rawProps.onClick && // TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
return updatePayload;
}(instance, type1, props, hostContext.namespace), null !== updatePayload) // If changes to the hydrated node need to be applied at the
// commit-phase we mark this as such.
markUpdate(workInProgress);
} else {
var instance, type1, props, rootContainerInstance1, hostContext, hostInst, node, props1, updatePayload, instance1 = function(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
if (validateDOMNesting(type, null, hostContext.ancestorInfo), "string" == typeof props.children || "number" == typeof props.children) {
var hostInst, node, props1, string = "" + props.children, ownAncestorInfo = updatedAncestorInfo(hostContext.ancestorInfo, type);
validateDOMNesting(null, string, ownAncestorInfo);
}
var domElement = function(type, props, rootContainerElement, parentNamespace) {
// tags get no namespace.
var isCustomComponentTag, domElement, ownerDocument = getOwnerDocumentFromRootContainer(rootContainerElement), namespaceURI = parentNamespace;
if (namespaceURI === HTML_NAMESPACE && (namespaceURI = getIntrinsicNamespace(type)), namespaceURI === HTML_NAMESPACE) {
if ((isCustomComponentTag = isCustomComponent(type, props)) || type === type.toLowerCase() || error("<%s /> is using incorrect casing. Use PascalCase for React components, or lowercase for HTML elements.", type), "script" === type) {
// Create the script via .innerHTML so its "parser-inserted" flag is
// set to true and it does not execute
var div = ownerDocument.createElement("div");
div.innerHTML = "<script></script>"; // eslint-disable-line
// This is guaranteed to yield a script element.
var firstChild = div.firstChild;
domElement = div.removeChild(firstChild);
} else if ("string" == typeof props.is) // $FlowIssue `createElement` should be updated for Web Components
domElement = ownerDocument.createElement(type, {
is: props.is
});
else // attributes on `select`s needs to be added before `option`s are inserted.
// This prevents:
// - a bug where the `select` does not scroll to the correct option because singular
// `select` elements automatically pick the first item #13222
// - a bug where the `select` set the first item as selected despite the `size` attribute #14239
// See https://github.com/facebook/react/issues/13222
// and https://github.com/facebook/react/issues/14239
if (// Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
// See discussion in https://github.com/facebook/react/pull/6896
// and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
domElement = ownerDocument.createElement(type), "select" === type) {
var node = domElement;
props.multiple ? node.multiple = !0 : props.size && // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
// it is possible that no option is selected.
//
// This is only necessary when a select in "single selection mode".
(node.size = props.size);
}
} else domElement = ownerDocument.createElementNS(namespaceURI, type);
return namespaceURI !== HTML_NAMESPACE || isCustomComponentTag || "[object HTMLUnknownElement]" !== Object.prototype.toString.call(domElement) || Object.prototype.hasOwnProperty.call(warnedUnknownTags, type) || (warnedUnknownTags[type] = !0, error("The tag <%s> is unrecognized in this browser. If you meant to render a React component, start its name with an uppercase letter.", type)), domElement;
}(type, props, rootContainerInstance, hostContext.namespace);
return hostInst = internalInstanceHandle, domElement[internalInstanceKey] = hostInst, node = domElement, props1 = props, node[internalPropsKey] = props1, domElement;
}(type, newProps, rootContainerInstance, currentHostContext, workInProgress);
// (eg DOM renderer supports auto-focus for certain elements).
// Make sure such renderers get scheduled for later work.
appendAllChildren(instance1, workInProgress, !1, !1), workInProgress.stateNode = instance1, !function(domElement, tag, rawProps, rootContainerElement) {
var element, props, value, props1, isCustomComponentTag = isCustomComponent(tag, rawProps);
switch(validatePropertiesInDevelopment(tag, rawProps), tag){
case "dialog":
listenToNonDelegatedEvent("cancel", domElement), listenToNonDelegatedEvent("close", domElement), props1 = rawProps;
break;
case "iframe":
case "object":
case "embed":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the load event.
listenToNonDelegatedEvent("load", domElement), props1 = rawProps;
break;
case "video":
case "audio":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for all the media events.
for(var i = 0; i < mediaEventTypes.length; i++)listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
props1 = rawProps;
break;
case "source":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the error event.
listenToNonDelegatedEvent("error", domElement), props1 = rawProps;
break;
case "img":
case "image":
case "link":
// We listen to these events in case to ensure emulated bubble
// listeners still fire for error and load events.
listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement), props1 = rawProps;
break;
case "details":
// We listen to this event in case to ensure emulated bubble
// listeners still fire for the toggle event.
listenToNonDelegatedEvent("toggle", domElement), props1 = rawProps;
break;
case "input":
initWrapperState(domElement, rawProps), props1 = getHostProps(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "option":
validateProps(domElement, rawProps), props1 = getHostProps$1(domElement, rawProps);
break;
case "select":
initWrapperState$1(domElement, rawProps), props1 = getHostProps$2(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
case "textarea":
initWrapperState$2(domElement, rawProps), props1 = getHostProps$3(domElement, rawProps), // listeners still fire for the invalid event.
listenToNonDelegatedEvent("invalid", domElement);
break;
default:
props1 = rawProps;
}
switch(assertValidProps(tag, props1), function(tag, domElement, rootContainerElement, nextProps, isCustomComponentTag) {
for(var propKey in nextProps)if (nextProps.hasOwnProperty(propKey)) {
var nextProp = nextProps[propKey];
if (propKey === STYLE) nextProp && // Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp), setValueForStyles(domElement, nextProp);
else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var nextHtml = nextProp ? nextProp[HTML$1] : void 0;
null != nextHtml && setInnerHTML(domElement, nextHtml);
} else propKey === CHILDREN ? "string" == typeof nextProp ? ("textarea" !== tag || "" !== nextProp) && setTextContent(domElement, nextProp) : "number" == typeof nextProp && setTextContent(domElement, "" + nextProp) : propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING || propKey === AUTOFOCUS || (registrationNameDependencies.hasOwnProperty(propKey) ? null != nextProp && ("function" != typeof nextProp && warnForInvalidEventListener(propKey, nextProp), "onScroll" === propKey && listenToNonDelegatedEvent("scroll", domElement)) : null != nextProp && setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag));
}
}(tag, domElement, 0, props1, isCustomComponentTag), tag){
case "input":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement), postMountWrapper(domElement, rawProps, !1);
break;
case "textarea":
// TODO: Make sure we check if this is still unmounted or do any clean
// up necessary since we never stop tracking anymore.
track(domElement), postMountWrapper$3(domElement);
break;
case "option":
element = domElement, null != (props = rawProps).value && element.setAttribute("value", "" + getToStringValue(props.value));
break;
case "select":
domElement.multiple = !!rawProps.multiple, null != (value = rawProps.value) ? updateOptions(domElement, !!rawProps.multiple, value, !1) : null != rawProps.defaultValue && updateOptions(domElement, !!rawProps.multiple, rawProps.defaultValue, !0);
break;
default:
"function" == typeof props1.onClick && // TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
} // Calculate the diff between the two objects.
(instance1, type, newProps, 0), shouldAutoFocusHostComponent(type, newProps) && markUpdate(workInProgress);
}
null !== workInProgress.ref && // If there is a ref on a host node we need to schedule a callback
markRef$1(workInProgress);
}
return null;
case 6:
if (current && null != workInProgress.stateNode) {
var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
// to schedule a side-effect to do the updates.
updateHostText$1(current, workInProgress, oldText, newProps);
} else {
if ("string" != typeof newProps && null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
var hostInst1, textNode, _rootContainerInstance = getRootHostContainer(), _currentHostContext = getHostContext();
if (popHydrationState(workInProgress)) (function(fiber) {
var hostInst, textInstance = fiber.stateNode, textContent = fiber.memoizedProps, shouldUpdate = (hostInst = fiber, textInstance[internalInstanceKey] = hostInst, textInstance.nodeValue !== textContent);
if (shouldUpdate) {
// We assume that prepareToHydrateHostTextInstance is called in a context where the
// hydration parent is the parent host component of this host text.
var returnFiber = hydrationParentFiber;
if (null !== returnFiber) switch(returnFiber.tag){
case 3:
returnFiber.stateNode.containerInfo, warnForUnmatchedText(textInstance, textContent);
break;
case 5:
returnFiber.type;
var parentProps = returnFiber.memoizedProps;
returnFiber.stateNode, !0 !== parentProps[SUPPRESS_HYDRATION_WARNING$1] && warnForUnmatchedText(textInstance, textContent);
}
}
return shouldUpdate;
})(workInProgress) && markUpdate(workInProgress);
else {
validateDOMNesting(null, newProps, _currentHostContext.ancestorInfo), hostInst1 = workInProgress, (textNode = getOwnerDocumentFromRootContainer(_rootContainerInstance).createTextNode(newProps))[internalInstanceKey] = hostInst1, workInProgress.stateNode = textNode;
}
}
return null;
case 13:
pop(suspenseStackCursor, workInProgress);
var nextState = workInProgress.memoizedState;
if ((64 & workInProgress.flags) != 0) return(// Something suspended. Re-render with the fallback children.
workInProgress.lanes = renderLanes, (8 & workInProgress.mode) != 0 && transferActualDuration(workInProgress), workInProgress);
var nextDidTimeout = null !== nextState, prevDidTimeout = !1;
return null === current ? void 0 !== workInProgress.memoizedProps.fallback && popHydrationState(workInProgress) : prevDidTimeout = null !== current.memoizedState, nextDidTimeout && !prevDidTimeout && (2 & workInProgress.mode) != 0 && (null === current && !0 !== workInProgress.memoizedProps.unstable_avoidThisFallback || (1 & suspenseStackCursor.current) != 0 ? 0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 3) : ((0 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus) && (workInProgressRootExitStatus = 4), null !== workInProgressRoot && (includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootUpdatedLanes)) && // Mark the current render as suspended so that we switch to working on
// the updates that were skipped. Usually we only suspend at the end of
// the render phase.
// TODO: We should probably always mark the root as suspended immediately
// (inside this function), since by suspending at the end of the render
// phase introduces a potential mistake where we suspend lanes that were
// pinged or updated while we were rendering.
markRootSuspended$1(workInProgressRoot, workInProgressRootRenderLanes))), (nextDidTimeout || prevDidTimeout) && // If this boundary just timed out, schedule an effect to attach a
// retry listener to the promise. This flag is also used to hide the
// primary children. In mutation mode, we also need the flag to
// *unhide* children that were previously hidden, so check if this
// is currently timed out, too.
(workInProgress.flags |= 4), null;
case 4:
return popHostContainer(workInProgress), updateHostContainer(workInProgress), null === current && listenToAllSupportedEvents(workInProgress.stateNode.containerInfo), null;
case 10:
return(// Pop provider fiber
popProvider(workInProgress), null);
case 19:
pop(suspenseStackCursor, workInProgress);
var renderState = workInProgress.memoizedState;
if (null === renderState) // We're running in the default, "independent" mode.
// We don't do anything in this mode.
return null;
var didSuspendAlready = (64 & workInProgress.flags) != 0, renderedTail = renderState.rendering;
if (null === renderedTail) {
// We just rendered the head.
if (didSuspendAlready) cutOffTailIfNeeded(renderState, !1);
else {
if (0 !== workInProgressRootExitStatus || null !== current && (64 & current.flags) != 0) for(var row = workInProgress.child; null !== row;){
var suspended = findFirstSuspended(row);
if (null !== suspended) {
didSuspendAlready = !0, workInProgress.flags |= 64, cutOffTailIfNeeded(renderState, !1);
// part of the second pass. In that case nothing will subscribe to
// its thennables. Instead, we'll transfer its thennables to the
// SuspenseList so that it can retry if they resolve.
// There might be multiple of these in the list but since we're
// going to wait for all of them anyway, it doesn't really matter
// which ones gets to ping. In theory we could get clever and keep
// track of how many dependencies remain but it gets tricky because
// in the meantime, we can add/remove/change items and dependencies.
// We might bail out of the loop before finding any but that
// doesn't matter since that means that the other boundaries that
// we did find already has their listeners attached.
var newContext, newThennables = suspended.updateQueue;
return null !== newThennables && (workInProgress.updateQueue = newThennables, workInProgress.flags |= 4), null === renderState.lastEffect && (workInProgress.firstEffect = null), workInProgress.lastEffect = renderState.lastEffect, !function(workInProgress, lanes) {
for(var child = workInProgress.child; null !== child;)(function(workInProgress, renderLanes) {
// This resets the Fiber to what createFiber or createWorkInProgress would
// have set the values to before during the first pass. Ideally this wouldn't
// be necessary but unfortunately many code paths reads from the workInProgress
// when they should be reading from current and writing to workInProgress.
// We assume pendingProps, index, key, ref, return are still untouched to
// avoid doing another reconciliation.
// Reset the effect tag but keep any Placement tags, since that's something
// that child fiber is setting, not the reconciliation.
workInProgress.flags &= 2, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null;
var current = workInProgress.alternate;
if (null === current) // Reset to createFiber's initial values.
workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null, // Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration = 0, workInProgress.treeBaseDuration = 0;
else {
// Reset to the cloned values that createWorkInProgress would've.
workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type;
// it cannot be shared with the current fiber.
var currentDependencies = current.dependencies;
workInProgress.dependencies = null === currentDependencies ? null : {
lanes: currentDependencies.lanes,
firstContext: currentDependencies.firstContext
}, // Note: We don't reset the actualTime counts. It's useful to accumulate
// actual time across multiple render passes.
workInProgress.selfBaseDuration = current.selfBaseDuration, workInProgress.treeBaseDuration = current.treeBaseDuration;
}
})(child, lanes), child = child.sibling;
}(workInProgress, renderLanes), newContext = 1 & suspenseStackCursor.current | 2, push(suspenseStackCursor, newContext, workInProgress), workInProgress.child;
}
row = row.sibling;
}
null !== renderState.tail && now() > workInProgressRootRenderTargetTime && (// We have already passed our CPU deadline but we still have rows
// left in the tail. We'll just give up further attempts to render
// the main content and only render fallbacks.
workInProgress.flags |= 64, didSuspendAlready = !0, cutOffTailIfNeeded(renderState, !1), // to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes = 33554432, markSpawnedWork(33554432));
} // Next we're going to render the tail.
} else {
// Append the rendered row to the child list.
if (!didSuspendAlready) {
var _suspended = findFirstSuspended(renderedTail);
if (null !== _suspended) {
workInProgress.flags |= 64, didSuspendAlready = !0;
// get lost if this row ends up dropped during a second pass.
var _newThennables = _suspended.updateQueue;
if (null !== _newThennables && (workInProgress.updateQueue = _newThennables, workInProgress.flags |= 4), cutOffTailIfNeeded(renderState, !0), null === renderState.tail && "hidden" === renderState.tailMode && !renderedTail.alternate && !isHydrating // We don't cut it if we're hydrating.
) {
// We need to delete the row we just rendered.
// Reset the effect list to what it was before we rendered this
// child. The nested children have already appended themselves.
var lastEffect = workInProgress.lastEffect = renderState.lastEffect; // Remove any effects that were appended after this point.
return null !== lastEffect && (lastEffect.nextEffect = null), null;
}
} else 2 * // The time it took to render last row is greater than the remaining
// time we have to render. So rendering one more row would likely
// exceed it.
now() - renderState.renderingStartTime > workInProgressRootRenderTargetTime && 1073741824 !== renderLanes && (// We have now passed our CPU deadline and we'll just give up further
// attempts to render the main content and only render fallbacks.
// The assumption is that this is usually faster.
workInProgress.flags |= 64, didSuspendAlready = !0, cutOffTailIfNeeded(renderState, !1), // to get it started back up to attempt the next item. While in terms
// of priority this work has the same priority as this current render,
// it's not part of the same transition once the transition has
// committed. If it's sync, we still want to yield so that it can be
// painted. Conceptually, this is really the same as pinging.
// We can use any RetryLane even if it's the one currently rendering
// since we're leaving it behind on this node.
workInProgress.lanes = 33554432, markSpawnedWork(33554432));
}
if (renderState.isBackwards) // The effect list of the backwards tail will have been added
// to the end. This breaks the guarantee that life-cycles fire in
// sibling order but that isn't a strong guarantee promised by React.
// Especially since these might also just pop in during future commits.
// Append to the beginning of the list.
renderedTail.sibling = workInProgress.child, workInProgress.child = renderedTail;
else {
var previousSibling = renderState.last;
null !== previousSibling ? previousSibling.sibling = renderedTail : workInProgress.child = renderedTail, renderState.last = renderedTail;
}
}
if (null !== renderState.tail) {
// We still have tail rows to render.
// Pop a row.
var next = renderState.tail;
renderState.rendering = next, renderState.tail = next.sibling, renderState.lastEffect = workInProgress.lastEffect, renderState.renderingStartTime = now(), next.sibling = null;
// TODO: We can probably just avoid popping it instead and only
// setting it the first time we go from not suspended to suspended.
var suspenseContext = suspenseStackCursor.current;
return didSuspendAlready ? suspenseContext = 1 & suspenseContext | 2 : suspenseContext &= 1, push(suspenseStackCursor, suspenseContext, workInProgress), next;
}
return null;
case 20:
case 21:
case 22:
break;
case 23:
case 24:
if (popRenderLanes(workInProgress), null !== current) {
var _nextState = workInProgress.memoizedState;
null !== current.memoizedState != (null !== _nextState) && "unstable-defer-without-hiding" !== newProps.mode && (workInProgress.flags |= 4);
}
return null;
}
throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
}
function unwindInterruptedWork(interruptedWork) {
switch(interruptedWork.tag){
case 1:
null != interruptedWork.type.childContextTypes && popContext(interruptedWork);
break;
case 3:
popHostContainer(interruptedWork), popTopLevelContextObject(interruptedWork), resetWorkInProgressVersions();
break;
case 5:
popHostContext(interruptedWork);
break;
case 4:
popHostContainer(interruptedWork);
break;
case 13:
case 19:
pop(suspenseStackCursor, interruptedWork);
break;
case 10:
popProvider(interruptedWork);
break;
case 23:
case 24:
popRenderLanes(interruptedWork);
}
}
function createCapturedValue(value, source) {
// If the value is an error, call this function immediately after it is thrown
// so the stack is accurate.
return {
value: value,
source: source,
stack: getStackByFiberInDevAndProd(source)
};
}
function logCapturedError(boundary, errorInfo) {
try {
var error = errorInfo.value, source = errorInfo.source, stack = errorInfo.stack;
// `preventDefault()` in window `error` handler.
// We record this information as an expando on the error.
if (null != error && error._suppressLogging) {
if (1 === boundary.tag) // The error is recoverable and was silenced.
// Ignore it and don't print the stack addendum.
// This is handy for testing error boundaries without noise.
return;
// The error is fatal. Since the silencing might have
// been accidental, we'll surface it anyway.
// However, the browser would have silenced the original error
// so we'll print it first, and then print the stack addendum.
console.error(error); // Don't transform to our wrapper
// For a more detailed description of this block, see:
// https://github.com/facebook/react/pull/13384
}
var componentName = source ? getComponentName(source.type) : null, errorBoundaryName = getComponentName(boundary.type), combinedMessage = (componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:") + "\n" + (null !== stack ? stack : "") + "\n\n" + (errorBoundaryName ? "React will try to recreate this component tree from scratch using the error boundary you provided, " + errorBoundaryName + "." : "Consider adding an error boundary to your tree to customize error handling behavior.\nVisit https://reactjs.org/link/error-boundaries to learn more about error boundaries.");
// We don't include the original error message and JS stack because the browser
// has already printed it. Even if the application swallows the error, it is still
// displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
console.error(combinedMessage); // Don't transform to our wrapper
} catch (e) {
// This method must not throw, or React internal state will get messed up.
// If console.error is overridden, or logCapturedError() shows a dialog that throws,
// we want to report this error outside of the normal stack as a last resort.
// https://github.com/facebook/react/issues/13188
setTimeout(function() {
throw e;
});
}
}
// Mutation mode
appendAllChildren = function(parent, workInProgress, needsVisibilityToggle, isHidden) {
for(// We only have the top Fiber that was created but we need recurse down its
// children to find all the terminal nodes.
var node = workInProgress.child; null !== node;){
if (5 === node.tag || 6 === node.tag) !function(parentInstance, child) {
parentInstance.appendChild(child);
}(parent, node.stateNode);
else if (4 === node.tag) ;
else if (null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === workInProgress) return;
for(; null === node.sibling;){
if (null === node.return || node.return === workInProgress) return;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
}, updateHostContainer = function(workInProgress) {
// Noop
}, updateHostComponent$1 = function(current, workInProgress, type, newProps, rootContainerInstance) {
// If we have an alternate, that means this is an update and we need to
// schedule a side-effect to do the updates.
var oldProps = current.memoizedProps;
if (oldProps !== newProps) {
// component is hitting the resume path. Figure out why. Possibly
// related to `hidden`.
var updatePayload = function(domElement, type, oldProps, newProps, rootContainerInstance, hostContext) {
if (typeof newProps.children != typeof oldProps.children && ("string" == typeof newProps.children || "number" == typeof newProps.children)) {
var string = "" + newProps.children, ownAncestorInfo = updatedAncestorInfo(hostContext.ancestorInfo, type);
validateDOMNesting(null, string, ownAncestorInfo);
}
return function(domElement, tag, lastRawProps, nextRawProps, rootContainerElement) {
validatePropertiesInDevelopment(tag, nextRawProps);
var lastProps, nextProps, propKey, styleName, updatePayload = null;
switch(tag){
case "input":
lastProps = getHostProps(domElement, lastRawProps), nextProps = getHostProps(domElement, nextRawProps), updatePayload = [];
break;
case "option":
lastProps = getHostProps$1(domElement, lastRawProps), nextProps = getHostProps$1(domElement, nextRawProps), updatePayload = [];
break;
case "select":
lastProps = getHostProps$2(domElement, lastRawProps), nextProps = getHostProps$2(domElement, nextRawProps), updatePayload = [];
break;
case "textarea":
lastProps = getHostProps$3(domElement, lastRawProps), nextProps = getHostProps$3(domElement, nextRawProps), updatePayload = [];
break;
default:
lastProps = lastRawProps, nextProps = nextRawProps, "function" != typeof lastProps.onClick && "function" == typeof nextProps.onClick && // TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(domElement);
}
assertValidProps(tag, nextProps);
var styleUpdates = null;
for(propKey in lastProps)if (!nextProps.hasOwnProperty(propKey) && lastProps.hasOwnProperty(propKey) && null != lastProps[propKey]) {
if (propKey === STYLE) {
var lastStyle = lastProps[propKey];
for(styleName in lastStyle)lastStyle.hasOwnProperty(styleName) && (styleUpdates || (styleUpdates = {}), styleUpdates[styleName] = "");
} else propKey !== DANGEROUSLY_SET_INNER_HTML && propKey !== CHILDREN && propKey !== SUPPRESS_CONTENT_EDITABLE_WARNING && propKey !== SUPPRESS_HYDRATION_WARNING && propKey !== AUTOFOCUS && (registrationNameDependencies.hasOwnProperty(propKey) ? updatePayload || (updatePayload = []) : // For all other deleted properties we add it to the queue. We use
// the allowed property list in the commit phase instead.
(updatePayload = updatePayload || []).push(propKey, null));
}
for(propKey in nextProps){
var nextProp = nextProps[propKey], lastProp = null != lastProps ? lastProps[propKey] : void 0;
if (nextProps.hasOwnProperty(propKey) && nextProp !== lastProp && (null != nextProp || null != lastProp)) {
if (propKey === STYLE) {
if (nextProp && // Freeze the next style object so that we can assume it won't be
// mutated. We have already warned for this in the past.
Object.freeze(nextProp), lastProp) {
// Unset styles on `lastProp` but not on `nextProp`.
for(styleName in lastProp)!lastProp.hasOwnProperty(styleName) || nextProp && nextProp.hasOwnProperty(styleName) || (styleUpdates || (styleUpdates = {}), styleUpdates[styleName] = "");
// Update styles that changed since `lastProp`.
for(styleName in nextProp)nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName] && (styleUpdates || (styleUpdates = {}), styleUpdates[styleName] = nextProp[styleName]);
} else styleUpdates || (updatePayload || (updatePayload = []), updatePayload.push(propKey, styleUpdates)), styleUpdates = nextProp;
} else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
var nextHtml = nextProp ? nextProp[HTML$1] : void 0, lastHtml = lastProp ? lastProp[HTML$1] : void 0;
null != nextHtml && lastHtml !== nextHtml && (updatePayload = updatePayload || []).push(propKey, nextHtml);
} else propKey === CHILDREN ? ("string" == typeof nextProp || "number" == typeof nextProp) && (updatePayload = updatePayload || []).push(propKey, "" + nextProp) : propKey !== SUPPRESS_CONTENT_EDITABLE_WARNING && propKey !== SUPPRESS_HYDRATION_WARNING && (registrationNameDependencies.hasOwnProperty(propKey) ? (null != nextProp && ("function" != typeof nextProp && warnForInvalidEventListener(propKey, nextProp), "onScroll" === propKey && listenToNonDelegatedEvent("scroll", domElement)), updatePayload || lastProp === nextProp || // This is a special case. If any listener updates we need to ensure
// that the "current" props pointer gets updated so we need a commit
// to update this element.
(updatePayload = [])) : "object" == typeof nextProp && null !== nextProp && nextProp.$$typeof === REACT_OPAQUE_ID_TYPE ? // If we encounter useOpaqueReference's opaque object, this means we are hydrating.
// In this case, call the opaque object's toString function which generates a new client
// ID so client and server IDs match and throws to rerender.
nextProp.toString() : // For any other property we always add it to the queue and then we
// filter it out using the allowed property list during the commit.
(updatePayload = updatePayload || []).push(propKey, nextProp));
}
}
return styleUpdates && (/**
* When mixing shorthand and longhand property names, we warn during updates if
* we expect an incorrect result to occur. In particular, we warn for:
*
* Updating a shorthand property (longhand gets overwritten):
* {font: 'foo', fontVariant: 'bar'} -> {font: 'baz', fontVariant: 'bar'}
* becomes .style.font = 'baz'
* Removing a shorthand property (longhand gets lost too):
* {font: 'foo', fontVariant: 'bar'} -> {fontVariant: 'bar'}
* becomes .style.font = ''
* Removing a longhand property (should revert to shorthand; doesn't):
* {font: 'foo', fontVariant: 'bar'} -> {font: 'foo'}
* becomes .style.fontVariant = ''
*/ function(styleUpdates, nextStyles) {
if (nextStyles) {
var expandedUpdates = expandShorthandMap(styleUpdates), expandedStyles = expandShorthandMap(nextStyles), warnedAbout = {};
for(var key in expandedUpdates){
var originalKey = expandedUpdates[key], correctOriginalKey = expandedStyles[key];
if (correctOriginalKey && originalKey !== correctOriginalKey) {
var value, warningKey = originalKey + "," + correctOriginalKey;
if (warnedAbout[warningKey]) continue;
warnedAbout[warningKey] = !0, error("%s a style property during rerender (%s) when a conflicting property is set (%s) can lead to styling bugs. To avoid this, don't mix shorthand and non-shorthand properties for the same value; instead, replace the shorthand with separate values.", null == (value = styleUpdates[originalKey]) || "boolean" == typeof value || "" === value ? "Removing" : "Updating", originalKey, correctOriginalKey);
}
}
}
}(styleUpdates, nextProps[STYLE]), (updatePayload = updatePayload || []).push(STYLE, styleUpdates)), updatePayload;
} // Apply the diff.
(domElement, type, oldProps, newProps);
}(workInProgress.stateNode, type, oldProps, newProps, 0, getHostContext()); // TODO: Type this specific to this type of component.
workInProgress.updateQueue = updatePayload, updatePayload && markUpdate(workInProgress);
} // If we get updated because one of our children updated, we don't
}, updateHostText$1 = function(current, workInProgress, oldText, newText) {
// If the text differs, mark it as an update. All the work in done in commitWork.
oldText !== newText && markUpdate(workInProgress);
};
var PossiblyWeakMap$1 = "function" == typeof WeakMap ? WeakMap : Map;
function createRootErrorUpdate(fiber, errorInfo, lane) {
var update = createUpdate(-1, lane); // Unmount the root by rendering null.
update.tag = 3, // being called "element".
update.payload = {
element: null
};
var error = errorInfo.value;
return update.callback = function() {
onUncaughtError(error), logCapturedError(fiber, errorInfo);
}, update;
}
function createClassErrorUpdate(fiber, errorInfo, lane) {
var update = createUpdate(-1, lane);
update.tag = 3;
var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
if ("function" == typeof getDerivedStateFromError) {
var error$1 = errorInfo.value;
update.payload = function() {
return logCapturedError(fiber, errorInfo), getDerivedStateFromError(error$1);
};
}
var inst = fiber.stateNode;
return null !== inst && "function" == typeof inst.componentDidCatch ? update.callback = function() {
markFailedErrorBoundaryForHotReloading(fiber), "function" != typeof getDerivedStateFromError && (instance = this, null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([
instance
]) : legacyErrorBoundariesThatAlreadyFailed.add(instance), logCapturedError(fiber, errorInfo));
var instance, error$1 = errorInfo.value, stack = errorInfo.stack;
this.componentDidCatch(error$1, {
componentStack: null !== stack ? stack : ""
}), "function" == typeof getDerivedStateFromError || (1 & fiber.lanes) != 0 || error("%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown");
} : update.callback = function() {
markFailedErrorBoundaryForHotReloading(fiber);
}, update;
}
var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
var PossiblyWeakSet = "function" == typeof WeakSet ? WeakSet : Set, callComponentWillUnmountWithTimer = function(current, instance) {
instance.props = current.memoizedProps, instance.state = current.memoizedState, instance.componentWillUnmount();
};
function safelyDetachRef(current) {
var ref = current.ref;
null !== ref && ("function" == typeof ref ? (invokeGuardedCallback(null, ref, null, null), hasError && captureCommitPhaseError(current, clearCaughtError())) : ref.current = null);
}
function hideOrUnhideAllChildren(finishedWork, isHidden) {
for(// We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
var node = finishedWork;;){
if (5 === node.tag) {
var instance = node.stateNode;
isHidden ? function(instance) {
var style = instance.style;
"function" == typeof style.setProperty ? style.setProperty("display", "none", "important") : style.display = "none";
}(instance) : function(instance, props) {
var styleProp = props.style, display = null != styleProp && styleProp.hasOwnProperty("display") ? styleProp.display : null;
instance.style.display = dangerousStyleValue("display", display);
}(node.stateNode, node.memoizedProps);
} else if (6 === node.tag) {
var _instance3 = node.stateNode;
isHidden ? _instance3.nodeValue = "" : _instance3.nodeValue = node.memoizedProps;
} else if ((23 === node.tag || 24 === node.tag) && null !== node.memoizedState && node !== finishedWork) ;
else if (null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === finishedWork) return;
for(; null === node.sibling;){
if (null === node.return || node.return === finishedWork) return;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
}
// deletion, so don't let them throw. Host-originating errors should
// interrupt deletion, so it's okay
function commitUnmount(finishedRoot, current, renderPriorityLevel) {
switch(!function(fiber) {
if (injectedHook && "function" == typeof injectedHook.onCommitFiberUnmount) try {
injectedHook.onCommitFiberUnmount(rendererID, fiber);
} catch (err) {
hasLoggedError || (hasLoggedError = !0, error("React instrumentation encountered an error: %s", err));
}
}(current), current.tag){
case 0:
case 11:
case 14:
case 15:
case 22:
var updateQueue = current.updateQueue;
if (null !== updateQueue) {
var lastEffect = updateQueue.lastEffect;
if (null !== lastEffect) {
var firstEffect = lastEffect.next, effect = firstEffect;
do {
var _effect2 = effect, destroy = _effect2.destroy, tag = _effect2.tag;
void 0 !== destroy && ((4 & tag) != /* */ 0 ? enqueuePendingPassiveHookEffectUnmount(current, effect) : (invokeGuardedCallback(null, destroy, null), hasError && captureCommitPhaseError(current, clearCaughtError()))), effect = effect.next;
}while (effect !== firstEffect)
}
}
return;
case 1:
safelyDetachRef(current);
var instance = current.stateNode;
"function" == typeof instance.componentWillUnmount && (invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current, instance), hasError && captureCommitPhaseError(current, clearCaughtError()));
return;
case 5:
safelyDetachRef(current);
return;
case 4:
unmountHostComponents(finishedRoot, current);
return;
case 20:
case 18:
case 21:
return;
}
}
function detachFiberMutation(fiber) {
// Cut off the return pointers to disconnect it from the tree. Ideally, we
// should clear the child pointer of the parent alternate to let this
// get GC:ed but we don't know which for sure which parent is the current
// one so we'll settle for GC:ing the subtree of this child. This child
// itself will be GC:ed when the parent updates the next time.
// Note: we cannot null out sibling here, otherwise it can cause issues
// with findDOMNode and how it requires the sibling field to carry out
// traversal in a later effect. See PR #16820. We now clear the sibling
// field after effects, see: detachFiberAfterEffects.
//
// Don't disconnect stateNode now; it will be detached in detachFiberAfterEffects.
// It may be required if the current component is an error boundary,
// and one of its descendants throws while unmounting a passive effect.
fiber.alternate = null, fiber.child = null, fiber.dependencies = null, fiber.firstEffect = null, fiber.lastEffect = null, fiber.memoizedProps = null, fiber.memoizedState = null, fiber.pendingProps = null, fiber.return = null, fiber.updateQueue = null, fiber._debugOwner = null;
}
function isHostParent(fiber) {
return 5 === fiber.tag || 3 === fiber.tag || 4 === fiber.tag;
}
function commitPlacement(finishedWork) {
var parent, isContainer, parentFiber = function(fiber) {
for(var parent = fiber.return; null !== parent;){
if (isHostParent(parent)) return parent;
parent = parent.return;
}
throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
}(finishedWork), parentStateNode = parentFiber.stateNode; // Note: these two variables *must* always be updated together.
switch(parentFiber.tag){
case 5:
parent = parentStateNode, isContainer = !1;
break;
case 3:
case 4:
parent = parentStateNode.containerInfo, isContainer = !0;
break;
default:
throw Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.");
}
16 & parentFiber.flags && (setTextContent(parent, ""), parentFiber.flags &= -17);
var before = function(fiber) {
// We're going to search forward into the tree until we find a sibling host
// node. Unfortunately, if multiple insertions are done in a row we have to
// search past them. This leads to exponential search for the next sibling.
// TODO: Find a more efficient way to do this.
var node = fiber;
siblings: for(;;){
// If we didn't find anything, let's try the next sibling.
for(; null === node.sibling;){
if (null === node.return || isHostParent(node.return)) // If we pop out of the root or hit the parent the fiber we are the
// last sibling.
return null;
node = node.return;
}
for(node.sibling.return = node.return, node = node.sibling; 5 !== node.tag && 6 !== node.tag && 18 !== node.tag;){
// If it is not host node and, we might have a host node inside it.
// Try to search down until we find one.
if (2 & node.flags || null === node.child || 4 === node.tag) continue siblings;
// If we don't have a child, try the siblings instead.
node.child.return = node, node = node.child;
} // Check if this host node is stable or about to be placed.
if (!(2 & node.flags)) // Found it!
return node.stateNode;
}
}(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
// children to find all the terminal nodes.
isContainer ? function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
var tag = node.tag, isHost = 5 === tag || 6 === tag;
if (isHost) {
var parentNode, reactRootContainer, stateNode = isHost ? node.stateNode : node.stateNode.instance;
before ? 8 === parent.nodeType ? parent.parentNode.insertBefore(stateNode, before) : parent.insertBefore(stateNode, before) : (8 === parent.nodeType ? (parentNode = parent.parentNode).insertBefore(stateNode, parent) : (parentNode = parent).appendChild(stateNode), null == parent._reactRootContainer && null === parentNode.onclick && // TODO: This cast may not be sound for SVG, MathML or custom elements.
trapClickOnNonInteractiveElement(parentNode));
} else if (4 === tag) ;
else {
var child = node.child;
if (null !== child) {
insertOrAppendPlacementNodeIntoContainer(child, before, parent);
for(var sibling = child.sibling; null !== sibling;)insertOrAppendPlacementNodeIntoContainer(sibling, before, parent), sibling = sibling.sibling;
}
}
}(finishedWork, before, parent) : function insertOrAppendPlacementNode(node, before, parent) {
var tag = node.tag, isHost = 5 === tag || 6 === tag;
if (isHost) {
var stateNode = isHost ? node.stateNode : node.stateNode.instance;
before ? function(parentInstance, child, beforeChild) {
parentInstance.insertBefore(child, beforeChild);
}(parent, stateNode, before) : function(parentInstance, child) {
parentInstance.appendChild(child);
}(parent, stateNode);
} else if (4 === tag) ;
else {
var child = node.child;
if (null !== child) {
insertOrAppendPlacementNode(child, before, parent);
for(var sibling = child.sibling; null !== sibling;)insertOrAppendPlacementNode(sibling, before, parent), sibling = sibling.sibling;
}
}
}(finishedWork, before, parent);
}
function unmountHostComponents(finishedRoot, current, renderPriorityLevel) {
for(// We only have the top Fiber that was deleted but we need to recurse down its
// children to find all the terminal nodes.
var currentParent, currentParentIsContainer, node = current, currentParentIsValid = !1;;){
if (!currentParentIsValid) {
var container, child, parent = node.return;
findParent: for(;;){
if (null === parent) throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
var parentStateNode = parent.stateNode;
switch(parent.tag){
case 5:
currentParent = parentStateNode, currentParentIsContainer = !1;
break findParent;
case 3:
case 4:
currentParent = parentStateNode.containerInfo, currentParentIsContainer = !0;
break findParent;
}
parent = parent.return;
}
currentParentIsValid = !0;
}
if (5 === node.tag || 6 === node.tag) // node from the tree.
(!function(finishedRoot, root, renderPriorityLevel) {
for(// While we're inside a removed host node we don't want to call
// removeChild on the inner nodes because they're removed by the top
// call anyway. We also want to call componentWillUnmount on all
// composites before this host node is removed from the tree. Therefore
// we do an inner loop while we're still inside the host node.
var node = root;;){
// Skip portals because commitUnmount() currently visits them recursively.
if (commitUnmount(finishedRoot, node), null !== node.child && // If we use mutation we drill down into portals using commitUnmount above.
// If we don't use mutation we drill down into portals here instead.
4 !== node.tag) {
node.child.return = node, node = node.child;
continue;
}
if (node === root) return;
for(; null === node.sibling;){
if (null === node.return || node.return === root) return;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
}(finishedRoot, node), currentParentIsContainer) ? (container = currentParent, child = node.stateNode, 8 === container.nodeType ? container.parentNode.removeChild(child) : container.removeChild(child)) : !function(parentInstance, child) {
parentInstance.removeChild(child);
}(currentParent, node.stateNode); // Don't visit children because we already visited them.
else if (4 === node.tag) {
if (null !== node.child) {
// When we go into a portal, it becomes the parent to remove from.
// We will reassign it back when we pop the portal on the way up.
currentParent = node.stateNode.containerInfo, currentParentIsContainer = !0, node.child.return = node, node = node.child;
continue;
}
} else if (commitUnmount(finishedRoot, node), null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === current) return;
for(; null === node.sibling;){
if (null === node.return || node.return === current) return;
4 === (node = node.return).tag && // When we go out of the portal, we need to restore the parent.
// Since we don't keep a stack of them, we will search for it.
(currentParentIsValid = !1);
}
node.sibling.return = node.return, node = node.sibling;
}
}
function commitWork(current, finishedWork) {
switch(finishedWork.tag){
case 0:
case 11:
case 14:
case 15:
case 22:
!function(tag, finishedWork) {
var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
if (null !== lastEffect) {
var firstEffect = lastEffect.next, effect = firstEffect;
do {
if ((3 & effect.tag) === tag) {
// Unmount
var destroy = effect.destroy;
effect.destroy = void 0, void 0 !== destroy && destroy();
}
effect = effect.next;
}while (effect !== firstEffect)
}
}(3, finishedWork);
return;
case 1:
case 12:
case 17:
return;
case 5:
var finishedWork1, instance = finishedWork.stateNode;
if (null != instance) {
// Commit the work prepared earlier.
var node, props, newProps = finishedWork.memoizedProps, oldProps = null !== current ? current.memoizedProps : newProps, type = finishedWork.type, updatePayload = finishedWork.updateQueue; // For hydration we reuse the update path but we treat the oldProps
if (finishedWork.updateQueue = null, null !== updatePayload) {
node = instance, props = newProps, node[internalPropsKey] = props, function(domElement, updatePayload, tag, lastRawProps, nextRawProps) {
var wasMultiple, value;
// changed.
switch("input" === tag && "radio" === nextRawProps.type && null != nextRawProps.name && updateChecked(domElement, nextRawProps), isCustomComponent(tag, lastRawProps), function(domElement, updatePayload, wasCustomComponentTag, isCustomComponentTag) {
// TODO: Handle wasCustomComponentTag
for(var i = 0; i < updatePayload.length; i += 2){
var propKey = updatePayload[i], propValue = updatePayload[i + 1];
propKey === STYLE ? setValueForStyles(domElement, propValue) : propKey === DANGEROUSLY_SET_INNER_HTML ? setInnerHTML(domElement, propValue) : propKey === CHILDREN ? setTextContent(domElement, propValue) : setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);
}
}(domElement, updatePayload, 0, isCustomComponent(tag, nextRawProps)), tag){
case "input":
// Update the wrapper around inputs *after* updating props. This has to
// happen after `updateDOMProperties`. Otherwise HTML5 input validations
// raise warnings and prevent the new value from being assigned.
updateWrapper(domElement, nextRawProps);
break;
case "textarea":
updateWrapper$1(domElement, nextRawProps);
break;
case "select":
// <select> value update needs to occur after <option> children
// reconciliation
wasMultiple = domElement._wrapperState.wasMultiple, domElement._wrapperState.wasMultiple = !!nextRawProps.multiple, null != (value = nextRawProps.value) ? updateOptions(domElement, !!nextRawProps.multiple, value, !1) : !!nextRawProps.multiple !== wasMultiple && (null != nextRawProps.defaultValue ? updateOptions(domElement, !!nextRawProps.multiple, nextRawProps.defaultValue, !0) : // Revert the select back to its default unselected state.
updateOptions(domElement, !!nextRawProps.multiple, nextRawProps.multiple ? [] : "", !1));
}
}(instance, updatePayload, type, oldProps, newProps);
}
}
return;
case 6:
if (null === finishedWork.stateNode) throw Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");
var textInstance = finishedWork.stateNode, newText = finishedWork.memoizedProps;
null !== current && current.memoizedProps, textInstance.nodeValue = newText;
return;
case 3:
var _root = finishedWork.stateNode;
_root.hydrate && (// We've just hydrated. No need to hydrate again.
_root.hydrate = !1, // Retry if any event replaying was blocked on this.
retryIfBlockedOn(_root.containerInfo));
return;
case 13:
null !== (finishedWork1 = finishedWork).memoizedState && (globalMostRecentFallbackTime = now(), hideOrUnhideAllChildren(finishedWork1.child, !0)), attachSuspenseRetryListeners(finishedWork);
return;
case 19:
attachSuspenseRetryListeners(finishedWork);
return;
case 20:
case 21:
break;
case 23:
case 24:
var newState = finishedWork.memoizedState;
hideOrUnhideAllChildren(finishedWork, null !== newState);
return;
}
throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
}
function attachSuspenseRetryListeners(finishedWork) {
// If this boundary just timed out, then it will have a set of wakeables.
// For each wakeable, attach a listener so that when it resolves, React
// attempts to re-render the boundary in the primary (pre-timeout) state.
var wakeables = finishedWork.updateQueue;
if (null !== wakeables) {
finishedWork.updateQueue = null;
var retryCache = finishedWork.stateNode;
null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet()), wakeables.forEach(function(wakeable) {
// Memoize using the boundary fiber to prevent redundant listeners.
var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
retryCache.has(wakeable) || (!0 !== wakeable.__reactDoNotTraceInteractions && (retry = unstable_wrap(retry)), retryCache.add(wakeable), wakeable.then(retry, retry));
});
}
} // This function detects when a Suspense boundary goes from visible to hidden.
if ("function" == typeof Symbol && Symbol.for) {
var symbolFor$1 = Symbol.for;
symbolFor$1("selector.component"), symbolFor$1("selector.has_pseudo_class"), symbolFor$1("selector.role"), symbolFor$1("selector.test_id"), symbolFor$1("selector.text");
}
var commitHooks = [], ceil = Math.ceil, ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher, ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner, IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing, executionContext = /* */ 0, workInProgressRoot = null, workInProgress = null, workInProgressRootRenderLanes = 0, subtreeRenderLanes = 0, subtreeRenderLanesCursor = createCursor(0), workInProgressRootExitStatus = 0, workInProgressRootFatalError = null, workInProgressRootIncludedLanes = 0, workInProgressRootSkippedLanes = 0, workInProgressRootUpdatedLanes = 0, workInProgressRootPingedLanes = 0, mostRecentlyUpdatedRoot = null, globalMostRecentFallbackTime = 0, workInProgressRootRenderTargetTime = 1 / 0;
function resetRenderTimer() {
workInProgressRootRenderTargetTime = now() + 500;
}
var nextEffect = null, hasUncaughtError = !1, firstUncaughtError = null, legacyErrorBoundariesThatAlreadyFailed = null, rootDoesHavePassiveEffects = !1, rootWithPendingPassiveEffects = null, pendingPassiveEffectsRenderPriority = 90, pendingPassiveEffectsLanes = 0, pendingPassiveHookEffectsMount = [], pendingPassiveHookEffectsUnmount = [], rootsWithPendingDiscreteUpdates = null, nestedUpdateCount = 0, rootWithNestedUpdates = null, nestedPassiveUpdateCount = 0, spawnedWorkDuringRender = null, currentEventTime = -1, currentEventWipLanes = 0, currentEventPendingLanes = 0, isFlushingPassiveEffects = !1, focusedInstanceHandle = null, shouldFireAfterActiveInstanceBlur = !1;
function requestEventTime() {
return (48 & executionContext) != 0 ? now() : -1 !== currentEventTime ? currentEventTime : currentEventTime = now() // We're not inside React, so we may be in the middle of a browser event.
;
}
function requestUpdateLane(fiber) {
// Special cases
var wipLanes, lane, lane1, mode = fiber.mode;
if ((2 & mode) == 0) return 1;
// The algorithm for assigning an update to a lane should be stable for all
if ((4 & mode) == 0) return 99 === getCurrentPriorityLevel() ? 1 : 2;
if (0 === currentEventWipLanes && (currentEventWipLanes = workInProgressRootIncludedLanes), 0 !== ReactCurrentBatchConfig.transition) return 0 !== currentEventPendingLanes && (currentEventPendingLanes = null !== mostRecentlyUpdatedRoot ? mostRecentlyUpdatedRoot.pendingLanes : 0), wipLanes = currentEventWipLanes, 0 === (lane = pickArbitraryLane(4186112 & ~currentEventPendingLanes)) && 0 === // If all lanes have pending work, look for a lane that isn't currently
// being worked on.
(lane = pickArbitraryLane(4186112 & ~wipLanes)) && // If everything is being worked on, pick any lane. This has the
// effect of interrupting the current work-in-progress.
(lane = pickArbitraryLane(4186112)), lane;
// TODO: Remove this dependency on the Scheduler priority.
// To do that, we're replacing it with an update lane priority.
var schedulerPriority = getCurrentPriorityLevel(); // The old behavior was using the priority level of the Scheduler.
return(// TODO: Temporary. We're removing the concept of discrete updates.
(/* */ 4 & executionContext) != 0 && 98 === schedulerPriority ? findUpdateLane(12, currentEventWipLanes) : findUpdateLane(function(schedulerPriorityLevel) {
switch(schedulerPriorityLevel){
case 99:
return 15;
case 98:
return 10;
case 97:
case 96:
// TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
return 8;
case 95:
return 2;
default:
return 0;
}
}(schedulerPriority), currentEventWipLanes));
}
function scheduleUpdateOnFiber(fiber, lane, eventTime) {
(function() {
if (nestedUpdateCount > 50) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");
nestedPassiveUpdateCount > 50 && (nestedPassiveUpdateCount = 0, error("Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render."));
})(), function(fiber) {
if (isRendering && (/* */ 16 & executionContext) != 0 && !isUpdatingOpaqueValueInRenderPhase) switch(fiber.tag){
case 0:
case 11:
case 15:
var renderingComponentName = workInProgress && getComponentName(workInProgress.type) || "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
didWarnAboutUpdateInRenderForAnotherComponent.has(renderingComponentName) || (didWarnAboutUpdateInRenderForAnotherComponent.add(renderingComponentName), error("Cannot update a component (`%s`) while rendering a different component (`%s`). To locate the bad setState() call inside `%s`, follow the stack trace as described in https://reactjs.org/link/setstate-in-render", getComponentName(fiber.type) || "Unknown", renderingComponentName, renderingComponentName));
break;
case 1:
didWarnAboutUpdateInRender || (error("Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."), didWarnAboutUpdateInRender = !0);
}
} // a 'shared' variable that changes when act() opens/closes in tests.
(fiber);
var root = markUpdateLaneFromFiberToRoot(fiber, lane);
if (null === root) return function(fiber) {
var tag = fiber.tag;
if ((3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag || 22 === tag) && (/* */ 8192 & fiber.flags) == 0) {
// the problematic code almost always lies inside that component.
var componentName = getComponentName(fiber.type) || "ReactComponent";
if (null !== didWarnStateUpdateForUnmountedComponent) {
if (didWarnStateUpdateForUnmountedComponent.has(componentName)) return;
didWarnStateUpdateForUnmountedComponent.add(componentName);
} else didWarnStateUpdateForUnmountedComponent = new Set([
componentName
]);
if (isFlushingPassiveEffects) ;
else {
var previousFiber = current;
try {
setCurrentFiber(fiber), error("Can't perform a React state update on an unmounted component. This is a no-op, but it indicates a memory leak in your application. To fix, cancel all subscriptions and asynchronous tasks in %s.", 1 === tag ? "the componentWillUnmount method" : "a useEffect cleanup function");
} finally{
previousFiber ? setCurrentFiber(fiber) : resetCurrentFiber();
}
}
} // If there are pending passive effects unmounts for this Fiber,
}(fiber), null;
// Mark that the root has a pending update.
markRootUpdated(root, lane, eventTime), root === workInProgressRoot && (workInProgressRootUpdatedLanes |= lane, 4 === workInProgressRootExitStatus && // The root already suspended with a delay, which means this render
// definitely won't finish. Since we have a new update, let's mark it as
// suspended now, right before marking the incoming update. This has the
// effect of interrupting the current render and switching to the update.
// TODO: Make sure this doesn't override pings that happen while we've
// already started rendering.
markRootSuspended$1(root, workInProgressRootRenderLanes)); // TODO: requestUpdateLanePriority also reads the priority. Pass the
// priority as an argument to that function and this one.
var priorityLevel = getCurrentPriorityLevel();
1 === lane ? // Check if we're inside unbatchedUpdates
(/* */ 8 & executionContext) != 0 && // Check if we're not already rendering
(48 & executionContext) == 0 ? (// Register pending interactions on the root to avoid losing traced interaction data.
schedulePendingInteractions(root, lane), // root inside of batchedUpdates should be synchronous, but layout updates
// should be deferred until the end of the batch.
performSyncWorkOnRoot(root)) : (ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, lane), 0 === executionContext && (// Flush the synchronous work now, unless we're already working or inside
// a batch. This is intentionally inside scheduleUpdateOnFiber instead of
// scheduleCallbackForFiber to preserve the ability to schedule a callback
// without immediately flushing it. We only do this for user-initiated
// updates, to preserve historical behavior of legacy mode.
resetRenderTimer(), flushSyncCallbackQueue())) : ((4 & executionContext) != 0 && // Only updates at user-blocking priority or greater are considered
// discrete, even inside a discrete event.
(98 === priorityLevel || 99 === priorityLevel) && (null === rootsWithPendingDiscreteUpdates ? rootsWithPendingDiscreteUpdates = new Set([
root
]) : rootsWithPendingDiscreteUpdates.add(root)), ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, lane)), // `requestUpdateLane`. We assume it's the same as the root being updated,
// since in the common case of a single root app it probably is. If it's not
// the same root, then it's not a huge deal, we just might batch more stuff
// together more than necessary.
mostRecentlyUpdatedRoot = root;
} // This is split into a separate function so we can mark a fiber with pending
// work without treating it as a typical update that originates from an event;
// e.g. retrying a Suspense boundary isn't an update, but it does schedule work
// on a fiber.
function markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
a = sourceFiber.lanes, // Update the source fiber's lanes
sourceFiber.lanes = a | lane;
var a, alternate = sourceFiber.alternate;
null !== alternate && (alternate.lanes = alternate.lanes | lane), null === alternate && (1026 & sourceFiber.flags) != 0 && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
for(var node = sourceFiber, parent = sourceFiber.return; null !== parent;)(parent.childLanes = parent.childLanes | lane, null !== (alternate = parent.alternate)) ? alternate.childLanes = alternate.childLanes | lane : (1026 & parent.flags) != 0 && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber), node = parent, parent = parent.return;
return 3 === node.tag ? node.stateNode : null;
} // Use this function to schedule a task for a root. There's only one task per
// root; if a task was already scheduled, we'll check to make sure the priority
// of the existing task is the same as the priority of the next level that the
// root has work on. This function is called on every update, and right before
// exiting a task.
function ensureRootIsScheduled(root, currentTime) {
var callback, newCallbackNode, existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
!// expired so we know to work on those next.
function(root, currentTime) {
for(// TODO: This gets called every time we yield. We can optimize by storing
// the earliest expiration time on the root. Then use that to quickly bail out
// of this function.
var pendingLanes = root.pendingLanes, suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes, expirationTimes = root.expirationTimes, lanes = pendingLanes; lanes > 0;){
var index = pickArbitraryLaneIndex(lanes), lane = 1 << index, expirationTime = expirationTimes[index];
-1 === expirationTime ? ((lane & suspendedLanes) == 0 || (lane & pingedLanes) != 0) && // Assumes timestamps are monotonically increasing.
(expirationTimes[index] = function(lane, currentTime) {
// TODO: Expiration heuristic is constant per lane, so could use a map.
getHighestPriorityLanes(lane);
var priority = return_highestLanePriority;
return priority >= 10 ? currentTime + 250 : priority >= 6 ? currentTime + 5000 : -1;
}(lane, currentTime)) : expirationTime <= currentTime && // This lane expired
(root.expiredLanes |= lane), lanes &= ~lane;
}
} // This returns the highest priority pending lanes regardless of whether they
(root, currentTime);
var nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : 0), newCallbackPriority = return_highestLanePriority; // This returns the priority level computed during the `getNextLanes` call.
if (0 === nextLanes) {
// Special case: There's nothing to work on.
null !== existingCallbackNode && (existingCallbackNode !== fakeCallbackNode && unstable_cancelCallback(existingCallbackNode), root.callbackNode = null, root.callbackPriority = 0);
return;
} // Check if there's an existing task. We may be able to reuse it.
if (null !== existingCallbackNode) {
if (root.callbackPriority === newCallbackPriority) // The priority hasn't changed. We can reuse the existing task. Exit.
return;
// The priority changed. Cancel the existing callback. We'll schedule a new
// one below.
existingCallbackNode !== fakeCallbackNode && unstable_cancelCallback(existingCallbackNode);
} // Schedule a new callback.
15 === newCallbackPriority ? (callback = performSyncWorkOnRoot.bind(null, root), null === syncQueue ? (syncQueue = [
callback
], immediateQueueCallbackNode = unstable_scheduleCallback(unstable_ImmediatePriority, flushSyncCallbackQueueImpl)) : // Push onto existing queue. Don't need to schedule a callback because
// we already scheduled one when we created the queue.
syncQueue.push(callback), // Special case: Sync React callbacks are scheduled on a special
// internal queue
newCallbackNode = fakeCallbackNode) : newCallbackNode = 14 === newCallbackPriority ? scheduleCallback(99, performSyncWorkOnRoot.bind(null, root)) : scheduleCallback(function(lanePriority) {
switch(lanePriority){
case 15:
case 14:
return 99;
case 13:
case 12:
case 11:
case 10:
return 98;
case 9:
case 8:
case 7:
case 6:
case 4:
case 5:
return 97;
case 3:
case 2:
case 1:
return 95;
case 0:
return 90;
default:
throw Error("Invalid update priority: " + lanePriority + ". This is a bug in React.");
}
}(newCallbackPriority), performConcurrentWorkOnRoot.bind(null, root)), root.callbackPriority = newCallbackPriority, root.callbackNode = newCallbackNode;
} // This is the entry point for every concurrent task, i.e. anything that
// goes through Scheduler.
function performConcurrentWorkOnRoot(root) {
if (// Since we know we're in a React event, we can clear the current
// event time. The next update will compute a new event time.
currentEventTime = -1, currentEventWipLanes = 0, currentEventPendingLanes = 0, (48 & executionContext) != 0) throw Error("Should not already be working.");
// Flush any pending passive effects before deciding which lanes to work on,
// in case they schedule additional work.
var originalCallbackNode = root.callbackNode;
if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode) // The current task was canceled. Exit. We don't need to call
// `ensureRootIsScheduled` because the check above implies either that
// there's a new task, or that there's no remaining work on this root.
return null;
// Determine the next expiration time to work on, using the fields stored
// on the root.
var lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : 0);
if (0 === lanes) // Defensive coding. This is never expected to happen.
return null;
var exitStatus = function(root, lanes) {
var prevExecutionContext = executionContext;
executionContext |= 16;
var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
(workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) && (resetRenderTimer(), prepareFreshStack(root, lanes), startWorkOnPendingInteractions(root, lanes));
for(var prevInteractions = pushInteractions(root);;)try {
!/** @noinline */ function() {
// Perform work until Scheduler asks us to yield
for(; null !== workInProgress && !unstable_shouldYield();)performUnitOfWork(workInProgress);
}();
break;
} catch (thrownValue) {
handleError(root, thrownValue);
}
return (resetContextDependencies(), popInteractions(prevInteractions), ReactCurrentDispatcher$2.current = prevDispatcher, executionContext = prevExecutionContext, null !== workInProgress) ? 0 : (workInProgressRoot = null, workInProgressRootRenderLanes = 0, workInProgressRootExitStatus);
}(root, lanes);
if ((workInProgressRootIncludedLanes & workInProgressRootUpdatedLanes) != 0) // The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// So we'll throw out the current work and restart.
prepareFreshStack(root, 0);
else if (0 !== exitStatus) {
if (2 === exitStatus && (executionContext |= /* */ 64, root.hydrate && (root.hydrate = !1, clearContainer(root.containerInfo)), 0 !== // synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
(lanes = getLanesToRetrySynchronouslyOnError(root)) && (exitStatus = renderRootSync(root, lanes))), 1 === exitStatus) {
var fatalError = workInProgressRootFatalError;
throw prepareFreshStack(root, 0), markRootSuspended$1(root, lanes), ensureRootIsScheduled(root, now()), fatalError;
} // We now have a consistent tree. The next step is either to commit it,
// or, if something suspended, wait to commit it after a timeout.
var finishedWork = root.current.alternate;
root.finishedWork = finishedWork, root.finishedLanes = lanes, function(root, exitStatus, lanes) {
switch(exitStatus){
case 0:
case 1:
throw Error("Root did not complete. This is a bug in React.");
// Flow knows about invariant, so it complains if I add a break
// statement, but eslint doesn't know about invariant, so it complains
// if I do. eslint-disable-next-line no-fallthrough
case 2:
case 5:
// We should have already attempted to retry this tree. If we reached
// this point, it errored again. Commit it.
commitRoot(root);
break;
case 3:
// should immediately commit it or wait a bit.
if (markRootSuspended$1(root, lanes), includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
!function() {
// Never force flush in production. This function should get stripped out.
return actingUpdatesScopeDepth > 0;
}()) {
// This render only included retries, no updates. Throttle committing
// retries so that we don't show too many loading states too quickly.
var msUntilTimeout = globalMostRecentFallbackTime + 500 - now(); // Don't bother with a very short suspense time.
if (msUntilTimeout > 10) {
if (0 !== getNextLanes(root, 0)) break;
var suspendedLanes = root.suspendedLanes;
if ((suspendedLanes & lanes) !== lanes) {
requestEventTime(), markRootPinged(root, suspendedLanes);
break;
} // The render is suspended, it hasn't timed out, and there's no
// lower priority work to do. Instead of committing the fallback
// immediately, wait for more data to arrive.
root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), msUntilTimeout);
break;
}
} // The work expired. Commit immediately.
commitRoot(root);
break;
case 4:
if (markRootSuspended$1(root, lanes), (4186112 & lanes) === lanes) break;
if (!function() {
return actingUpdatesScopeDepth > 0;
}()) {
// This is not a transition, but we did trigger an avoided state.
// Schedule a placeholder to display after a short delay, using the Just
// Noticeable Difference.
// TODO: Is the JND optimization worth the added complexity? If this is
// the only reason we track the event time, then probably not.
// Consider removing.
var timeElapsed, mostRecentEventTime = function(root, lanes) {
for(var eventTimes = root.eventTimes, mostRecentEventTime = -1; lanes > 0;){
var index = pickArbitraryLaneIndex(lanes), lane = 1 << index, eventTime = eventTimes[index];
eventTime > mostRecentEventTime && (mostRecentEventTime = eventTime), lanes &= ~lane;
}
return mostRecentEventTime;
}(root, lanes), timeElapsedMs = now() - mostRecentEventTime, _msUntilTimeout = ((timeElapsed = timeElapsedMs) < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : 1960 * ceil(timeElapsed / 1960)) - timeElapsedMs;
if (_msUntilTimeout > 10) {
// Instead of committing the fallback immediately, wait for more data
// to arrive.
root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout);
break;
}
} // Commit the placeholder.
commitRoot(root);
break;
default:
throw Error("Unknown root exit status.");
}
}(root, exitStatus, lanes);
}
return (ensureRootIsScheduled(root, now()), root.callbackNode === originalCallbackNode) ? performConcurrentWorkOnRoot.bind(null, root) : null;
}
function markRootSuspended$1(root, suspendedLanes) {
// When suspending, we should always exclude lanes that were pinged or (more
// rarely, since we try to avoid it) updated during the render phase.
// TODO: Lol maybe there's a better way to factor this besides this
// obnoxiously named function :)
suspendedLanes &= ~workInProgressRootPingedLanes, function(root, suspendedLanes) {
root.suspendedLanes |= suspendedLanes, root.pingedLanes &= ~suspendedLanes;
for(var expirationTimes = root.expirationTimes, lanes = suspendedLanes; lanes > 0;){
var index = pickArbitraryLaneIndex(lanes), lane = 1 << index;
expirationTimes[index] = -1, lanes &= ~lane;
}
}(root, suspendedLanes &= ~workInProgressRootUpdatedLanes);
} // This is the entry point for synchronous tasks that don't go
// through Scheduler
function performSyncWorkOnRoot(root) {
if ((48 & executionContext) != 0) throw Error("Should not already be working.");
if (flushPassiveEffects(), root === workInProgressRoot && (a = root.expiredLanes, (a & workInProgressRootRenderLanes) != 0) ? (exitStatus = renderRootSync(root, // There's a partial tree, and at least one of its lanes has expired. Finish
// rendering it before rendering the rest of the expired work.
lanes = workInProgressRootRenderLanes), (workInProgressRootIncludedLanes & workInProgressRootUpdatedLanes) != 0 && (// The render included lanes that were updated during the render phase.
// For example, when unhiding a hidden tree, we include all the lanes
// that were previously skipped when the tree was hidden. That set of
// lanes is a superset of the lanes we started rendering with.
//
// Note that this only happens when part of the tree is rendered
// concurrently. If the whole tree is rendered synchronously, then there
// are no interleaved events.
lanes = getNextLanes(root, lanes), exitStatus = renderRootSync(root, lanes))) : (lanes = getNextLanes(root, 0), exitStatus = renderRootSync(root, lanes)), 0 !== root.tag && 2 === exitStatus && (executionContext |= 64, root.hydrate && (root.hydrate = !1, clearContainer(root.containerInfo)), 0 !== // synchronously to block concurrent data mutations, and we'll includes
// all pending updates are included. If it still fails after the second
// attempt, we'll give up and commit the resulting tree.
(lanes = getLanesToRetrySynchronouslyOnError(root)) && (exitStatus = renderRootSync(root, lanes))), 1 === exitStatus) {
var a, lanes, exitStatus, fatalError = workInProgressRootFatalError;
throw prepareFreshStack(root, 0), markRootSuspended$1(root, lanes), ensureRootIsScheduled(root, now()), fatalError;
} // We now have a consistent tree. Because this is a sync render, we
// will commit it even if something suspended.
var finishedWork = root.current.alternate;
return root.finishedWork = finishedWork, root.finishedLanes = lanes, commitRoot(root), // pending level.
ensureRootIsScheduled(root, now()), null;
}
function batchedUpdates$1(fn, a) {
var prevExecutionContext = executionContext;
executionContext |= /* */ 1;
try {
return fn(a);
} finally{
0 === (executionContext = prevExecutionContext) && (// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer(), flushSyncCallbackQueue());
}
}
function unbatchedUpdates(fn, a) {
var prevExecutionContext = executionContext;
executionContext &= -2, executionContext |= 8;
try {
return fn(a);
} finally{
0 === (executionContext = prevExecutionContext) && (// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer(), flushSyncCallbackQueue());
}
}
function flushSync(fn, a) {
var prevExecutionContext = executionContext;
if ((48 & prevExecutionContext) != 0) return error("flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."), fn(a);
executionContext |= 1;
try {
if (fn) return runWithPriority$1(99, fn.bind(null, a));
return;
} finally{
executionContext = prevExecutionContext, // Note that this will happen even if batchedUpdates is higher up
// the stack.
flushSyncCallbackQueue();
}
}
function pushRenderLanes(fiber, lanes) {
push(subtreeRenderLanesCursor, subtreeRenderLanes, fiber), subtreeRenderLanes |= lanes, workInProgressRootIncludedLanes |= lanes;
}
function popRenderLanes(fiber) {
subtreeRenderLanes = subtreeRenderLanesCursor.current, pop(subtreeRenderLanesCursor, fiber);
}
function prepareFreshStack(root, lanes) {
root.finishedWork = null, root.finishedLanes = 0;
var timeoutHandle = root.timeoutHandle;
if (-1 !== timeoutHandle && (// The root previous suspended and scheduled a timeout to commit a fallback
// state. Now that we have additional work, cancel the timeout.
root.timeoutHandle = -1, cancelTimeout(timeoutHandle)), null !== workInProgress) for(var interruptedWork = workInProgress.return; null !== interruptedWork;)unwindInterruptedWork(interruptedWork), interruptedWork = interruptedWork.return;
workInProgressRoot = root, workInProgress = createWorkInProgress(root.current, null), workInProgressRootRenderLanes = subtreeRenderLanes = workInProgressRootIncludedLanes = lanes, workInProgressRootExitStatus = 0, workInProgressRootFatalError = null, workInProgressRootSkippedLanes = 0, workInProgressRootUpdatedLanes = 0, workInProgressRootPingedLanes = 0, spawnedWorkDuringRender = null, ReactStrictModeWarnings.discardPendingWarnings();
}
function handleError(root, thrownValue) {
for(;;){
var erroredWork = workInProgress;
try {
if (// Reset module-level state that was set during the render phase.
resetContextDependencies(), resetHooksAfterThrow(), resetCurrentFiber(), // separate issue. Write a regression test using string refs.
ReactCurrentOwner$2.current = null, null === erroredWork || null === erroredWork.return) {
// Expected to be working on a non-root fiber. This is a fatal error
// because there's no ancestor that can handle it; the root is
// supposed to capture all errors that weren't caught by an error
// boundary.
workInProgressRootExitStatus = 1, workInProgressRootFatalError = thrownValue, // sibling, or the parent if there are no siblings. But since the root
// has no siblings nor a parent, we set it to null. Usually this is
// handled by `completeUnitOfWork` or `unwindWork`, but since we're
// intentionally not calling those, we need set it here.
// TODO: Consider calling `unwindWork` to pop the contexts.
workInProgress = null;
return;
}
8 & erroredWork.mode && // Record the time spent rendering before an error was thrown. This
// avoids inaccurate Profiler durations in the case of a
// suspended render.
stopProfilerTimerIfRunningAndRecordDelta(erroredWork, !0), function(root, returnFiber, sourceFiber, value, rootRenderLanes) {
if (// The source fiber did not complete.
sourceFiber.flags |= /* */ 2048, sourceFiber.firstEffect = sourceFiber.lastEffect = null, null !== value && "object" == typeof value && "function" == typeof value.then) {
// This is a wakeable.
var wakeable = value;
if ((2 & sourceFiber.mode) == 0) {
// Reset the memoizedState to what it was before we attempted
// to render it.
var currentSource = sourceFiber.alternate;
currentSource ? (sourceFiber.updateQueue = currentSource.updateQueue, sourceFiber.memoizedState = currentSource.memoizedState, sourceFiber.lanes = currentSource.lanes) : (sourceFiber.updateQueue = null, sourceFiber.memoizedState = null);
}
var hasInvisibleParentBoundary = (1 & suspenseStackCursor.current) != 0, _workInProgress = returnFiber; // Schedule the nearest Suspense to re-render the timed out view.
do {
if (13 === _workInProgress.tag && function(workInProgress, hasInvisibleParent) {
// If it was the primary children that just suspended, capture and render the
// fallback. Otherwise, don't capture and bubble to the next boundary.
var nextState = workInProgress.memoizedState;
if (null !== nextState) return null !== nextState.dehydrated;
var props = workInProgress.memoizedProps; // In order to capture, the Suspense component must have a fallback prop.
return void 0 !== props.fallback && (!0 !== props.unstable_avoidThisFallback || !hasInvisibleParent) // Regular boundaries always capture.
;
}(_workInProgress, hasInvisibleParentBoundary)) {
// Found the nearest boundary.
// Stash the promise on the boundary fiber. If the boundary times out, we'll
// attach another listener to flip the boundary back to its normal state.
var wakeables = _workInProgress.updateQueue;
if (null === wakeables) {
var updateQueue = new Set();
updateQueue.add(wakeable), _workInProgress.updateQueue = updateQueue;
} else wakeables.add(wakeable);
// If the boundary is outside of blocking mode, we should *not*
// suspend the commit. Pretend as if the suspended component rendered
// null and keep rendering. In the commit phase, we'll schedule a
// subsequent synchronous update to re-render the Suspense.
//
// Note: It doesn't matter whether the component that suspended was
// inside a blocking mode tree. If the Suspense is outside of it, we
// should *not* suspend the commit.
if ((2 & _workInProgress.mode) == 0) {
if (_workInProgress.flags |= 64, sourceFiber.flags |= 16384, // But we shouldn't call any lifecycle methods or callbacks. Remove
// all lifecycle effect tags.
sourceFiber.flags &= -2981, 1 === sourceFiber.tag) {
if (null === sourceFiber.alternate) // This is a new mount. Change the tag so it's not mistaken for a
// completed class component. For example, we should not call
// componentWillUnmount if it is deleted.
sourceFiber.tag = 17;
else {
// When we try rendering again, we should not reuse the current fiber,
// since it's known to be in an inconsistent state. Use a force update to
// prevent a bail out.
var update = createUpdate(-1, 1);
update.tag = 2, enqueueUpdate(sourceFiber, update);
}
} // The source fiber did not complete. Mark it with Sync priority to
// indicate that it still has pending work.
sourceFiber.lanes = 1 | sourceFiber.lanes;
return;
} // Confirmed that the boundary is in a concurrent mode tree. Continue
// with the normal suspend path.
//
// After this we'll use a set of heuristics to determine whether this
// render pass will run to completion or restart or "suspend" the commit.
// The actual logic for this is spread out in different places.
//
// This first principle is that if we're going to suspend when we complete
// a root, then we should also restart if we get an update or ping that
// might unsuspend it, and vice versa. The only reason to suspend is
// because you think you might want to restart before committing. However,
// it doesn't make sense to restart only while in the period we're suspended.
//
// Restarting too aggressively is also not good because it starves out any
// intermediate loading state. So we use heuristics to determine when.
// Suspense Heuristics
//
// If nothing threw a Promise or all the same fallbacks are already showing,
// then don't suspend/restart.
//
// If this is an initial render of a new tree of Suspense boundaries and
// those trigger a fallback, then don't suspend/restart. We want to ensure
// that we can show the initial loading state as quickly as possible.
//
// If we hit a "Delayed" case, such as when we'd switch from content back into
// a fallback, then we should always suspend/restart. Transitions apply
// to this case. If none is defined, JND is used instead.
//
// If we're already showing a fallback and it gets "retried", allowing us to show
// another level, but there's still an inner boundary that would show a fallback,
// then we suspend/restart for 500ms since the last time we showed a fallback
// anywhere in the tree. This effectively throttles progressive loading into a
// consistent train of commits. This also gives us an opportunity to restart to
// get to the completed state slightly earlier.
//
// If there's ambiguity due to batching it's resolved in preference of:
// 1) "delayed", 2) "initial render", 3) "retry".
//
// We want to ensure that a "busy" state doesn't get force committed. We want to
// ensure that new initial loading states can commit as soon as possible.
(function(root, wakeable, lanes) {
// Attach a listener to the promise to "ping" the root and retry. But only if
// one does not already exist for the lanes we're currently rendering (which
// acts like a "thread ID" here).
var threadIDs, pingCache = root.pingCache;
if (null === pingCache ? (pingCache = root.pingCache = new PossiblyWeakMap$1(), threadIDs = new Set(), pingCache.set(wakeable, threadIDs)) : void 0 === (threadIDs = pingCache.get(wakeable)) && (threadIDs = new Set(), pingCache.set(wakeable, threadIDs)), !threadIDs.has(lanes)) {
// Memoize using the thread ID to prevent redundant listeners.
threadIDs.add(lanes);
var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
wakeable.then(ping, ping);
}
})(root, wakeable, rootRenderLanes), _workInProgress.flags |= /* */ 4096, _workInProgress.lanes = rootRenderLanes;
return;
} // This boundary already captured during this render. Continue to the next
// boundary.
_workInProgress = _workInProgress.return;
}while (null !== _workInProgress) // No boundary was found. Fallthrough to error mode.
// TODO: Use invariant so the message is stripped in prod?
value = Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.");
} // We didn't find a boundary that could handle this type of exception. Start
5 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2), value = createCapturedValue(value, sourceFiber);
var workInProgress = returnFiber;
do {
switch(workInProgress.tag){
case 3:
var _errorInfo = value;
workInProgress.flags |= 4096;
var lane = pickArbitraryLane(rootRenderLanes);
workInProgress.lanes = workInProgress.lanes | lane;
var _update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
enqueueCapturedUpdate(workInProgress, _update);
return;
case 1:
// Capture and retry
var errorInfo = value, ctor = workInProgress.type, instance = workInProgress.stateNode;
if ((64 & workInProgress.flags) == 0 && ("function" == typeof ctor.getDerivedStateFromError || null !== instance && "function" == typeof instance.componentDidCatch && !isAlreadyFailedLegacyErrorBoundary(instance))) {
workInProgress.flags |= 4096;
var _lane = pickArbitraryLane(rootRenderLanes);
workInProgress.lanes = workInProgress.lanes | _lane; // Schedule the error boundary to re-render using updated state
var _update2 = createClassErrorUpdate(workInProgress, errorInfo, _lane);
enqueueCapturedUpdate(workInProgress, _update2);
return;
}
}
workInProgress = workInProgress.return;
}while (null !== workInProgress)
}(root, erroredWork.return, erroredWork, thrownValue, workInProgressRootRenderLanes), completeUnitOfWork(erroredWork);
} catch (yetAnotherThrownValue) {
// Something in the return path also threw.
thrownValue = yetAnotherThrownValue, workInProgress === erroredWork && null !== erroredWork ? workInProgress = // If this boundary has already errored, then we had trouble processing
// the error. Bubble it to the next boundary.
erroredWork = erroredWork.return : erroredWork = workInProgress;
continue;
} // Return to the normal work loop.
return;
}
}
function pushDispatcher() {
var prevDispatcher = ReactCurrentDispatcher$2.current;
return (ReactCurrentDispatcher$2.current = ContextOnlyDispatcher, null === prevDispatcher) ? ContextOnlyDispatcher : prevDispatcher;
}
function pushInteractions(root) {
var prevInteractions = __interactionsRef.current;
return __interactionsRef.current = root.memoizedInteractions, prevInteractions;
}
function popInteractions(prevInteractions) {
__interactionsRef.current = prevInteractions;
}
function markSkippedUpdateLanes(lane) {
workInProgressRootSkippedLanes |= lane;
}
function renderRootSync(root, lanes) {
var prevExecutionContext = executionContext;
executionContext |= 16;
var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
(workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) && (prepareFreshStack(root, lanes), startWorkOnPendingInteractions(root, lanes));
for(var prevInteractions = pushInteractions(root);;)try {
!/** @noinline */ function() {
// Already timed out, so perform work without checking if we need to yield.
for(; null !== workInProgress;)performUnitOfWork(workInProgress);
}();
break;
} catch (thrownValue) {
handleError(root, thrownValue);
}
if (resetContextDependencies(), popInteractions(prevInteractions), executionContext = prevExecutionContext, ReactCurrentDispatcher$2.current = prevDispatcher, null !== workInProgress) throw Error("Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
return workInProgressRoot = null, workInProgressRootRenderLanes = 0, workInProgressRootExitStatus;
} // The work loop is an extremely hot path. Tell Closure not to inline it.
function performUnitOfWork(unitOfWork) {
// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
var next, current = unitOfWork.alternate;
setCurrentFiber(unitOfWork), (8 & unitOfWork.mode) != 0 ? (startProfilerTimer(unitOfWork), next = beginWork$1(current, unitOfWork, subtreeRenderLanes), stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, !0)) : next = beginWork$1(current, unitOfWork, subtreeRenderLanes), resetCurrentFiber(), unitOfWork.memoizedProps = unitOfWork.pendingProps, null === next ? // If this doesn't spawn new work, complete the current work.
completeUnitOfWork(unitOfWork) : workInProgress = next, ReactCurrentOwner$2.current = null;
}
function completeUnitOfWork(unitOfWork) {
// Attempt to complete the current unit of work, then move to the next
// sibling. If there are no more siblings, return to the parent fiber.
var completedWork = unitOfWork;
do {
// The current, flushed, state of this fiber is the alternate. Ideally
// nothing should rely on this, but relying on it here means that we don't
// need an additional field on the work in progress.
var current = completedWork.alternate, returnFiber = completedWork.return;
if ((2048 & completedWork.flags) == 0) {
setCurrentFiber(completedWork);
var next = void 0;
if ((8 & completedWork.mode) == 0 ? next = completeWork(current, completedWork, subtreeRenderLanes) : (startProfilerTimer(completedWork), next = completeWork(current, completedWork, subtreeRenderLanes), stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1)), resetCurrentFiber(), null !== next) {
// Completing this fiber spawned new work. Work on that next.
workInProgress = next;
return;
}
(function(completedWork) {
if (24 !== // TODO: Move this check out of the hot path by moving `resetChildLanes`
// to switch statement in `completeWork`.
completedWork.tag && 23 !== completedWork.tag || null === completedWork.memoizedState || (1073741824 & subtreeRenderLanes) != 0 || (4 & completedWork.mode) == 0) {
var newChildLanes = 0; // Bubble up the earliest expiration time.
if ((8 & completedWork.mode) != 0) {
for(// In profiling mode, resetChildExpirationTime is also used to reset
// profiler durations.
var actualDuration = completedWork.actualDuration, treeBaseDuration = completedWork.selfBaseDuration, shouldBubbleActualDurations = null === completedWork.alternate || completedWork.child !== completedWork.alternate.child, child = completedWork.child; null !== child;)newChildLanes |= child.lanes | child.childLanes, shouldBubbleActualDurations && (actualDuration += child.actualDuration), treeBaseDuration += child.treeBaseDuration, child = child.sibling;
if (13 === completedWork.tag && null !== completedWork.memoizedState) {
// Don't count time spent in a timed out Suspense subtree as part of the base duration.
var primaryChildFragment = completedWork.child;
null !== primaryChildFragment && (treeBaseDuration -= primaryChildFragment.treeBaseDuration);
}
completedWork.actualDuration = actualDuration, completedWork.treeBaseDuration = treeBaseDuration;
} else for(var _child = completedWork.child; null !== _child;)newChildLanes |= _child.lanes | _child.childLanes, _child = _child.sibling;
completedWork.childLanes = newChildLanes;
}
})(completedWork), null !== returnFiber && // Do not append effects to parents if a sibling failed to complete
(2048 & returnFiber.flags) == 0 && (null === returnFiber.firstEffect && (returnFiber.firstEffect = completedWork.firstEffect), null !== completedWork.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = completedWork.firstEffect), returnFiber.lastEffect = completedWork.lastEffect), completedWork.flags > 1 && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = completedWork : returnFiber.firstEffect = completedWork, returnFiber.lastEffect = completedWork));
} else {
// This fiber did not complete because something threw. Pop values off
// the stack without entering the complete phase. If this is a boundary,
// capture values if possible.
var _next = function(workInProgress, renderLanes) {
switch(workInProgress.tag){
case 1:
isContextProvider(workInProgress.type) && popContext(workInProgress);
var flags = workInProgress.flags;
if (4096 & flags) return workInProgress.flags = -4097 & flags | 64, (8 & workInProgress.mode) != 0 && transferActualDuration(workInProgress), workInProgress;
return null;
case 3:
popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), resetWorkInProgressVersions();
var _flags = workInProgress.flags;
if ((64 & _flags) != 0) throw Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue.");
return workInProgress.flags = -4097 & _flags | 64, workInProgress;
case 5:
return(// TODO: popHydrationState
popHostContext(workInProgress), null);
case 13:
pop(suspenseStackCursor, workInProgress);
var _flags2 = workInProgress.flags;
if (4096 & _flags2) return workInProgress.flags = -4097 & _flags2 | 64, (8 & workInProgress.mode) != 0 && transferActualDuration(workInProgress), workInProgress;
return null;
case 19:
// caught by a nested boundary. If not, it should bubble through.
return pop(suspenseStackCursor, workInProgress), null;
case 4:
return popHostContainer(workInProgress), null;
case 10:
return popProvider(workInProgress), null;
case 23:
case 24:
return popRenderLanes(workInProgress), null;
default:
return null;
}
}(completedWork); // Because this fiber did not complete, don't reset its expiration time.
if (null !== _next) {
// If completing this work spawned new work, do that next. We'll come
// back here again.
// Since we're restarting, remove anything that is not a host effect
// from the effect tag.
_next.flags &= /* */ 2047, workInProgress = _next;
return;
}
if ((8 & completedWork.mode) != 0) {
// Record the render duration for the fiber that errored.
stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1); // Include the time spent working on failed children before continuing.
for(var actualDuration = completedWork.actualDuration, child = completedWork.child; null !== child;)actualDuration += child.actualDuration, child = child.sibling;
completedWork.actualDuration = actualDuration;
}
null !== returnFiber && (// Mark the parent fiber as incomplete and clear its effect list.
returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.flags |= 2048);
}
var siblingFiber = completedWork.sibling;
if (null !== siblingFiber) {
// If there is more work to do in this returnFiber, do that next.
workInProgress = siblingFiber;
return;
} // Otherwise, return to the parent
workInProgress = completedWork = returnFiber;
}while (null !== completedWork) // We've reached the root.
0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
}
function commitRoot(root) {
return runWithPriority$1(99, commitRootImpl.bind(null, root, getCurrentPriorityLevel())), null;
}
function commitRootImpl(root, renderPriorityLevel) {
do // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
// means `flushPassiveEffects` will sometimes result in additional
// passive effects. So we need to keep flushing in a loop until there are
// no more pending effects.
// TODO: Might be better if `flushPassiveEffects` did not automatically
// flush synchronous work at the end, to avoid factoring hazards like this.
flushPassiveEffects();
while (null !== rootWithPendingPassiveEffects)
if (ReactStrictModeWarnings.flushLegacyContextWarning(), ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings(), (48 & executionContext) != 0) throw Error("Should not already be working.");
var firstEffect, finishedWork = root.finishedWork, lanes = root.finishedLanes;
if (null === finishedWork) return null;
if (root.finishedWork = null, root.finishedLanes = 0, finishedWork === root.current) throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");
// commitRoot never returns a continuation; it always finishes synchronously.
// So we can clear these now to allow a new callback to be scheduled.
root.callbackNode = null;
// pending time is whatever is left on the root fiber.
var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
if (!function(root, remainingLanes) {
var noLongerPendingLanes = root.pendingLanes & ~remainingLanes;
root.pendingLanes = remainingLanes, root.suspendedLanes = 0, root.pingedLanes = 0, root.expiredLanes &= remainingLanes, root.mutableReadLanes &= remainingLanes, root.entangledLanes &= remainingLanes;
for(var entanglements = root.entanglements, eventTimes = root.eventTimes, expirationTimes = root.expirationTimes, lanes = noLongerPendingLanes; lanes > 0;){
var index = pickArbitraryLaneIndex(lanes), lane = 1 << index;
entanglements[index] = 0, eventTimes[index] = -1, expirationTimes[index] = -1, lanes &= ~lane;
}
}(root, remainingLanes), null !== rootsWithPendingDiscreteUpdates && (24 & remainingLanes) == 0 && rootsWithPendingDiscreteUpdates.has(root) && rootsWithPendingDiscreteUpdates.delete(root), root === workInProgressRoot && (// We can reset these now that they are finished.
workInProgressRoot = null, workInProgress = null, workInProgressRootRenderLanes = 0), finishedWork.flags > 1 ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, firstEffect = finishedWork.firstEffect) : firstEffect = finishedWork : // There is no effect on the root.
firstEffect = finishedWork.firstEffect, null !== firstEffect) {
var containerInfo, focusedElem, input, selection, containerInfo1, prevExecutionContext = executionContext;
executionContext |= /* */ 32;
var prevInteractions = pushInteractions(root); // Reset this to null before calling lifecycles
ReactCurrentOwner$2.current = null, containerInfo = root.containerInfo, eventsEnabled = _enabled, selectionInformation = {
focusedElem: focusedElem = getActiveElementDeep(),
selectionRange: hasSelectionCapabilities(focusedElem) ? ("selectionStart" in (input = focusedElem) ? {
start: input.selectionStart,
end: input.selectionEnd
} : /**
* @param {DOMElement} outerNode
* @return {?object}
*/ function(outerNode) {
var ownerDocument = outerNode.ownerDocument, win = ownerDocument && ownerDocument.defaultView || window, selection = win.getSelection && win.getSelection();
if (!selection || 0 === selection.rangeCount) return null;
var anchorNode = selection.anchorNode, anchorOffset = selection.anchorOffset, focusNode = selection.focusNode, focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
// up/down buttons on an <input type="number">. Anonymous divs do not seem to
// expose properties, triggering a "Permission denied error" if any of its
// properties are accessed. The only seemingly possible way to avoid erroring
// is to access a property that typically works for non-anonymous divs and
// catch any error that may otherwise arise. See
// https://bugzilla.mozilla.org/show_bug.cgi?id=208427
try {
/* eslint-disable no-unused-expressions */ anchorNode.nodeType, focusNode.nodeType;
/* eslint-enable no-unused-expressions */ } catch (e) {
return null;
}
return(/**
* Returns {start, end} where `start` is the character/codepoint index of
* (anchorNode, anchorOffset) within the textContent of `outerNode`, and
* `end` is the index of (focusNode, focusOffset).
*
* Returns null if you pass in garbage input but we should probably just crash.
*
* Exported only for testing.
*/ function(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {
var length = 0, start = -1, end = -1, indexWithinAnchor = 0, indexWithinFocus = 0, node = outerNode, parentNode = null;
outer: for(;;){
for(var next = null; node === anchorNode && (0 === anchorOffset || 3 === node.nodeType) && (start = length + anchorOffset), node === focusNode && (0 === focusOffset || 3 === node.nodeType) && (end = length + focusOffset), 3 === node.nodeType && (length += node.nodeValue.length), null !== (next = node.firstChild);)parentNode = node, node = next;
for(;;){
if (node === outerNode) break outer;
if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset && (start = length), parentNode === focusNode && ++indexWithinFocus === focusOffset && (end = length), null !== (next = node.nextSibling)) break;
parentNode = (node = parentNode).parentNode;
} // Moving from `node` to its next sibling `next`.
node = next;
}
return -1 === start || -1 === end ? null : {
start: start,
end: end
};
}(outerNode, anchorNode, anchorOffset, focusNode, focusOffset));
}(input)) || {
start: 0,
end: 0
} : null
}, _enabled = !1, // of the effect list for each phase: all mutation effects come before all
// layout effects, and so on.
// The first phase a "before mutation" phase. We use this phase to read the
// state of the host tree right before we mutate it. This is where
// getSnapshotBeforeUpdate is called.
focusedInstanceHandle = null, shouldFireAfterActiveInstanceBlur = !1, nextEffect = firstEffect;
do if (invokeGuardedCallback(null, commitBeforeMutationEffects, null), hasError) {
if (null === nextEffect) throw Error("Should be working on an effect.");
var error1 = clearCaughtError();
captureCommitPhaseError(nextEffect, error1), nextEffect = nextEffect.nextEffect;
}
while (null !== nextEffect) // We no longer need to track the active instance fiber
focusedInstanceHandle = null, commitTime = unstable_now(), nextEffect = firstEffect;
do if (invokeGuardedCallback(null, commitMutationEffects, null, root, renderPriorityLevel), hasError) {
if (null === nextEffect) throw Error("Should be working on an effect.");
var _error = clearCaughtError();
captureCommitPhaseError(nextEffect, _error), nextEffect = nextEffect.nextEffect;
}
while (null !== nextEffect)
containerInfo1 = root.containerInfo, /**
* @restoreSelection: If any selection information was potentially lost,
* restore it. This is useful when performing operations that could remove dom
* nodes and place them back in, resulting in focus being lost.
*/ function(priorSelectionInformation) {
var node, curFocusedElem = getActiveElementDeep(), priorFocusedElem = priorSelectionInformation.focusedElem, priorSelectionRange = priorSelectionInformation.selectionRange;
if (curFocusedElem !== priorFocusedElem && (node = priorFocusedElem) && node.ownerDocument && function containsNode(outerNode, innerNode) {
if (!outerNode || !innerNode) return !1;
if (outerNode === innerNode) return !0;
if (isTextNode(outerNode)) return !1;
if (isTextNode(innerNode)) return containsNode(outerNode, innerNode.parentNode);
if ("contains" in outerNode) return outerNode.contains(innerNode);
else if (outerNode.compareDocumentPosition) return !!(16 & outerNode.compareDocumentPosition(innerNode));
else return !1;
}(node.ownerDocument.documentElement, node)) {
null !== priorSelectionRange && hasSelectionCapabilities(priorFocusedElem) && (input = priorFocusedElem, start = (offsets = priorSelectionRange).start, void 0 === (end = offsets.end) && (end = start), "selectionStart" in input ? (input.selectionStart = start, input.selectionEnd = Math.min(end, input.value.length)) : /**
* In modern non-IE browsers, we can support both forward and backward
* selections.
*
* Note: IE10+ supports the Selection object, but it does not support
* the `extend` method, which means that even in modern IE, it's not possible
* to programmatically create a backward selection. Thus, for all IE
* versions, we use the old IE API to create our selections.
*
* @param {DOMElement|DOMTextNode} node
* @param {object} offsets
*/ function(node, offsets) {
var doc = node.ownerDocument || document, win = doc && doc.defaultView || window;
// (For instance: TinyMCE editor used in a list component that supports pasting to add more,
// fails when pasting 100+ items)
if (win.getSelection) {
var selection = win.getSelection(), length = node.textContent.length, start = Math.min(offsets.start, length), end = void 0 === offsets.end ? start : Math.min(offsets.end, length);
// Flip backward selections, so we can set with a single range.
if (!selection.extend && start > end) {
var temp = end;
end = start, start = temp;
}
var startMarker = getNodeForCharacterOffset(node, start), endMarker = getNodeForCharacterOffset(node, end);
if (startMarker && endMarker) {
if (1 === selection.rangeCount && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) return;
var range = doc.createRange();
range.setStart(startMarker.node, startMarker.offset), selection.removeAllRanges(), start > end ? (selection.addRange(range), selection.extend(endMarker.node, endMarker.offset)) : (range.setEnd(endMarker.node, endMarker.offset), selection.addRange(range));
}
}
}(input, offsets)); // Focusing a node can change the scroll position, which is undesirable
for(var input, offsets, start, end, ancestors = [], ancestor = priorFocusedElem; ancestor = ancestor.parentNode;)1 === ancestor.nodeType && ancestors.push({
element: ancestor,
left: ancestor.scrollLeft,
top: ancestor.scrollTop
});
"function" == typeof priorFocusedElem.focus && priorFocusedElem.focus();
for(var i = 0; i < ancestors.length; i++){
var info = ancestors[i];
info.element.scrollLeft = info.left, info.element.scrollTop = info.top;
}
}
}(selectionInformation), _enabled = !!eventsEnabled, eventsEnabled = null, selectionInformation = null, // the mutation phase, so that the previous tree is still current during
// componentWillUnmount, but before the layout phase, so that the finished
// work is current during componentDidMount/Update.
root.current = finishedWork, // the host tree after it's been mutated. The idiomatic use case for this is
// layout, but class component lifecycles also fire here for legacy reasons.
nextEffect = firstEffect;
do if (invokeGuardedCallback(null, commitLayoutEffects, null, root, lanes), hasError) {
if (null === nextEffect) throw Error("Should be working on an effect.");
var _error2 = clearCaughtError();
captureCommitPhaseError(nextEffect, _error2), nextEffect = nextEffect.nextEffect;
}
while (null !== nextEffect)
nextEffect = null, // opportunity to paint.
requestPaint(), popInteractions(prevInteractions), executionContext = prevExecutionContext;
} else // No effects.
root.current = finishedWork, commitTime = unstable_now();
var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
if (rootDoesHavePassiveEffects) // This commit has passive effects. Stash a reference to them. But don't
// schedule a callback until after flushing layout work.
rootDoesHavePassiveEffects = !1, rootWithPendingPassiveEffects = root, pendingPassiveEffectsLanes = lanes, pendingPassiveEffectsRenderPriority = renderPriorityLevel;
else for(// We are done with the effect chain at this point so let's clear the
// nextEffect pointers to assist with GC. If we have passive effects, we'll
// clear this in flushPassiveEffects.
nextEffect = firstEffect; null !== nextEffect;){
var nextNextEffect = nextEffect.nextEffect;
nextEffect.nextEffect = null, 8 & nextEffect.flags && detachFiberAfterEffects(nextEffect), nextEffect = nextNextEffect;
}
// Read this again, since an effect might have updated it
if (0 !== (remainingLanes = root.pendingLanes)) {
if (null !== spawnedWorkDuringRender) {
var expirationTimes = spawnedWorkDuringRender;
spawnedWorkDuringRender = null;
for(var i = 0; i < expirationTimes.length; i++)scheduleInteractions(root, expirationTimes[i], root.memoizedInteractions);
}
schedulePendingInteractions(root, remainingLanes);
} else // If there's no remaining work, we can clear the set of already failed
// error boundaries.
legacyErrorBoundariesThatAlreadyFailed = null;
if (rootDidHavePassiveEffects || // If there are no passive effects, then we can complete the pending interactions.
// Otherwise, we'll wait until after the passive effects are flushed.
// Wait to do this until after remaining work has been scheduled,
// so that we don't prematurely signal complete for interactions when there's e.g. hidden work.
finishPendingInteractions(root, lanes), 1 === remainingLanes ? root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root) : nestedUpdateCount = 0, !function(root, priorityLevel) {
if (injectedHook && "function" == typeof injectedHook.onCommitFiberRoot) try {
var didError = (64 & root.current.flags) == 64;
injectedHook.onCommitFiberRoot(rendererID, root, priorityLevel, didError);
} catch (err) {
hasLoggedError || (hasLoggedError = !0, error("React instrumentation encountered an error: %s", err));
}
}(finishedWork.stateNode, renderPriorityLevel), commitHooks.forEach(function(commitHook) {
return commitHook();
}), // additional work on this root is scheduled.
ensureRootIsScheduled(root, now()), hasUncaughtError) {
hasUncaughtError = !1;
var _error3 = firstUncaughtError;
throw firstUncaughtError = null, _error3;
}
return (8 & executionContext) != 0 || flushSyncCallbackQueue(), null;
}
function commitBeforeMutationEffects() {
for(; null !== nextEffect;){
var current = nextEffect.alternate;
!shouldFireAfterActiveInstanceBlur && null !== focusedInstanceHandle && ((8 & nextEffect.flags) != 0 ? doesFiberContain(nextEffect, focusedInstanceHandle) && (shouldFireAfterActiveInstanceBlur = !0) : 13 === nextEffect.tag && // It returns false if the boundary is already hidden.
// TODO: Use an effect tag.
function(current, finishedWork) {
if (null !== current) {
var oldState = current.memoizedState;
if (null === oldState || null !== oldState.dehydrated) {
var newState = finishedWork.memoizedState;
return null !== newState && null === newState.dehydrated;
}
}
return !1;
}(current, nextEffect) && doesFiberContain(nextEffect, focusedInstanceHandle) && (shouldFireAfterActiveInstanceBlur = !0));
var flags = nextEffect.flags;
(256 & flags) != 0 && (setCurrentFiber(nextEffect), function(current, finishedWork) {
switch(finishedWork.tag){
case 0:
case 11:
case 15:
case 22:
case 5:
case 6:
case 4:
case 17:
return;
case 1:
if (256 & finishedWork.flags && null !== current) {
var prevProps = current.memoizedProps, prevState = current.memoizedState, instance = finishedWork.stateNode;
finishedWork.type !== finishedWork.elementType || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && error("Expected %s props to match memoized props before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentName(finishedWork.type) || "instance"), instance.state !== finishedWork.memoizedState && error("Expected %s state to match memoized state before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentName(finishedWork.type) || "instance"));
var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState), didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
void 0 !== snapshot || didWarnSet.has(finishedWork.type) || (didWarnSet.add(finishedWork.type), error("%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.", getComponentName(finishedWork.type))), instance.__reactInternalSnapshotBeforeUpdate = snapshot;
}
return;
case 3:
256 & finishedWork.flags && clearContainer(finishedWork.stateNode.containerInfo);
return;
}
throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
}(current, nextEffect), resetCurrentFiber()), (/* */ 512 & flags) == 0 || rootDoesHavePassiveEffects || (rootDoesHavePassiveEffects = !0, scheduleCallback(97, function() {
return flushPassiveEffects(), null;
})), nextEffect = nextEffect.nextEffect;
}
}
function commitMutationEffects(root, renderPriorityLevel) {
// TODO: Should probably move the bulk of this function to commitWork.
for(; null !== nextEffect;){
setCurrentFiber(nextEffect);
var flags = nextEffect.flags;
if (16 & flags && setTextContent(nextEffect.stateNode, ""), 128 & flags) {
var current = nextEffect.alternate;
null !== current && function(current) {
var currentRef = current.ref;
null !== currentRef && ("function" == typeof currentRef ? currentRef(null) : currentRef.current = null);
} // User-originating errors (lifecycles and refs) should not interrupt
(current);
} // The following switch statement is only concerned about placement,
switch(1038 & flags){
case 2:
commitPlacement(nextEffect), // inserted, before any life-cycles like componentDidMount gets called.
// TODO: findDOMNode doesn't rely on this any more but isMounted does
// and isMounted is deprecated anyway so we should be able to kill this.
nextEffect.flags &= -3;
break;
case /* */ 6:
// Placement
commitPlacement(nextEffect), // inserted, before any life-cycles like componentDidMount gets called.
nextEffect.flags &= -3, commitWork(nextEffect.alternate, nextEffect);
break;
case 1024:
nextEffect.flags &= -1025;
break;
case /* */ 1028:
nextEffect.flags &= -1025, commitWork(nextEffect.alternate, nextEffect);
break;
case 4:
commitWork(nextEffect.alternate, nextEffect);
break;
case 8:
!function(finishedRoot, current, renderPriorityLevel) {
// Recursively delete all host nodes from the parent.
// Detach refs and call componentWillUnmount() on the whole subtree.
unmountHostComponents(finishedRoot, current);
var alternate = current.alternate;
detachFiberMutation(current), null !== alternate && detachFiberMutation(alternate);
}(root, nextEffect);
}
resetCurrentFiber(), nextEffect = nextEffect.nextEffect;
}
}
function commitLayoutEffects(root, committedLanes) {
for(; null !== nextEffect;){
setCurrentFiber(nextEffect);
var flags = nextEffect.flags;
36 & flags && function(finishedRoot, current, finishedWork, committedLanes) {
switch(finishedWork.tag){
case 0:
case 11:
case 15:
case 22:
(function(tag, finishedWork) {
var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
if (null !== lastEffect) {
var firstEffect = lastEffect.next, effect = firstEffect;
do {
if ((3 & effect.tag) === tag) {
// Mount
var create = effect.create;
effect.destroy = create();
var destroy = effect.destroy;
if (void 0 !== destroy && "function" != typeof destroy) {
var addendum = void 0;
error("An effect function must not return anything besides a function, which is used for clean-up.%s", null === destroy ? " You returned null. If your effect does not require clean up, return undefined (or nothing)." : "function" == typeof destroy.then ? "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. Instead, write the async function inside your effect and call it immediately:\n\nuseEffect(() => {\n async function fetchData() {\n // You can await here\n const response = await MyAPI.getData(someId);\n // ...\n }\n fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching" : " You returned: " + destroy);
}
}
effect = effect.next;
}while (effect !== firstEffect)
}
})(3, finishedWork), function(finishedWork) {
var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
if (null !== lastEffect) {
var firstEffect = lastEffect.next, effect = firstEffect;
do {
var fiber, effect1, _effect = effect, next = _effect.next, tag = _effect.tag;
(4 & tag) != 0 && (1 & tag) != 0 && (enqueuePendingPassiveHookEffectUnmount(finishedWork, effect), fiber = finishedWork, effect1 = effect, pendingPassiveHookEffectsMount.push(effect1, fiber), rootDoesHavePassiveEffects || (rootDoesHavePassiveEffects = !0, scheduleCallback(97, function() {
return flushPassiveEffects(), null;
}))), effect = next;
}while (effect !== firstEffect)
}
}(finishedWork);
return;
case 1:
var instance = finishedWork.stateNode;
if (4 & finishedWork.flags) {
if (null === current) finishedWork.type !== finishedWork.elementType || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && error("Expected %s props to match memoized props before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentName(finishedWork.type) || "instance"), instance.state !== finishedWork.memoizedState && error("Expected %s state to match memoized state before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentName(finishedWork.type) || "instance")), instance.componentDidMount();
else {
var prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps), prevState = current.memoizedState;
finishedWork.type !== finishedWork.elementType || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && error("Expected %s props to match memoized props before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentName(finishedWork.type) || "instance"), instance.state !== finishedWork.memoizedState && error("Expected %s state to match memoized state before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentName(finishedWork.type) || "instance")), instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
}
} // TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
var updateQueue = finishedWork.updateQueue;
null !== updateQueue && (finishedWork.type !== finishedWork.elementType || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && error("Expected %s props to match memoized props before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentName(finishedWork.type) || "instance"), instance.state !== finishedWork.memoizedState && error("Expected %s state to match memoized state before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentName(finishedWork.type) || "instance")), // but instead we rely on them being set during last render.
// TODO: revisit this when we implement resuming.
commitUpdateQueue(finishedWork, updateQueue, instance));
return;
case 3:
// TODO: I think this is now always non-null by the time it reaches the
// commit phase. Consider removing the type check.
var _updateQueue = finishedWork.updateQueue;
if (null !== _updateQueue) {
var _instance = null;
if (null !== finishedWork.child) switch(finishedWork.child.tag){
case 5:
case 1:
_instance = finishedWork.child.stateNode;
}
commitUpdateQueue(finishedWork, _updateQueue, _instance);
}
return;
case 5:
var _instance2 = finishedWork.stateNode; // Renderers may schedule work to be done after host components are mounted
// (eg DOM renderer may schedule auto-focus for inputs and form controls).
// These effects should only be committed when components are first mounted,
// aka when there is no current/alternate.
if (null === current && 4 & finishedWork.flags) shouldAutoFocusHostComponent(finishedWork.type, finishedWork.memoizedProps) && _instance2.focus();
return;
case 6:
case 4:
case 19:
case 17:
case 20:
case 21:
case 23:
case 24:
// We have no life-cycles associated with text.
return;
case 12:
var _finishedWork$memoize2 = finishedWork.memoizedProps, onRender = (_finishedWork$memoize2.onCommit, _finishedWork$memoize2.onRender);
finishedWork.stateNode.effectDuration;
var commitTime1 = commitTime;
"function" == typeof onRender && onRender(finishedWork.memoizedProps.id, null === current ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, commitTime1, finishedRoot.memoizedInteractions);
return;
case 13:
(function(finishedRoot, finishedWork) {
if (null === finishedWork.memoizedState) {
var current = finishedWork.alternate;
if (null !== current) {
var prevState = current.memoizedState;
if (null !== prevState) {
var suspenseInstance = prevState.dehydrated;
null !== suspenseInstance && // Retry if any event replaying was blocked on this.
retryIfBlockedOn(suspenseInstance);
}
}
}
})(0, finishedWork);
return;
}
throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
}(root, nextEffect.alternate, nextEffect), 128 & flags && function(finishedWork) {
var ref = finishedWork.ref;
if (null !== ref) {
var instanceToUse, instance = finishedWork.stateNode;
finishedWork.tag, instanceToUse = instance, "function" == typeof ref ? ref(instanceToUse) : (ref.hasOwnProperty("current") || error("Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().", getComponentName(finishedWork.type)), ref.current = instanceToUse);
}
}(nextEffect), resetCurrentFiber(), nextEffect = nextEffect.nextEffect;
}
}
function flushPassiveEffects() {
// Returns whether passive effects were flushed.
if (90 !== pendingPassiveEffectsRenderPriority) {
var priorityLevel = pendingPassiveEffectsRenderPriority > 97 ? 97 : pendingPassiveEffectsRenderPriority;
return pendingPassiveEffectsRenderPriority = 90, runWithPriority$1(priorityLevel, flushPassiveEffectsImpl);
}
return !1;
}
function enqueuePendingPassiveHookEffectUnmount(fiber, effect) {
pendingPassiveHookEffectsUnmount.push(effect, fiber), fiber.flags |= 8192;
var alternate = fiber.alternate;
null !== alternate && (alternate.flags |= 8192), rootDoesHavePassiveEffects || (rootDoesHavePassiveEffects = !0, scheduleCallback(97, function() {
return flushPassiveEffects(), null;
}));
}
function invokePassiveEffectCreate(effect) {
var create = effect.create;
effect.destroy = create();
}
function flushPassiveEffectsImpl() {
if (null === rootWithPendingPassiveEffects) return !1;
var root = rootWithPendingPassiveEffects, lanes = pendingPassiveEffectsLanes;
if (rootWithPendingPassiveEffects = null, pendingPassiveEffectsLanes = 0, (48 & executionContext) != 0) throw Error("Cannot flush passive effects while already rendering.");
isFlushingPassiveEffects = !0;
var prevExecutionContext = executionContext;
executionContext |= 32;
var prevInteractions = pushInteractions(root), unmountEffects = pendingPassiveHookEffectsUnmount; // It's important that ALL pending passive effect destroy functions are called
pendingPassiveHookEffectsUnmount = [];
for(var i = 0; i < unmountEffects.length; i += 2){
var _effect = unmountEffects[i], fiber = unmountEffects[i + 1], destroy = _effect.destroy;
_effect.destroy = void 0, fiber.flags &= -8193;
var alternate = fiber.alternate;
if (null !== alternate && (alternate.flags &= -8193), "function" == typeof destroy) {
if (setCurrentFiber(fiber), invokeGuardedCallback(null, destroy, null), hasError) {
if (null === fiber) throw Error("Should be working on an effect.");
captureCommitPhaseError(fiber, clearCaughtError());
}
resetCurrentFiber();
}
} // Second pass: Create new passive effects.
var mountEffects = pendingPassiveHookEffectsMount;
pendingPassiveHookEffectsMount = [];
for(var _i = 0; _i < mountEffects.length; _i += 2){
var _effect2 = mountEffects[_i], _fiber = mountEffects[_i + 1];
if (setCurrentFiber(_fiber), invokeGuardedCallback(null, invokePassiveEffectCreate, null, _effect2), hasError) {
if (null === _fiber) throw Error("Should be working on an effect.");
captureCommitPhaseError(_fiber, clearCaughtError());
}
resetCurrentFiber();
} // Note: This currently assumes there are no passive effects on the root fiber
for(// because the root is not part of its own effect list.
// This could change in the future.
var effect = root.current.firstEffect; null !== effect;){
var nextNextEffect = effect.nextEffect; // Remove nextEffect pointer to assist GC
effect.nextEffect = null, 8 & effect.flags && detachFiberAfterEffects(effect), effect = nextNextEffect;
}
return popInteractions(prevInteractions), finishPendingInteractions(root, lanes), isFlushingPassiveEffects = !1, executionContext = prevExecutionContext, flushSyncCallbackQueue(), // exceeds the limit, we'll fire a warning.
nestedPassiveUpdateCount = null === rootWithPendingPassiveEffects ? 0 : nestedPassiveUpdateCount + 1, !0;
}
function isAlreadyFailedLegacyErrorBoundary(instance) {
return null !== legacyErrorBoundariesThatAlreadyFailed && legacyErrorBoundariesThatAlreadyFailed.has(instance);
}
var onUncaughtError = function(error) {
hasUncaughtError || (hasUncaughtError = !0, firstUncaughtError = error);
};
function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
var update = createRootErrorUpdate(rootFiber, createCapturedValue(error, sourceFiber), 1);
enqueueUpdate(rootFiber, update);
var eventTime = requestEventTime(), root = markUpdateLaneFromFiberToRoot(rootFiber, 1);
null !== root && (markRootUpdated(root, 1, eventTime), ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, 1));
}
function captureCommitPhaseError(sourceFiber, error) {
if (3 === sourceFiber.tag) {
// Error was thrown at the root. There is no parent, so the root
// itself should capture it.
captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
return;
}
for(var fiber = sourceFiber.return; null !== fiber;){
if (3 === fiber.tag) {
captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
return;
}
if (1 === fiber.tag) {
var ctor = fiber.type, instance = fiber.stateNode;
if ("function" == typeof ctor.getDerivedStateFromError || "function" == typeof instance.componentDidCatch && !isAlreadyFailedLegacyErrorBoundary(instance)) {
var errorInfo = createCapturedValue(error, sourceFiber), update = createClassErrorUpdate(fiber, errorInfo, 1);
enqueueUpdate(fiber, update);
var eventTime = requestEventTime(), root = markUpdateLaneFromFiberToRoot(fiber, 1);
if (null !== root) markRootUpdated(root, 1, eventTime), ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, 1);
else // This component has already been unmounted.
// We can't schedule any follow up work for the root because the fiber is already unmounted,
// but we can still call the log-only boundary so the error isn't swallowed.
//
// TODO This is only a temporary bandaid for the old reconciler fork.
// We can delete this special case once the new fork is merged.
if ("function" == typeof instance.componentDidCatch && !isAlreadyFailedLegacyErrorBoundary(instance)) try {
instance.componentDidCatch(error, errorInfo);
} catch (errorToIgnore) {
// TODO Ignore this error? Rethrow it?
// This is kind of an edge case.
}
return;
}
}
fiber = fiber.return;
}
}
function pingSuspendedRoot(root, wakeable, pingedLanes) {
var pingCache = root.pingCache;
null !== pingCache && // The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
pingCache.delete(wakeable);
var eventTime = requestEventTime();
markRootPinged(root, pingedLanes), workInProgressRoot === root && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (4 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < 500 ? // Restart from the root.
prepareFreshStack(root, 0) : // Even though we can't restart right now, we might get an
// opportunity later. So we mark this render as having a ping.
workInProgressRootPingedLanes |= pingedLanes), ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, pingedLanes);
}
function resolveRetryWakeable(boundaryFiber, wakeable) {
var retryCache, retryLane, eventTime, root, lane, mode;
null !== (retryCache = boundaryFiber.stateNode) && // The wakeable resolved, so we no longer need to memoize, because it will
// never be thrown again.
retryCache.delete(wakeable), 0 == (retryLane = 0) && (retryLane = (2 & (mode = boundaryFiber.mode)) == 0 ? 1 : (4 & mode) == 0 ? 99 === getCurrentPriorityLevel() ? 1 : 2 : (0 === currentEventWipLanes && (currentEventWipLanes = workInProgressRootIncludedLanes), 0 === (lane = pickArbitraryLane(62914560 & ~currentEventWipLanes)) && (lane = pickArbitraryLane(62914560)), lane) // See `requestUpdateLane` for explanation of `currentEventWipLanes`
), eventTime = requestEventTime(), null !== (root = markUpdateLaneFromFiberToRoot(boundaryFiber, retryLane)) && (markRootUpdated(root, retryLane, eventTime), ensureRootIsScheduled(root, eventTime), schedulePendingInteractions(root, retryLane));
} // Computes the next Just Noticeable Difference (JND) boundary.
var didWarnStateUpdateForNotYetMountedComponent = null;
function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
if ((16 & executionContext) == 0 && 6 & fiber.mode) {
var tag = fiber.tag;
if (2 === tag || 3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag || 22 === tag) {
// the problematic code almost always lies inside that component.
var componentName = getComponentName(fiber.type) || "ReactComponent";
if (null !== didWarnStateUpdateForNotYetMountedComponent) {
if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) return;
didWarnStateUpdateForNotYetMountedComponent.add(componentName);
} else didWarnStateUpdateForNotYetMountedComponent = new Set([
componentName
]);
var previousFiber = current;
try {
setCurrentFiber(fiber), error("Can't perform a React state update on a component that hasn't mounted yet. This indicates that you have a side-effect in your render function that asynchronously later calls tries to update the component. Move this work to useEffect instead.");
} finally{
previousFiber ? setCurrentFiber(fiber) : resetCurrentFiber();
}
} // We show the whole stack but dedupe on the top component's name because
}
}
var didWarnStateUpdateForUnmountedComponent = null;
beginWork$1 = function(current, unitOfWork, lanes) {
// If a component throws an error, we replay it again in a synchronously
// dispatched event, so that the debugger will treat it as an uncaught
// error See ReactErrorUtils for more information.
// Before entering the begin phase, copy the work-in-progress onto a dummy
// fiber. If beginWork throws, we'll use this to reset the state.
var originalWorkInProgressCopy = assignFiberPropertiesInDEV(null, unitOfWork);
try {
return beginWork(current, unitOfWork, lanes);
} catch (originalError) {
if (null !== originalError && "object" == typeof originalError && "function" == typeof originalError.then) // Don't replay promises. Treat everything else like an error.
throw originalError;
// Keep this code in sync with handleError; any changes here must have
if (// corresponding changes there.
resetContextDependencies(), resetHooksAfterThrow(), // same fiber again.
// Unwind the failed stack frame
unwindInterruptedWork(unitOfWork), assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy), 8 & unitOfWork.mode && // Reset the profiler timer.
startProfilerTimer(unitOfWork), invokeGuardedCallback(null, beginWork, null, current, unitOfWork, lanes), hasError) // Rethrow this error instead of the original one.
throw clearCaughtError();
// This branch is reachable if the render phase is impure.
throw originalError;
}
};
var didWarnAboutUpdateInRender = !1;
didWarnAboutUpdateInRenderForAnotherComponent = new Set();
var IsThisRendererActing = {
current: !1
};
function warnIfNotScopedWithMatchingAct(fiber) {
if (!0 === IsSomeRendererActing.current && !0 !== IsThisRendererActing.current) {
var previousFiber = current;
try {
setCurrentFiber(fiber), error("It looks like you're using the wrong act() around your test interactions.\nBe sure to use the matching version of act() corresponding to your renderer:\n\n// for react-dom:\nimport {act} from 'react-dom/test-utils';\n// ...\nact(() => ...);\n\n// for react-test-renderer:\nimport TestRenderer from react-test-renderer';\nconst {act} = TestRenderer;\n// ...\nact(() => ...);");
} finally{
previousFiber ? setCurrentFiber(fiber) : resetCurrentFiber();
}
}
}
function warnIfNotCurrentlyActingEffectsInDEV(fiber) {
(1 & fiber.mode) != 0 && !1 === IsSomeRendererActing.current && !1 === IsThisRendererActing.current && error("An update to %s ran an effect, but was not wrapped in act(...).\n\nWhen testing, code that causes React state updates should be wrapped into act(...):\n\nact(() => {\n /* fire events that update state */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://reactjs.org/link/wrap-tests-with-act", getComponentName(fiber.type));
}
var warnIfNotCurrentlyActingUpdatesInDev = function(fiber) {
if (0 === executionContext && !1 === IsSomeRendererActing.current && !1 === IsThisRendererActing.current) {
var previousFiber = current;
try {
setCurrentFiber(fiber), error("An update to %s inside a test was not wrapped in act(...).\n\nWhen testing, code that causes React state updates should be wrapped into act(...):\n\nact(() => {\n /* fire events that update state */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://reactjs.org/link/wrap-tests-with-act", getComponentName(fiber.type));
} finally{
previousFiber ? setCurrentFiber(fiber) : resetCurrentFiber();
}
}
}, didWarnAboutUnmockedScheduler = !1; // In tests, we want to enforce a mocked scheduler.
function computeThreadID(root, lane) {
// Interaction threads are unique per root and expiration time.
// NOTE: Intentionally unsound cast. All that matters is that it's a number
// and it represents a batch of work. Could make a helper function instead,
// but meh this is fine for now.
return 1000 * lane + root.interactionThreadID;
}
function markSpawnedWork(lane) {
null === spawnedWorkDuringRender ? spawnedWorkDuringRender = [
lane
] : spawnedWorkDuringRender.push(lane);
}
function scheduleInteractions(root, lane, interactions) {
if (interactions.size > 0) {
var pendingInteractionMap = root.pendingInteractionMap, pendingInteractions = pendingInteractionMap.get(lane);
null != pendingInteractions ? interactions.forEach(function(interaction) {
!pendingInteractions.has(interaction) && // Update the pending async work count for previously unscheduled interaction.
interaction.__count++, pendingInteractions.add(interaction);
}) : (pendingInteractionMap.set(lane, new Set(interactions)), interactions.forEach(function(interaction) {
interaction.__count++;
}));
var subscriber = __subscriberRef.current;
if (null !== subscriber) {
var threadID = computeThreadID(root, lane);
subscriber.onWorkScheduled(interactions, threadID);
}
}
}
function schedulePendingInteractions(root, lane) {
scheduleInteractions(root, lane, __interactionsRef.current);
}
function startWorkOnPendingInteractions(root, lanes) {
// we can accurately attribute time spent working on it, And so that cascading
// work triggered during the render phase will be associated with it.
var interactions = new Set();
if (root.pendingInteractionMap.forEach(function(scheduledInteractions, scheduledLane) {
(lanes & scheduledLane) != 0 && scheduledInteractions.forEach(function(interaction) {
return interactions.add(interaction);
});
}), // We can re-use it in hot functions like performConcurrentWorkOnRoot()
// without having to recalculate it. We will also use it in commitWork() to
// pass to any Profiler onRender() hooks. This also provides DevTools with a
// way to access it when the onCommitRoot() hook is called.
root.memoizedInteractions = interactions, interactions.size > 0) {
var subscriber = __subscriberRef.current;
if (null !== subscriber) {
var threadID = computeThreadID(root, lanes);
try {
subscriber.onWorkStarted(interactions, threadID);
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(99, function() {
throw error;
});
}
}
}
}
function finishPendingInteractions(root, committedLanes) {
var subscriber, remainingLanesAfterCommit = root.pendingLanes;
try {
if (subscriber = __subscriberRef.current, null !== subscriber && root.memoizedInteractions.size > 0) {
// FIXME: More than one lane can finish in a single commit.
var threadID = computeThreadID(root, committedLanes);
subscriber.onWorkStopped(root.memoizedInteractions, threadID);
}
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(99, function() {
throw error;
});
} finally{
// Clear completed interactions from the pending Map.
// Unless the render was suspended or cascading work was scheduled,
// In which case– leave pending interactions until the subsequent render.
var pendingInteractionMap = root.pendingInteractionMap;
pendingInteractionMap.forEach(function(scheduledInteractions, lane) {
// Only decrement the pending interaction count if we're done.
// If there's still work at the current priority,
// That indicates that we are waiting for suspense data.
(remainingLanesAfterCommit & lane) != 0 || (pendingInteractionMap.delete(lane), scheduledInteractions.forEach(function(interaction) {
if (interaction.__count--, null !== subscriber && 0 === interaction.__count) try {
subscriber.onInteractionScheduledWorkCompleted(interaction);
} catch (error) {
// If the subscriber throws, rethrow it in a separate task
scheduleCallback(99, function() {
throw error;
});
}
}));
});
}
} // `act` testing API
function shouldForceFlushFallbacksInDEV() {
return actingUpdatesScopeDepth > 0;
}
// so we can tell if any async act() calls try to run in parallel.
var actingUpdatesScopeDepth = 0;
function detachFiberAfterEffects(fiber) {
fiber.sibling = null, fiber.stateNode = null;
}
var resolveFamily = null, failedBoundaries = null; // $FlowFixMe Flow gets confused by a WeakSet feature check below.
function resolveFunctionForHotReloading(type) {
if (null === resolveFamily) // Hot reloading is disabled.
return type;
var family = resolveFamily(type);
return void 0 === family ? type : family.current // Use the latest known implementation.
;
}
function resolveForwardRefForHotReloading(type) {
if (null === resolveFamily) // Hot reloading is disabled.
return type;
var family = resolveFamily(type);
if (void 0 === family) {
// Check if we're dealing with a real forwardRef. Don't want to crash early.
if (null != type && "function" == typeof type.render) {
// ForwardRef is special because its resolved .type is an object,
// but it's possible that we only have its inner render function in the map.
// If that inner render function is different, we'll build a new forwardRef type.
var currentRender = resolveFunctionForHotReloading(type.render);
if (type.render !== currentRender) {
var syntheticType = {
$$typeof: REACT_FORWARD_REF_TYPE,
render: currentRender
};
return void 0 !== type.displayName && (syntheticType.displayName = type.displayName), syntheticType;
}
}
return type;
} // Use the latest known implementation.
return family.current;
}
function isCompatibleFamilyForHotReloading(fiber, element) {
if (null === resolveFamily) // Hot reloading is disabled.
return !1;
var prevType = fiber.elementType, nextType = element.type, needsCompareFamilies = !1, $$typeofNextType = "object" == typeof nextType && null !== nextType ? nextType.$$typeof : null;
switch(fiber.tag){
case 1:
"function" == typeof nextType && (needsCompareFamilies = !0);
break;
case 0:
"function" == typeof nextType ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && // We don't know the inner type yet.
// We're going to assume that the lazy inner type is stable,
// and so it is sufficient to avoid reconciling it away.
// We're not going to unwrap or actually use the new lazy type.
(needsCompareFamilies = !0);
break;
case 11:
$$typeofNextType === REACT_FORWARD_REF_TYPE ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
break;
case 14:
case 15:
$$typeofNextType === REACT_MEMO_TYPE ? // TODO: if it was but can no longer be simple,
// we shouldn't set this.
needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
break;
default:
return !1;
} // Check if both types have a family and it's the same one.
if (needsCompareFamilies) {
// Note: memo() and forwardRef() we'll compare outer rather than inner type.
// This means both of them need to be registered to preserve state.
// If we unwrapped and compared the inner types for wrappers instead,
// then we would risk falsely saying two separate memo(Foo)
// calls are equivalent because they wrap the same Foo function.
var prevFamily = resolveFamily(prevType);
if (void 0 !== prevFamily && prevFamily === resolveFamily(nextType)) return !0;
}
return !1;
}
function markFailedErrorBoundaryForHotReloading(fiber) {
null !== resolveFamily && "function" == typeof WeakSet && (null === failedBoundaries && (failedBoundaries = new WeakSet()), failedBoundaries.add(fiber));
}
hasBadMapPolyfill = !1;
try {
Object.preventExtensions({});
/* eslint-enable no-new */ } catch (e) {
// TODO: Consider warning about bad polyfills
hasBadMapPolyfill = !0;
}
var debugCounter = 1;
function FiberNode(tag, pendingProps, key, mode) {
// Instance
this.tag = tag, this.key = key, this.elementType = null, this.type = null, this.stateNode = null, this.return = null, this.child = null, this.sibling = null, this.index = 0, this.ref = null, this.pendingProps = pendingProps, this.memoizedProps = null, this.updateQueue = null, this.memoizedState = null, this.dependencies = null, this.mode = mode, this.flags = 0, this.nextEffect = null, this.firstEffect = null, this.lastEffect = null, this.lanes = 0, this.childLanes = 0, this.alternate = null, // Note: The following is done to avoid a v8 performance cliff.
//
// Initializing the fields below to smis and later updating them with
// double values will cause Fibers to end up having separate shapes.
// This behavior/bug has something to do with Object.preventExtension().
// Fortunately this only impacts DEV builds.
// Unfortunately it makes React unusably slow for some applications.
// To work around this, initialize the fields below with doubles.
//
// Learn more about this here:
// https://github.com/facebook/react/issues/14365
// https://bugs.chromium.org/p/v8/issues/detail?id=8538
this.actualDuration = Number.NaN, this.actualStartTime = Number.NaN, this.selfBaseDuration = Number.NaN, this.treeBaseDuration = Number.NaN, // This won't trigger the performance cliff mentioned above,
// and it simplifies other profiler code (including DevTools).
this.actualDuration = 0, this.actualStartTime = -1, this.selfBaseDuration = 0, this.treeBaseDuration = 0, // This isn't directly used but is handy for debugging internals:
this._debugID = debugCounter++, this._debugSource = null, this._debugOwner = null, this._debugNeedsRemount = !1, this._debugHookTypes = null, hasBadMapPolyfill || "function" != typeof Object.preventExtensions || Object.preventExtensions(this);
} // This is a constructor function, rather than a POJO constructor, still
// please ensure we do the following:
// 1) Nobody should add any instance methods on this. Instance methods can be
// more difficult to predict when they get optimized and they are almost
// never inlined properly in static compilers.
// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
// always know when it is a fiber.
// 3) We might want to experiment with using numeric keys since they are easier
// to optimize in a non-JIT environment.
// 4) We can easily go from a constructor to a createFiber object literal if that
// is faster.
// 5) It should be easy to port this to a C struct and keep a C implementation
// compatible.
var createFiber = function(tag, pendingProps, key, mode) {
// $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
return new FiberNode(tag, pendingProps, key, mode);
};
function shouldConstruct$1(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function createWorkInProgress(current, pendingProps) {
var workInProgress = current.alternate;
null === workInProgress ? (// We use a double buffering pooling technique because we know that we'll
// only ever need at most two versions of a tree. We pool the "other" unused
// node that we're free to reuse. This is lazily created to avoid allocating
// extra objects for things that are never updated. It also allow us to
// reclaim the extra memory if needed.
(workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode)).elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, // DEV-only fields
workInProgress._debugID = current._debugID, workInProgress._debugSource = current._debugSource, workInProgress._debugOwner = current._debugOwner, workInProgress._debugHookTypes = current._debugHookTypes, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, // Reset the effect tag.
workInProgress.flags = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null, // We intentionally reset, rather than copy, actualDuration & actualStartTime.
// This prevents time from endlessly accumulating in new commits.
// This has the downside of resetting values for different priority renders,
// But works for yielding (the common case) and should support resuming.
workInProgress.actualDuration = 0, workInProgress.actualStartTime = -1), workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue;
// it cannot be shared with the current fiber.
var currentDependencies = current.dependencies;
switch(workInProgress.dependencies = null === currentDependencies ? null : {
lanes: currentDependencies.lanes,
firstContext: currentDependencies.firstContext
}, workInProgress.sibling = current.sibling, workInProgress.index = current.index, workInProgress.ref = current.ref, workInProgress.selfBaseDuration = current.selfBaseDuration, workInProgress.treeBaseDuration = current.treeBaseDuration, workInProgress._debugNeedsRemount = current._debugNeedsRemount, workInProgress.tag){
case 2:
case 0:
case 15:
case 1:
workInProgress.type = resolveFunctionForHotReloading(current.type);
break;
case 11:
workInProgress.type = resolveForwardRefForHotReloading(current.type);
}
return workInProgress;
} // Used to reuse a Fiber for a second pass.
function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
var pendingProps1, mode1, lanes1, key1, fiber, pendingProps2, mode2, lanes2, fiber1, pendingProps3, mode3, lanes3, fiber2, pendingProps4, mode4, lanes4, fiber3, fiberTag = 2, resolvedType = type; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
if ("function" == typeof type) shouldConstruct$1(type) && (fiberTag = 1), resolvedType = resolveFunctionForHotReloading(resolvedType);
else if ("string" == typeof type) fiberTag = 5;
else getTag: switch(type){
case REACT_FRAGMENT_TYPE:
return createFiberFromFragment(pendingProps.children, mode, lanes, key);
case REACT_DEBUG_TRACING_MODE_TYPE:
fiberTag = 8, mode |= 16;
break;
case REACT_STRICT_MODE_TYPE:
fiberTag = 8, mode |= 1;
break;
case REACT_PROFILER_TYPE:
return pendingProps1 = pendingProps, mode1 = mode, lanes1 = lanes, key1 = key, "string" != typeof pendingProps1.id && error('Profiler must specify an "id" as a prop'), (fiber = createFiber(12, pendingProps1, key1, 8 | mode1)).elementType = REACT_PROFILER_TYPE, fiber.type = REACT_PROFILER_TYPE, fiber.lanes = lanes1, fiber.stateNode = {
effectDuration: 0,
passiveEffectDuration: 0
}, fiber;
case REACT_SUSPENSE_TYPE:
return pendingProps2 = pendingProps, mode2 = mode, lanes2 = lanes, // This needs to be fixed in getComponentName so that it relies on the tag
// instead.
(fiber1 = createFiber(13, pendingProps2, key, mode2)).type = REACT_SUSPENSE_TYPE, fiber1.elementType = REACT_SUSPENSE_TYPE, fiber1.lanes = lanes2, fiber1;
case REACT_SUSPENSE_LIST_TYPE:
return pendingProps3 = pendingProps, mode3 = mode, lanes3 = lanes, // TODO: The SuspenseListComponent fiber shouldn't have a type. It has a tag.
// This needs to be fixed in getComponentName so that it relies on the tag
// instead.
(fiber2 = createFiber(19, pendingProps3, key, mode3)).type = REACT_SUSPENSE_LIST_TYPE, fiber2.elementType = REACT_SUSPENSE_LIST_TYPE, fiber2.lanes = lanes3, fiber2;
case REACT_OFFSCREEN_TYPE:
return createFiberFromOffscreen(pendingProps, mode, lanes, key);
case REACT_LEGACY_HIDDEN_TYPE:
return pendingProps4 = pendingProps, mode4 = mode, lanes4 = lanes, (fiber3 = createFiber(24, pendingProps4, key, mode4)).type = REACT_LEGACY_HIDDEN_TYPE, fiber3.elementType = REACT_LEGACY_HIDDEN_TYPE, fiber3.lanes = lanes4, fiber3;
default:
if ("object" == typeof type && null !== type) switch(type.$$typeof){
case REACT_PROVIDER_TYPE:
fiberTag = 10;
break getTag;
case REACT_CONTEXT_TYPE:
// This is a consumer
fiberTag = 9;
break getTag;
case REACT_FORWARD_REF_TYPE:
fiberTag = 11, resolvedType = resolveForwardRefForHotReloading(resolvedType);
break getTag;
case REACT_MEMO_TYPE:
fiberTag = 14;
break getTag;
case REACT_LAZY_TYPE:
fiberTag = 16, resolvedType = null;
break getTag;
case REACT_BLOCK_TYPE:
fiberTag = 22;
break getTag;
}
var info = "";
(void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
var ownerName = owner ? getComponentName(owner.type) : null;
throw ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`."), Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (null == type ? type : typeof type) + "." + info);
}
var fiber4 = createFiber(fiberTag, pendingProps, key, mode);
return fiber4.elementType = type, fiber4.type = resolvedType, fiber4.lanes = lanes, fiber4._debugOwner = owner, fiber4;
}
function createFiberFromElement(element, mode, lanes) {
var owner = null;
owner = element._owner;
var fiber = createFiberFromTypeAndProps(element.type, element.key, element.props, owner, mode, lanes);
return fiber._debugSource = element._source, fiber._debugOwner = element._owner, fiber;
}
function createFiberFromFragment(elements, mode, lanes, key) {
var fiber = createFiber(7, elements, key, mode);
return fiber.lanes = lanes, fiber;
}
function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
var fiber = createFiber(23, pendingProps, key, mode); // TODO: The OffscreenComponent fiber shouldn't have a type. It has a tag.
return fiber.type = REACT_OFFSCREEN_TYPE, fiber.elementType = REACT_OFFSCREEN_TYPE, fiber.lanes = lanes, fiber;
}
function createFiberFromText(content, mode, lanes) {
var fiber = createFiber(6, content, null, mode);
return fiber.lanes = lanes, fiber;
}
function createFiberFromPortal(portal, mode, lanes) {
var fiber = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
return fiber.lanes = lanes, fiber.stateNode = {
containerInfo: portal.containerInfo,
pendingChildren: null,
// Used by persistent updates
implementation: portal.implementation
}, fiber;
} // Used for stashing WIP properties to replay failed work in DEV.
function assignFiberPropertiesInDEV(target, source) {
return null === target && // This Fiber's initial properties will always be overwritten.
// We only use a Fiber to ensure the same hidden class so DEV isn't slow.
(target = createFiber(2, null, null, 0)), // We tried to use Object.assign() instead but this is called in
// the hottest path, and Object.assign() was too slow:
// https://github.com/facebook/react/issues/12502
// This code is DEV-only so size is not a concern.
target.tag = source.tag, target.key = source.key, target.elementType = source.elementType, target.type = source.type, target.stateNode = source.stateNode, target.return = source.return, target.child = source.child, target.sibling = source.sibling, target.index = source.index, target.ref = source.ref, target.pendingProps = source.pendingProps, target.memoizedProps = source.memoizedProps, target.updateQueue = source.updateQueue, target.memoizedState = source.memoizedState, target.dependencies = source.dependencies, target.mode = source.mode, target.flags = source.flags, target.nextEffect = source.nextEffect, target.firstEffect = source.firstEffect, target.lastEffect = source.lastEffect, target.lanes = source.lanes, target.childLanes = source.childLanes, target.alternate = source.alternate, target.actualDuration = source.actualDuration, target.actualStartTime = source.actualStartTime, target.selfBaseDuration = source.selfBaseDuration, target.treeBaseDuration = source.treeBaseDuration, target._debugID = source._debugID, target._debugSource = source._debugSource, target._debugOwner = source._debugOwner, target._debugNeedsRemount = source._debugNeedsRemount, target._debugHookTypes = source._debugHookTypes, target;
}
function FiberRootNode(containerInfo, tag, hydrate) {
switch(this.tag = tag, this.containerInfo = containerInfo, this.pendingChildren = null, this.current = null, this.pingCache = null, this.finishedWork = null, this.timeoutHandle = -1, this.context = null, this.pendingContext = null, this.hydrate = hydrate, this.callbackNode = null, this.callbackPriority = 0, this.eventTimes = createLaneMap(0), this.expirationTimes = createLaneMap(-1), this.pendingLanes = 0, this.suspendedLanes = 0, this.pingedLanes = 0, this.expiredLanes = 0, this.mutableReadLanes = 0, this.finishedLanes = 0, this.entangledLanes = 0, this.entanglements = createLaneMap(0), this.mutableSourceEagerHydrationData = null, this.interactionThreadID = unstable_getThreadID(), this.memoizedInteractions = new Set(), this.pendingInteractionMap = new Map(), tag){
case 1:
this._debugRootType = "createBlockingRoot()";
break;
case 2:
this._debugRootType = "createRoot()";
break;
case 0:
this._debugRootType = "createLegacyRoot()";
}
}
function updateContainer(element, container, parentComponent, callback) {
!function(root, children) {
if (injectedHook && "function" == typeof injectedHook.onScheduleFiberRoot) try {
injectedHook.onScheduleFiberRoot(rendererID, root, children);
} catch (err) {
hasLoggedError || (hasLoggedError = !0, error("React instrumentation encountered an error: %s", err));
}
}(container, element);
var current$1 = container.current, eventTime = requestEventTime();
// $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
"undefined" != typeof jest && (!1 === didWarnAboutUnmockedScheduler && void 0 === unstable_flushAllWithoutAsserting && (2 & current$1.mode || 4 & current$1.mode) && (didWarnAboutUnmockedScheduler = !0, error("In Concurrent or Sync modes, the \"scheduler\" module needs to be mocked to guarantee consistent behaviour across tests and browsers. For example, with jest: \njest.mock('scheduler', () => require('scheduler/unstable_mock'));\n\nFor more info, visit https://reactjs.org/link/mock-scheduler")), warnIfNotScopedWithMatchingAct(current$1));
var lane = requestUpdateLane(current$1), context = function(parentComponent) {
if (!parentComponent) return emptyContextObject;
var fiber = get(parentComponent), parentContext = function(fiber) {
// Currently this is only used with renderSubtreeIntoContainer; not sure if it
// makes sense elsewhere
if (getNearestMountedFiber(fiber) !== fiber || 1 !== fiber.tag) throw Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.");
var node = fiber;
do {
switch(node.tag){
case 3:
return node.stateNode.context;
case 1:
if (isContextProvider(node.type)) return node.stateNode.__reactInternalMemoizedMergedChildContext;
}
node = node.return;
}while (null !== node)
throw Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
}(fiber);
if (1 === fiber.tag) {
var Component = fiber.type;
if (isContextProvider(Component)) return processChildContext(fiber, Component, parentContext);
}
return parentContext;
}(parentComponent);
null === container.context ? container.context = context : container.pendingContext = context, isRendering && null !== current && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = !0, error("Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.\n\nCheck the render method of %s.", getComponentName(current.type) || "Unknown"));
var update = createUpdate(eventTime, lane); // Caution: React DevTools currently depends on this property
return(// being called "element".
update.payload = {
element: element
}, null !== (callback = void 0 === callback ? null : callback) && ("function" != typeof callback && error("render(...): Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), update.callback = callback), enqueueUpdate(current$1, update), scheduleUpdateOnFiber(current$1, lane, eventTime), lane);
}
function getPublicRootInstance(container) {
var containerFiber = container.current;
return containerFiber.child ? (containerFiber.child.tag, containerFiber.child.stateNode) : null;
}
function markRetryLaneImpl(fiber, retryLane) {
var a, suspenseState = fiber.memoizedState;
null !== suspenseState && null !== suspenseState.dehydrated && (a = suspenseState.retryLane, suspenseState.retryLane = 0 !== a && a < retryLane ? a : retryLane);
} // Increases the priority of thennables when they resolve within this boundary.
function markRetryLaneIfNotHydrated(fiber, retryLane) {
markRetryLaneImpl(fiber, retryLane);
var alternate = fiber.alternate;
alternate && markRetryLaneImpl(alternate, retryLane);
}
function findHostInstanceWithNoPortals(fiber) {
var hostFiber = function(parent) {
var currentParent = findCurrentFiberUsingSlowPath(parent);
if (!currentParent) return null;
// Next we'll drill down this component to find the first HostComponent/Text.
for(var node = currentParent;;){
if (5 === node.tag || 6 === node.tag) return node;
if (node.child && 4 !== node.tag) {
node.child.return = node, node = node.child;
continue;
}
if (node === currentParent) break;
for(; !node.sibling;){
if (!node.return || node.return === currentParent) return null;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
} // Flow needs the return null here, but ESLint complains about it.
// eslint-disable-next-line no-unreachable
return null;
}(fiber);
return null === hostFiber ? null : 20 === hostFiber.tag ? hostFiber.stateNode.instance : hostFiber.stateNode;
}
didWarnAboutNestedUpdates = !1, didWarnAboutFindNodeInStrictMode = {};
var shouldSuspendImpl = function(fiber) {
return !1;
}, overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, setSuspenseHandler = null, copyWithDeleteImpl = function(obj, path, index) {
var key = path[index], updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj);
return index + 1 === path.length ? Array.isArray(updated) ? updated.splice(key, 1) : delete updated[key] : updated[key] = copyWithDeleteImpl(obj[key], path, index + 1), updated;
}, copyWithDelete = function(obj, path) {
return copyWithDeleteImpl(obj, path, 0);
}, copyWithRenameImpl = function(obj, oldPath, newPath, index) {
var oldKey = oldPath[index], updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj);
return index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], Array.isArray(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : // $FlowFixMe number or string is fine here
updated[oldKey] = copyWithRenameImpl(// $FlowFixMe number or string is fine here
obj[oldKey], oldPath, newPath, index + 1), updated;
}, copyWithRename = function(obj, oldPath, newPath) {
if (oldPath.length !== newPath.length) {
warn("copyWithRename() expects paths of the same length");
return;
}
for(var i = 0; i < newPath.length - 1; i++)if (oldPath[i] !== newPath[i]) {
warn("copyWithRename() expects paths to be the same except for the deepest key");
return;
}
return copyWithRenameImpl(obj, oldPath, newPath, 0);
}, copyWithSetImpl = function(obj, path, index, value) {
if (index >= path.length) return value;
var key = path[index], updated = Array.isArray(obj) ? obj.slice() : _assign({}, obj);
return updated[key] = copyWithSetImpl(obj[key], path, index + 1, value), updated;
}, copyWithSet = function(obj, path, value) {
return copyWithSetImpl(obj, path, 0, value);
}, findHook = function(fiber, id) {
for(// For now, the "id" of stateful hooks is just the stateful hook index.
// This may change in the future with e.g. nested hooks.
var currentHook = fiber.memoizedState; null !== currentHook && id > 0;)currentHook = currentHook.next, id--;
return currentHook;
};
function ReactDOMRoot(container, options) {
this._internalRoot = createRootImpl(container, 2, options);
}
function ReactDOMBlockingRoot(container, tag, options) {
this._internalRoot = createRootImpl(container, tag, options);
}
function createRootImpl(container, tag, options) {
// Tag is either LegacyRoot or Concurrent Root
var root, mode, uninitializedFiber, hostRoot, hydrate = null != options && !0 === options.hydrate;
null != options && options.hydrationOptions;
var mutableSources = null != options && null != options.hydrationOptions && options.hydrationOptions.mutableSources || null, root1 = ((root = new FiberRootNode(container, tag, hydrate)).current = (mode = 2 === tag ? 7 : 3 * (1 === tag), isDevToolsPresent && // Always collect profile timings when DevTools are present.
// This enables DevTools to start capturing timing at any point–
// Without some nodes in the tree having empty base times.
(mode |= 8), uninitializedFiber = createFiber(3, null, null, mode)), uninitializedFiber.stateNode = root, initializeUpdateQueue(uninitializedFiber), root);
if (hostRoot = root1.current, container[internalContainerInstanceKey] = hostRoot, container.nodeType, listenToAllSupportedEvents(8 === container.nodeType ? container.parentNode : container), mutableSources) for(var i = 0; i < mutableSources.length; i++)!// This ensures that the version used for server rendering matches the one
// that is eventually read during hydration.
// If they don't match there's a potential tear and a full deopt render is required.
function(root, mutableSource) {
var version = (0, mutableSource._getVersion)(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
// Retaining it forever may interfere with GC.
null == root.mutableSourceEagerHydrationData ? root.mutableSourceEagerHydrationData = [
mutableSource,
version
] : root.mutableSourceEagerHydrationData.push(mutableSource, version);
}(root1, mutableSources[i]);
return root1;
}
function isValidContainer(node) {
return !!(node && (1 === node.nodeType || 9 === node.nodeType || 11 === node.nodeType || 8 === node.nodeType && " react-mount-point-unstable " === node.nodeValue));
}
overrideHookState = function(fiber, id, path, value) {
var hook = findHook(fiber, id);
if (null !== hook) {
var newState = copyWithSet(hook.memoizedState, path, value);
hook.memoizedState = newState, hook.baseState = newState, // because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps), scheduleUpdateOnFiber(fiber, 1, -1);
}
}, overrideHookStateDeletePath = function(fiber, id, path) {
var hook = findHook(fiber, id);
if (null !== hook) {
var newState = copyWithDelete(hook.memoizedState, path);
hook.memoizedState = newState, hook.baseState = newState, // because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps), scheduleUpdateOnFiber(fiber, 1, -1);
}
}, overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
var hook = findHook(fiber, id);
if (null !== hook) {
var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
hook.memoizedState = newState, hook.baseState = newState, // because there is no update we can add for useReducer hooks that won't trigger an error.
// (There's no appropriate action type for DevTools overrides.)
// As a result though, React will see the scheduled update as a noop and bailout.
// Shallow cloning props works as a workaround for now to bypass the bailout check.
fiber.memoizedProps = _assign({}, fiber.memoizedProps), scheduleUpdateOnFiber(fiber, 1, -1);
}
}, overrideProps = function(fiber, path, value) {
fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value), fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps), scheduleUpdateOnFiber(fiber, 1, -1);
}, overridePropsDeletePath = function(fiber, path) {
fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path), fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps), scheduleUpdateOnFiber(fiber, 1, -1);
}, overridePropsRenamePath = function(fiber, oldPath, newPath) {
fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath), fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps), scheduleUpdateOnFiber(fiber, 1, -1);
}, scheduleUpdate = function(fiber) {
scheduleUpdateOnFiber(fiber, 1, -1);
}, setSuspenseHandler = function(newShouldSuspendImpl) {
shouldSuspendImpl = newShouldSuspendImpl;
}, ReactDOMRoot.prototype.render = ReactDOMBlockingRoot.prototype.render = function(children) {
var root = this._internalRoot;
"function" == typeof arguments[1] && error("render(...): does not support the second callback argument. To execute a side effect after rendering, declare it in a component body with useEffect().");
var container = root.containerInfo;
if (8 !== container.nodeType) {
var hostInstance = findHostInstanceWithNoPortals(root.current);
hostInstance && hostInstance.parentNode !== container && error("render(...): It looks like the React-rendered content of the root container was removed without using React. This is not supported and will cause errors. Instead, call root.unmount() to empty a root's container.");
}
updateContainer(children, root, null, null);
}, ReactDOMRoot.prototype.unmount = ReactDOMBlockingRoot.prototype.unmount = function() {
"function" == typeof arguments[0] && error("unmount(...): does not support a callback argument. To execute a side effect after rendering, declare it in a component body with useEffect().");
var root = this._internalRoot, container = root.containerInfo;
updateContainer(null, root, null, function() {
container[internalContainerInstanceKey] = null;
});
};
var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner, warnedAboutHydrateAPI = !1;
function getReactRootElementInContainer(container) {
return container ? 9 === container.nodeType ? container.documentElement : container.firstChild : null;
}
function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
topLevelUpdateWarnings(container), null !== (callback1 = void 0 === callback ? null : callback) && "function" != typeof callback1 && error("%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.", "render", callback1);
// member of intersection type." Whyyyyyy.
var callback1, fiberRoot, root = container._reactRootContainer;
if (root) {
if (fiberRoot = root._internalRoot, "function" == typeof callback) {
var _originalCallback = callback;
callback = function() {
var instance = getPublicRootInstance(fiberRoot);
_originalCallback.call(instance);
};
} // Update
updateContainer(children, fiberRoot, parentComponent, callback);
} else {
if (fiberRoot = // Initial mount
(root = container._reactRootContainer = function(container, forceHydrate) {
var shouldHydrate = forceHydrate || !!((rootElement = getReactRootElementInContainer(container)) && 1 === rootElement.nodeType && rootElement.hasAttribute(ROOT_ATTRIBUTE_NAME)); // First clear any existing content.
if (!shouldHydrate) for(var rootElement, rootSibling, warned = !1; rootSibling = container.lastChild;)!warned && 1 === rootSibling.nodeType && rootSibling.hasAttribute(ROOT_ATTRIBUTE_NAME) && (warned = !0, error("render(): Target node has markup rendered by React, but there are unrelated nodes as well. This is most commonly caused by white-space inserted around server-rendered markup.")), container.removeChild(rootSibling);
return !shouldHydrate || forceHydrate || warnedAboutHydrateAPI || (warnedAboutHydrateAPI = !0, warn("render(): Calling ReactDOM.render() to hydrate server-rendered markup will stop working in React v18. Replace the ReactDOM.render() call with ReactDOM.hydrate() if you want React to attach to the server HTML.")), new ReactDOMBlockingRoot(container, 0, shouldHydrate ? {
hydrate: !0
} : void 0);
}(container, forceHydrate))._internalRoot, "function" == typeof callback) {
var originalCallback = callback;
callback = function() {
var instance = getPublicRootInstance(fiberRoot);
originalCallback.call(instance);
};
} // Initial mount should not be batched.
unbatchedUpdates(function() {
updateContainer(children, fiberRoot, parentComponent, callback);
});
}
return getPublicRootInstance(fiberRoot);
}
topLevelUpdateWarnings = function(container) {
if (container._reactRootContainer && 8 !== container.nodeType) {
var hostInstance = findHostInstanceWithNoPortals(container._reactRootContainer._internalRoot.current);
hostInstance && hostInstance.parentNode !== container && error("render(...): It looks like the React-rendered content of this container was removed without using React. This is not supported and will cause errors. Instead, call ReactDOM.unmountComponentAtNode to empty a container.");
}
var isRootRenderedBySomeReact = !!container._reactRootContainer, rootEl = getReactRootElementInContainer(container);
rootEl && getInstanceFromNode(rootEl) && !isRootRenderedBySomeReact && error("render(...): Replacing React-rendered children with a new root component. If you intended to update the children of this node, you should instead have the existing children update their state and render the new components instead of calling ReactDOM.render."), 1 === container.nodeType && container.tagName && "BODY" === container.tagName.toUpperCase() && error("render(): Rendering components directly into document.body is discouraged, since its children are often manipulated by third-party scripts and browser extensions. This may lead to subtle reconciliation issues. Try rendering into a container element created for your app.");
}, attemptUserBlockingHydration = function(fiber) {
13 === fiber.tag && (scheduleUpdateOnFiber(fiber, 4, requestEventTime()), markRetryLaneIfNotHydrated(fiber, 4));
}, attemptContinuousHydration = function(fiber) {
13 === fiber.tag && (scheduleUpdateOnFiber(fiber, 67108864, requestEventTime()), markRetryLaneIfNotHydrated(fiber, 67108864));
}, attemptHydrationAtCurrentPriority = function(fiber) {
if (13 === fiber.tag) {
var eventTime = requestEventTime(), lane = requestUpdateLane(fiber);
scheduleUpdateOnFiber(fiber, lane, eventTime), markRetryLaneIfNotHydrated(fiber, lane);
}
}, attemptHydrationAtPriority = function(priority, fn) {
return fn();
};
var didWarnAboutUnstableCreatePortal = !1;
function createPortal$1(children, container) {
var key = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : null;
if (!isValidContainer(container)) throw Error("Target container is not a DOM element.");
// TODO: pass ReactDOM portal implementation as third argument
// $FlowFixMe The Flow type is opaque but there's no way to actually create it.
return function(children, containerInfo, implementation) {
var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null;
return {
// This tag allow us to uniquely identify this as a React Portal
$$typeof: REACT_PORTAL_TYPE,
key: null == key ? null : "" + key,
children: children,
containerInfo: containerInfo,
implementation: implementation
};
}(children, container, null, key);
}
if (("function" != typeof Map || // $FlowIssue Flow incorrectly thinks Map has no prototype
null == Map.prototype || "function" != typeof Map.prototype.forEach || "function" != typeof Set || // $FlowIssue Flow incorrectly thinks Set has no prototype
null == Set.prototype || "function" != typeof Set.prototype.clear || "function" != typeof Set.prototype.forEach) && error("React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"), restoreImpl = function(domElement, tag, props) {
var value;
switch(tag){
case "input":
updateWrapper(domElement, props), function(rootNode, props) {
var name = props.name;
if ("radio" === props.type && null != name) {
for(var queryRoot = rootNode; queryRoot.parentNode;)queryRoot = queryRoot.parentNode;
// If `rootNode.form` was non-null, then we could try `form.elements`,
for(var group = queryRoot.querySelectorAll("input[name=" + JSON.stringify("" + name) + '][type="radio"]'), i = 0; i < group.length; i++){
var otherNode = group[i];
if (otherNode !== rootNode && otherNode.form === rootNode.form) {
// and the same name are rendered into the same form (same as #1939).
// That's probably okay; we don't support it just as we don't support
// mixing React radio buttons with non-React ones.
var otherProps = getFiberCurrentPropsFromNode(otherNode);
if (!otherProps) throw Error("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.");
// We need update the tracked value on the named cousin since the value
// was changed but the input saw no event or value set
updateValueIfChanged(otherNode), // was previously checked to update will cause it to be come re-checked
// as appropriate.
updateWrapper(otherNode, otherProps);
} // This will throw if radio buttons rendered by different copies of React
}
}
} // In Chrome, assigning defaultValue to certain input types triggers input validation.
(domElement, props);
return;
case "textarea":
// DOM component is still mounted; update
updateWrapper$1(domElement, props);
return;
case "select":
null != (value = props.value) && updateOptions(domElement, !!props.multiple, value, !1);
return;
}
}, batchedUpdatesImpl = batchedUpdates$1, discreteUpdatesImpl = function(fn, a, b, c, d) {
var prevExecutionContext = executionContext;
executionContext |= 4;
try {
return runWithPriority$1(98, fn.bind(null, a, b, c, d));
} finally{
0 === (executionContext = prevExecutionContext) && (// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer(), flushSyncCallbackQueue());
}
}, flushDiscreteUpdatesImpl = function() {
// TODO: Should be able to flush inside batchedUpdates, but not inside `act`.
// However, `act` uses `batchedUpdates`, so there's no way to distinguish
// those two cases. Need to fix this before exposing flushDiscreteUpdates
// as a public API.
if ((49 & executionContext) != 0) {
(16 & executionContext) != 0 && error("unstable_flushDiscreteUpdates: Cannot flush updates when React is already rendering.");
// This is probably a nested event dispatch triggered by a lifecycle/effect,
// like `el.focus()`. Exit.
return;
}
(function() {
if (null !== rootsWithPendingDiscreteUpdates) {
// For each root with pending discrete updates, schedule a callback to
// immediately flush them.
var roots = rootsWithPendingDiscreteUpdates;
rootsWithPendingDiscreteUpdates = null, roots.forEach(function(root) {
root.expiredLanes |= 24 & root.pendingLanes, ensureRootIsScheduled(root, now());
});
} // Now flush the immediate queue.
flushSyncCallbackQueue();
})(), // they fire before the next serial event.
flushPassiveEffects();
}, batchedEventUpdatesImpl = function(fn, a) {
var prevExecutionContext = executionContext;
executionContext |= /* */ 2;
try {
return fn(a);
} finally{
0 === (executionContext = prevExecutionContext) && (// Flush the immediate callbacks that were scheduled during this batch
resetRenderTimer(), flushSyncCallbackQueue());
}
}, findFiberByHostInstance = (devToolsConfig = {
findFiberByHostInstance: getClosestInstanceFromNode,
bundleType: 1,
version: ReactVersion,
rendererPackageName: "react-dom"
}).findFiberByHostInstance, ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher, !function(internals) {
if ("undefined" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) // No DevTools
return !1;
var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
if (hook.isDisabled) // This isn't a real property on the hook, but it can be set to opt out
// of DevTools integration and associated warnings and logs.
// https://github.com/facebook/react/issues/3877
return !0;
if (!hook.supportsFiber) return error("The installed version of React DevTools is too old and will not work with the current version of React. Please update React DevTools. https://reactjs.org/link/react-devtools"), !0;
try {
rendererID = hook.inject(internals), injectedHook = hook;
} catch (err) {
error("React instrumentation encountered an error: %s.", err);
} // DevTools exists
return !0;
}({
bundleType: devToolsConfig.bundleType,
version: devToolsConfig.version,
rendererPackageName: devToolsConfig.rendererPackageName,
rendererConfig: devToolsConfig.rendererConfig,
overrideHookState: overrideHookState,
overrideHookStateDeletePath: overrideHookStateDeletePath,
overrideHookStateRenamePath: overrideHookStateRenamePath,
overrideProps: overrideProps,
overridePropsDeletePath: overridePropsDeletePath,
overridePropsRenamePath: overridePropsRenamePath,
setSuspenseHandler: setSuspenseHandler,
scheduleUpdate: scheduleUpdate,
currentDispatcherRef: ReactCurrentDispatcher,
findHostInstanceByFiber: function(fiber) {
var hostFiber = findCurrentHostFiber(fiber);
return null === hostFiber ? null : hostFiber.stateNode;
},
findFiberByHostInstance: findFiberByHostInstance || function(instance) {
return null;
},
// React Refresh
findHostInstancesForRefresh: function(root, families) {
var hostInstances = new Set(), types = new Set(families.map(function(family) {
return family.current;
}));
return function findHostInstancesForMatchingFibersRecursively(fiber, types, hostInstances) {
var child = fiber.child, sibling = fiber.sibling, tag = fiber.tag, type = fiber.type, candidateType = null;
switch(tag){
case 0:
case 15:
case 1:
candidateType = type;
break;
case 11:
candidateType = type.render;
}
var didMatch = !1;
null !== candidateType && types.has(candidateType) && (didMatch = !0), didMatch ? // We have a match. This only drills down to the closest host components.
// There's no need to search deeper because for the purpose of giving
// visual feedback, "flashing" outermost parent rectangles is sufficient.
function(fiber, hostInstances) {
if (!function(fiber, hostInstances) {
for(var node = fiber, foundHostInstances = !1;;){
if (5 === node.tag) // We got a match.
foundHostInstances = !0, hostInstances.add(node.stateNode);
else if (null !== node.child) {
node.child.return = node, node = node.child;
continue;
}
if (node === fiber) return foundHostInstances;
for(; null === node.sibling;){
if (null === node.return || node.return === fiber) return foundHostInstances;
node = node.return;
}
node.sibling.return = node.return, node = node.sibling;
}
return !1;
}(fiber, hostInstances)) for(var node = fiber;;){
switch(node.tag){
case 5:
hostInstances.add(node.stateNode);
return;
case 4:
case 3:
hostInstances.add(node.stateNode.containerInfo);
return;
}
if (null === node.return) throw Error("Expected to reach root first.");
node = node.return;
}
// If we didn't find any host children, fallback to closest host parent.
}(fiber, hostInstances) : null !== child && findHostInstancesForMatchingFibersRecursively(child, types, hostInstances), null !== sibling && findHostInstancesForMatchingFibersRecursively(sibling, types, hostInstances);
}(root.current, types, hostInstances), hostInstances;
},
scheduleRefresh: function(root, update) {
if (null !== resolveFamily) {
var staleFamilies = update.staleFamilies, updatedFamilies = update.updatedFamilies;
flushPassiveEffects(), flushSync(function() {
(function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
var alternate = fiber.alternate, child = fiber.child, sibling = fiber.sibling, tag = fiber.tag, type = fiber.type, candidateType = null;
switch(tag){
case 0:
case 15:
case 1:
candidateType = type;
break;
case 11:
candidateType = type.render;
}
if (null === resolveFamily) throw Error("Expected resolveFamily to be set during hot reload.");
var needsRender = !1, needsRemount = !1;
if (null !== candidateType) {
var family = resolveFamily(candidateType);
void 0 !== family && (staleFamilies.has(family) ? needsRemount = !0 : updatedFamilies.has(family) && (1 === tag ? needsRemount = !0 : needsRender = !0));
}
null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== alternate && failedBoundaries.has(alternate)) && (needsRemount = !0), needsRemount && (fiber._debugNeedsRemount = !0), (needsRemount || needsRender) && scheduleUpdateOnFiber(fiber, 1, -1), null === child || needsRemount || scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies), null !== sibling && scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
})(root.current, updatedFamilies, staleFamilies);
});
}
},
scheduleRoot: function(root, element) {
root.context === emptyContextObject && (flushPassiveEffects(), flushSync(function() {
updateContainer(element, root, null, null);
}));
},
setRefreshHandler: function(handler) {
resolveFamily = handler;
},
// Enables DevTools to append owner stacks to error messages in DEV mode.
getCurrentFiber: function() {
return current;
}
}) && canUseDOM && window.top === window.self && (navigator.userAgent.indexOf("Chrome") > -1 && -1 === navigator.userAgent.indexOf("Edge") || navigator.userAgent.indexOf("Firefox") > -1)) {
var protocol = window.location.protocol; // Don't warn in exotic cases like chrome-extension://.
/^(https?|file):$/.test(protocol) && // eslint-disable-next-line react-internal/no-production-logging
console.info("%cDownload the React DevTools for a better development experience: https://reactjs.org/link/react-devtools" + ("file:" === protocol ? "\nYou might need to use a local HTTP server (instead of file://): https://reactjs.org/link/react-devtools-faq" : ""), "font-weight:bold");
}
exports1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
// Keep in sync with ReactTestUtils.js, and ReactTestUtilsAct.js.
// This is an array for better minification.
Events: [
getInstanceFromNode,
getNodeFromInstance,
getFiberCurrentPropsFromNode,
enqueueStateRestore,
restoreStateIfNeeded,
flushPassiveEffects,
IsThisRendererActing
]
}, exports1.createPortal = createPortal$1, exports1.findDOMNode = function(componentOrElement) {
var owner = ReactCurrentOwner$3.current;
return (null !== owner && null !== owner.stateNode && (owner.stateNode._warnedAboutRefsInRender || error("%s is accessing findDOMNode inside its render(). render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentName(owner.type) || "A component"), owner.stateNode._warnedAboutRefsInRender = !0), null == componentOrElement) ? null : 1 === componentOrElement.nodeType ? componentOrElement : function(component, methodName) {
var fiber = get(component);
if (void 0 === fiber) {
if ("function" == typeof component.render) throw Error("Unable to find node on an unmounted component.");
throw Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component));
}
var hostFiber = findCurrentHostFiber(fiber);
if (null === hostFiber) return null;
if (1 & hostFiber.mode) {
var componentName = getComponentName(fiber.type) || "Component";
if (!didWarnAboutFindNodeInStrictMode[componentName]) {
didWarnAboutFindNodeInStrictMode[componentName] = !0;
var previousFiber = current;
try {
setCurrentFiber(hostFiber), 1 & fiber.mode ? error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-find-node", methodName, methodName, componentName) : error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-find-node", methodName, methodName, componentName);
} finally{
// Ideally this should reset to previous but this shouldn't be called in
// render and there's another warning for that anyway.
previousFiber ? setCurrentFiber(previousFiber) : resetCurrentFiber();
}
}
}
return hostFiber.stateNode;
}(componentOrElement, "findDOMNode");
}, exports1.flushSync = flushSync, exports1.hydrate = function(element, container, callback) {
if (!isValidContainer(container)) throw Error("Target container is not a DOM element.");
return container[internalContainerInstanceKey] && void 0 === container._reactRootContainer && error("You are calling ReactDOM.hydrate() on a container that was previously passed to ReactDOM.createRoot(). This is not supported. Did you mean to call createRoot(container, {hydrate: true}).render(element)?"), legacyRenderSubtreeIntoContainer(null, element, container, !0, callback);
}, exports1.render = function(element, container, callback) {
if (!isValidContainer(container)) throw Error("Target container is not a DOM element.");
return container[internalContainerInstanceKey] && void 0 === container._reactRootContainer && error("You are calling ReactDOM.render() on a container that was previously passed to ReactDOM.createRoot(). This is not supported. Did you mean to call root.render(element)?"), legacyRenderSubtreeIntoContainer(null, element, container, !1, callback);
}, exports1.unmountComponentAtNode = function(container) {
if (!isValidContainer(container)) throw Error("unmountComponentAtNode(...): Target container is not a DOM element.");
if (container[internalContainerInstanceKey] && void 0 === container._reactRootContainer && error("You are calling ReactDOM.unmountComponentAtNode() on a container that was previously passed to ReactDOM.createRoot(). This is not supported. Did you mean to call root.unmount()?"), container._reactRootContainer) {
var rootEl = getReactRootElementInContainer(container);
// get `true` twice. That's probably fine?
return rootEl && !getInstanceFromNode(rootEl) && error("unmountComponentAtNode(): The node you're attempting to unmount was rendered by another copy of React."), unbatchedUpdates(function() {
legacyRenderSubtreeIntoContainer(null, null, container, !1, function() {
// $FlowFixMe This should probably use `delete container._reactRootContainer`
container._reactRootContainer = null, container[internalContainerInstanceKey] = null;
});
}), !0;
}
var _rootEl = getReactRootElementInContainer(container), hasNonRootReactChild = !!(_rootEl && getInstanceFromNode(_rootEl)), isContainerReactRoot = 1 === container.nodeType && isValidContainer(container.parentNode) && !!container.parentNode._reactRootContainer;
return hasNonRootReactChild && error("unmountComponentAtNode(): The node you're attempting to unmount was rendered by React and is not a top-level container. %s", isContainerReactRoot ? "You may have accidentally passed in a React root node instead of its container." : "Instead, have the parent component update its state and rerender in order to remove this component."), !1;
}, exports1.unstable_batchedUpdates = batchedUpdates$1, exports1.unstable_createPortal = function(children, container) {
var key = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : null;
return didWarnAboutUnstableCreatePortal || (didWarnAboutUnstableCreatePortal = !0, warn('The ReactDOM.unstable_createPortal() alias has been deprecated, and will be removed in React 18+. Update your code to use ReactDOM.createPortal() instead. It has the exact same API, but without the "unstable_" prefix.')), createPortal$1(children, container, key);
}, exports1.unstable_renderSubtreeIntoContainer = function(parentComponent, element, containerNode, callback) {
return function(parentComponent, element, containerNode, callback) {
if (!isValidContainer(containerNode)) throw Error("Target container is not a DOM element.");
if (null == parentComponent || void 0 === parentComponent._reactInternals) throw Error("parentComponent must be a valid React Component");
return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, !1, callback);
}(parentComponent, element, containerNode, callback);
}, exports1.version = ReactVersion;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/underscore-1.5.2.js | JavaScript | // Underscore.js 1.5.2
// http://underscorejs.org
// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Underscore may be freely distributed under the MIT license.
(function() {
// Baseline setup
// --------------
// Establish the root object, `window` in the browser, or `exports` on the server.
var root = this, previousUnderscore = root._, breaker = {}, ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype, push = ArrayProto.push, slice = ArrayProto.slice, concat = ArrayProto.concat, toString = ObjProto.toString, hasOwnProperty = ObjProto.hasOwnProperty, nativeForEach = ArrayProto.forEach, nativeMap = ArrayProto.map, nativeReduce = ArrayProto.reduce, nativeReduceRight = ArrayProto.reduceRight, nativeFilter = ArrayProto.filter, nativeEvery = ArrayProto.every, nativeSome = ArrayProto.some, nativeIndexOf = ArrayProto.indexOf, nativeLastIndexOf = ArrayProto.lastIndexOf, nativeIsArray = Array.isArray, nativeKeys = Object.keys, nativeBind = FuncProto.bind, _ = function(obj) {
return obj instanceof _ ? obj : this instanceof _ ? void (this._wrapped = obj) : new _(obj);
};
"undefined" != typeof exports ? ("undefined" != typeof module && module.exports && (exports = module.exports = _), exports._ = _) : root._ = _, // Current version.
_.VERSION = "1.5.2";
// Collection Functions
// --------------------
// The cornerstone, an `each` implementation, aka `forEach`.
// Handles objects with the built-in `forEach`, arrays, and raw objects.
// Delegates to **ECMAScript 5**'s native `forEach` if available.
var each = _.each = _.forEach = function(obj, iterator, context) {
if (null != obj) {
if (nativeForEach && obj.forEach === nativeForEach) obj.forEach(iterator, context);
else if (obj.length === +obj.length) {
for(var i = 0, length = obj.length; i < length; i++)if (iterator.call(context, obj[i], i, obj) === breaker) return;
} else for(var keys = _.keys(obj), i = 0, length = keys.length; i < length; i++)if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
}
};
// Return the results of applying the iterator to each element.
// Delegates to **ECMAScript 5**'s native `map` if available.
_.map = _.collect = function(obj, iterator, context) {
var results = [];
return null == obj ? results : nativeMap && obj.map === nativeMap ? obj.map(iterator, context) : (each(obj, function(value, index, list) {
results.push(iterator.call(context, value, index, list));
}), results);
};
var reduceError = "Reduce of empty array with no initial value";
// **Reduce** builds up a single result from a list of values, aka `inject`,
// or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
_.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (null == obj && (obj = []), nativeReduce && obj.reduce === nativeReduce) return context && (iterator = _.bind(iterator, context)), initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
if (each(obj, function(value, index, list) {
initial ? memo = iterator.call(context, memo, value, index, list) : (memo = value, initial = !0);
}), !initial) throw TypeError(reduceError);
return memo;
}, // The right-associative version of reduce, also known as `foldr`.
// Delegates to **ECMAScript 5**'s native `reduceRight` if available.
_.reduceRight = _.foldr = function(obj, iterator, memo, context) {
var initial = arguments.length > 2;
if (null == obj && (obj = []), nativeReduceRight && obj.reduceRight === nativeReduceRight) return context && (iterator = _.bind(iterator, context)), initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
var length = obj.length;
if (length !== +length) {
var keys = _.keys(obj);
length = keys.length;
}
if (each(obj, function(value, index, list) {
index = keys ? keys[--length] : --length, initial ? memo = iterator.call(context, memo, obj[index], index, list) : (memo = obj[index], initial = !0);
}), !initial) throw TypeError(reduceError);
return memo;
}, // Return the first value which passes a truth test. Aliased as `detect`.
_.find = _.detect = function(obj, iterator, context) {
var result;
return any(obj, function(value, index, list) {
if (iterator.call(context, value, index, list)) return result = value, !0;
}), result;
}, // Return all the elements that pass a truth test.
// Delegates to **ECMAScript 5**'s native `filter` if available.
// Aliased as `select`.
_.filter = _.select = function(obj, iterator, context) {
var results = [];
return null == obj ? results : nativeFilter && obj.filter === nativeFilter ? obj.filter(iterator, context) : (each(obj, function(value, index, list) {
iterator.call(context, value, index, list) && results.push(value);
}), results);
}, // Return all the elements for which a truth test fails.
_.reject = function(obj, iterator, context) {
return _.filter(obj, function(value, index, list) {
return !iterator.call(context, value, index, list);
}, context);
}, // Determine whether all of the elements match a truth test.
// Delegates to **ECMAScript 5**'s native `every` if available.
// Aliased as `all`.
_.every = _.all = function(obj, iterator, context) {
iterator || (iterator = _.identity);
var result = !0;
return null == obj ? result : nativeEvery && obj.every === nativeEvery ? obj.every(iterator, context) : (each(obj, function(value, index, list) {
if (!(result = result && iterator.call(context, value, index, list))) return breaker;
}), !!result);
};
// Determine if at least one element in the object matches a truth test.
// Delegates to **ECMAScript 5**'s native `some` if available.
// Aliased as `any`.
var any = _.some = _.any = function(obj, iterator, context) {
iterator || (iterator = _.identity);
var result = !1;
return null == obj ? result : nativeSome && obj.some === nativeSome ? obj.some(iterator, context) : (each(obj, function(value, index, list) {
if (result || (result = iterator.call(context, value, index, list))) return breaker;
}), !!result);
};
// Determine if the array or object contains a given value (using `===`).
// Aliased as `include`.
_.contains = _.include = function(obj, target) {
return null != obj && (nativeIndexOf && obj.indexOf === nativeIndexOf ? -1 != obj.indexOf(target) : any(obj, function(value) {
return value === target;
}));
}, // Invoke a method (with arguments) on every item in a collection.
_.invoke = function(obj, method) {
var args = slice.call(arguments, 2), isFunc = _.isFunction(method);
return _.map(obj, function(value) {
return (isFunc ? method : value[method]).apply(value, args);
});
}, // Convenience version of a common use case of `map`: fetching a property.
_.pluck = function(obj, key) {
return _.map(obj, function(value) {
return value[key];
});
}, // Convenience version of a common use case of `filter`: selecting only objects
// containing specific `key:value` pairs.
_.where = function(obj, attrs, first) {
return _.isEmpty(attrs) ? first ? void 0 : [] : _[first ? "find" : "filter"](obj, function(value) {
for(var key in attrs)if (attrs[key] !== value[key]) return !1;
return !0;
});
}, // Convenience version of a common use case of `find`: getting the first object
// containing specific `key:value` pairs.
_.findWhere = function(obj, attrs) {
return _.where(obj, attrs, !0);
}, // Return the maximum element or (element-based computation).
// Can't optimize arrays of integers longer than 65,535 elements.
// See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
_.max = function(obj, iterator, context) {
if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) return Math.max.apply(Math, obj);
if (!iterator && _.isEmpty(obj)) return -1 / 0;
var result = {
computed: -1 / 0,
value: -1 / 0
};
return each(obj, function(value, index, list) {
var computed = iterator ? iterator.call(context, value, index, list) : value;
computed > result.computed && (result = {
value: value,
computed: computed
});
}), result.value;
}, // Return the minimum element (or element-based computation).
_.min = function(obj, iterator, context) {
if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) return Math.min.apply(Math, obj);
if (!iterator && _.isEmpty(obj)) return 1 / 0;
var result = {
computed: 1 / 0,
value: 1 / 0
};
return each(obj, function(value, index, list) {
var computed = iterator ? iterator.call(context, value, index, list) : value;
computed < result.computed && (result = {
value: value,
computed: computed
});
}), result.value;
}, // Shuffle an array, using the modern version of the
// [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
_.shuffle = function(obj) {
var rand, index = 0, shuffled = [];
return each(obj, function(value) {
rand = _.random(index++), shuffled[index - 1] = shuffled[rand], shuffled[rand] = value;
}), shuffled;
}, // Sample **n** random values from an array.
// If **n** is not specified, returns a single random element from the array.
// The internal `guard` argument allows it to work with `map`.
_.sample = function(obj, n, guard) {
return arguments.length < 2 || guard ? obj[_.random(obj.length - 1)] : _.shuffle(obj).slice(0, Math.max(0, n));
};
// An internal function to generate lookup iterators.
var lookupIterator = function(value) {
return _.isFunction(value) ? value : function(obj) {
return obj[value];
};
};
// Sort the object's values by a criterion produced by an iterator.
_.sortBy = function(obj, value, context) {
var iterator = lookupIterator(value);
return _.pluck(_.map(obj, function(value, index, list) {
return {
value: value,
index: index,
criteria: iterator.call(context, value, index, list)
};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
if (a !== b) {
if (a > b || void 0 === a) return 1;
if (a < b || void 0 === b) return -1;
}
return left.index - right.index;
}), "value");
};
// An internal function used for aggregate "group by" operations.
var group = function(behavior) {
return function(obj, value, context) {
var result = {}, iterator = null == value ? _.identity : lookupIterator(value);
return each(obj, function(value, index) {
behavior(result, iterator.call(context, value, index, obj), value);
}), result;
};
};
// Groups the object's values by a criterion. Pass either a string attribute
// to group by, or a function that returns the criterion.
_.groupBy = group(function(result, key, value) {
(_.has(result, key) ? result[key] : result[key] = []).push(value);
}), // Indexes the object's values by a criterion, similar to `groupBy`, but for
// when you know that your index values will be unique.
_.indexBy = group(function(result, key, value) {
result[key] = value;
}), // Counts instances of an object that group by a certain criterion. Pass
// either a string attribute to count by, or a function that returns the
// criterion.
_.countBy = group(function(result, key) {
_.has(result, key) ? result[key]++ : result[key] = 1;
}), // Use a comparator function to figure out the smallest index at which
// an object should be inserted so as to maintain order. Uses binary search.
_.sortedIndex = function(array, obj, iterator, context) {
for(var value = (iterator = null == iterator ? _.identity : lookupIterator(iterator)).call(context, obj), low = 0, high = array.length; low < high;){
var mid = low + high >>> 1;
iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
}
return low;
}, // Safely create a real, live array from anything iterable.
_.toArray = function(obj) {
return obj ? _.isArray(obj) ? slice.call(obj) : obj.length === +obj.length ? _.map(obj, _.identity) : _.values(obj) : [];
}, // Return the number of elements in an object.
_.size = function(obj) {
return null == obj ? 0 : obj.length === +obj.length ? obj.length : _.keys(obj).length;
}, // Array Functions
// ---------------
// Get the first element of an array. Passing **n** will return the first N
// values in the array. Aliased as `head` and `take`. The **guard** check
// allows it to work with `_.map`.
_.first = _.head = _.take = function(array, n, guard) {
if (null != array) return null == n || guard ? array[0] : slice.call(array, 0, n);
}, // Returns everything but the last entry of the array. Especially useful on
// the arguments object. Passing **n** will return all the values in
// the array, excluding the last N. The **guard** check allows it to work with
// `_.map`.
_.initial = function(array, n, guard) {
return slice.call(array, 0, array.length - (null == n || guard ? 1 : n));
}, // Get the last element of an array. Passing **n** will return the last N
// values in the array. The **guard** check allows it to work with `_.map`.
_.last = function(array, n, guard) {
if (null != array) return null == n || guard ? array[array.length - 1] : slice.call(array, Math.max(array.length - n, 0));
}, // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
// Especially useful on the arguments object. Passing an **n** will return
// the rest N values in the array. The **guard**
// check allows it to work with `_.map`.
_.rest = _.tail = _.drop = function(array, n, guard) {
return slice.call(array, null == n || guard ? 1 : n);
}, // Trim out all falsy values from an array.
_.compact = function(array) {
return _.filter(array, _.identity);
};
// Internal implementation of a recursive `flatten` function.
var flatten = function(input, shallow, output) {
return shallow && _.every(input, _.isArray) ? concat.apply(output, input) : (each(input, function(value) {
_.isArray(value) || _.isArguments(value) ? shallow ? push.apply(output, value) : flatten(value, shallow, output) : output.push(value);
}), output);
};
// Flatten out an array, either recursively (by default), or just one level.
_.flatten = function(array, shallow) {
return flatten(array, shallow, []);
}, // Return a version of the array that does not contain the specified value(s).
_.without = function(array) {
return _.difference(array, slice.call(arguments, 1));
}, // Produce a duplicate-free version of the array. If the array has already
// been sorted, you have the option of using a faster algorithm.
// Aliased as `unique`.
_.uniq = _.unique = function(array, isSorted, iterator, context) {
_.isFunction(isSorted) && (context = iterator, iterator = isSorted, isSorted = !1);
var initial = iterator ? _.map(array, iterator, context) : array, results = [], seen = [];
return each(initial, function(value, index) {
(isSorted ? index && seen[seen.length - 1] === value : _.contains(seen, value)) || (seen.push(value), results.push(array[index]));
}), results;
}, // Produce an array that contains the union: each distinct element from all of
// the passed-in arrays.
_.union = function() {
return _.uniq(_.flatten(arguments, !0));
}, // Produce an array that contains every item shared between all the
// passed-in arrays.
_.intersection = function(array) {
var rest = slice.call(arguments, 1);
return _.filter(_.uniq(array), function(item) {
return _.every(rest, function(other) {
return _.indexOf(other, item) >= 0;
});
});
}, // Take the difference between one array and a number of other arrays.
// Only the elements present in just the first array will remain.
_.difference = function(array) {
var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
return _.filter(array, function(value) {
return !_.contains(rest, value);
});
}, // Zip together multiple lists into a single array -- elements that share
// an index go together.
_.zip = function() {
for(var length = _.max(_.pluck(arguments, "length").concat(0)), results = Array(length), i = 0; i < length; i++)results[i] = _.pluck(arguments, "" + i);
return results;
}, // Converts lists into objects. Pass either a single array of `[key, value]`
// pairs, or two parallel arrays of the same length -- one of keys, and one of
// the corresponding values.
_.object = function(list, values) {
if (null == list) return {};
for(var result = {}, i = 0, length = list.length; i < length; i++)values ? result[list[i]] = values[i] : result[list[i][0]] = list[i][1];
return result;
}, // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
// we need this function. Return the position of the first occurrence of an
// item in an array, or -1 if the item is not included in the array.
// Delegates to **ECMAScript 5**'s native `indexOf` if available.
// If the array is large and already in sort order, pass `true`
// for **isSorted** to use binary search.
_.indexOf = function(array, item, isSorted) {
if (null == array) return -1;
var i = 0, length = array.length;
if (isSorted) {
if ("number" != typeof isSorted) return i = _.sortedIndex(array, item), array[i] === item ? i : -1;
i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
}
if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
for(; i < length; i++)if (array[i] === item) return i;
return -1;
}, // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
_.lastIndexOf = function(array, item, from) {
if (null == array) return -1;
var hasIndex = null != from;
if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
for(var i = hasIndex ? from : array.length; i--;)if (array[i] === item) return i;
return -1;
}, // Generate an integer Array containing an arithmetic progression. A port of
// the native Python `range()` function. See
// [the Python documentation](http://docs.python.org/library/functions.html#range).
_.range = function(start, stop, step) {
arguments.length <= 1 && (stop = start || 0, start = 0), step = arguments[2] || 1;
for(var length = Math.max(Math.ceil((stop - start) / step), 0), idx = 0, range = Array(length); idx < length;)range[idx++] = start, start += step;
return range;
};
// Function (ahem) Functions
// ------------------
// Reusable constructor function for prototype setting.
var ctor = function() {};
// Create a function bound to a given object (assigning `this`, and arguments,
// optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
// available.
_.bind = function(func, context) {
var args, bound;
if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
if (!_.isFunction(func)) throw TypeError();
return args = slice.call(arguments, 2), bound = function() {
if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
ctor.prototype = func.prototype;
var self = new ctor();
ctor.prototype = null;
var result = func.apply(self, args.concat(slice.call(arguments)));
return Object(result) === result ? result : self;
};
}, // Partially apply a function by creating a version that has had some of its
// arguments pre-filled, without changing its dynamic `this` context.
_.partial = function(func) {
var args = slice.call(arguments, 1);
return function() {
return func.apply(this, args.concat(slice.call(arguments)));
};
}, // Bind all of an object's methods to that object. Useful for ensuring that
// all callbacks defined on an object belong to it.
_.bindAll = function(obj) {
var funcs = slice.call(arguments, 1);
if (0 === funcs.length) throw Error("bindAll must be passed function names");
return each(funcs, function(f) {
obj[f] = _.bind(obj[f], obj);
}), obj;
}, // Memoize an expensive function by storing its results.
_.memoize = function(func, hasher) {
var memo = {};
return hasher || (hasher = _.identity), function() {
var key = hasher.apply(this, arguments);
return _.has(memo, key) ? memo[key] : memo[key] = func.apply(this, arguments);
};
}, // Delays a function for the given number of milliseconds, and then calls
// it with the arguments supplied.
_.delay = function(func, wait) {
var args = slice.call(arguments, 2);
return setTimeout(function() {
return func.apply(null, args);
}, wait);
}, // Defers a function, scheduling it to run after the current call stack has
// cleared.
_.defer = function(func) {
return _.delay.apply(_, [
func,
1
].concat(slice.call(arguments, 1)));
}, // Returns a function, that, when invoked, will only be triggered at most once
// during a given window of time. Normally, the throttled function will run
// as much as it can, without ever going more than once per `wait` duration;
// but if you'd like to disable the execution on the leading edge, pass
// `{leading: false}`. To disable execution on the trailing edge, ditto.
_.throttle = function(func, wait, options) {
var context, args, result, timeout = null, previous = 0;
options || (options = {});
var later = function() {
previous = !1 === options.leading ? 0 : new Date(), timeout = null, result = func.apply(context, args);
};
return function() {
var now = new Date();
previous || !1 !== options.leading || (previous = now);
var remaining = wait - (now - previous);
return context = this, args = arguments, remaining <= 0 ? (clearTimeout(timeout), timeout = null, previous = now, result = func.apply(context, args)) : timeout || !1 === options.trailing || (timeout = setTimeout(later, remaining)), result;
};
}, // Returns a function, that, as long as it continues to be invoked, will not
// be triggered. The function will be called after it stops being called for
// N milliseconds. If `immediate` is passed, trigger the function on the
// leading edge, instead of the trailing.
_.debounce = function(func, wait, immediate) {
var timeout, args, context, timestamp, result;
return function() {
context = this, args = arguments, timestamp = new Date();
var later = function() {
var last = new Date() - timestamp;
last < wait ? timeout = setTimeout(later, wait - last) : (timeout = null, immediate || (result = func.apply(context, args)));
}, callNow = immediate && !timeout;
return timeout || (timeout = setTimeout(later, wait)), callNow && (result = func.apply(context, args)), result;
};
}, // Returns a function that will be executed at most one time, no matter how
// often you call it. Useful for lazy initialization.
_.once = function(func) {
var memo, ran = !1;
return function() {
return ran || (ran = !0, memo = func.apply(this, arguments), func = null), memo;
};
}, // Returns the first function passed as an argument to the second,
// allowing you to adjust arguments, run code before and after, and
// conditionally execute the original function.
_.wrap = function(func, wrapper) {
return function() {
var args = [
func
];
return push.apply(args, arguments), wrapper.apply(this, args);
};
}, // Returns a function that is the composition of a list of functions, each
// consuming the return value of the function that follows.
_.compose = function() {
var funcs = arguments;
return function() {
for(var args = arguments, i = funcs.length - 1; i >= 0; i--)args = [
funcs[i].apply(this, args)
];
return args[0];
};
}, // Returns a function that will only be executed after being called N times.
_.after = function(times, func) {
return function() {
if (--times < 1) return func.apply(this, arguments);
};
}, // Object Functions
// ----------------
// Retrieve the names of an object's properties.
// Delegates to **ECMAScript 5**'s native `Object.keys`
_.keys = nativeKeys || function(obj) {
if (obj !== Object(obj)) throw TypeError("Invalid object");
var keys = [];
for(var key in obj)_.has(obj, key) && keys.push(key);
return keys;
}, // Retrieve the values of an object's properties.
_.values = function(obj) {
for(var keys = _.keys(obj), length = keys.length, values = Array(length), i = 0; i < length; i++)values[i] = obj[keys[i]];
return values;
}, // Convert an object into a list of `[key, value]` pairs.
_.pairs = function(obj) {
for(var keys = _.keys(obj), length = keys.length, pairs = Array(length), i = 0; i < length; i++)pairs[i] = [
keys[i],
obj[keys[i]]
];
return pairs;
}, // Invert the keys and values of an object. The values must be serializable.
_.invert = function(obj) {
for(var result = {}, keys = _.keys(obj), i = 0, length = keys.length; i < length; i++)result[obj[keys[i]]] = keys[i];
return result;
}, // Return a sorted list of the function names available on the object.
// Aliased as `methods`
_.functions = _.methods = function(obj) {
var names = [];
for(var key in obj)_.isFunction(obj[key]) && names.push(key);
return names.sort();
}, // Extend a given object with all the properties in passed-in object(s).
_.extend = function(obj) {
return each(slice.call(arguments, 1), function(source) {
if (source) for(var prop in source)obj[prop] = source[prop];
}), obj;
}, // Return a copy of the object only containing the whitelisted properties.
_.pick = function(obj) {
var copy = {}, keys = concat.apply(ArrayProto, slice.call(arguments, 1));
return each(keys, function(key) {
key in obj && (copy[key] = obj[key]);
}), copy;
}, // Return a copy of the object without the blacklisted properties.
_.omit = function(obj) {
var copy = {}, keys = concat.apply(ArrayProto, slice.call(arguments, 1));
for(var key in obj)_.contains(keys, key) || (copy[key] = obj[key]);
return copy;
}, // Fill in a given object with default properties.
_.defaults = function(obj) {
return each(slice.call(arguments, 1), function(source) {
if (source) for(var prop in source)void 0 === obj[prop] && (obj[prop] = source[prop]);
}), obj;
}, // Create a (shallow-cloned) duplicate of an object.
_.clone = function(obj) {
return _.isObject(obj) ? _.isArray(obj) ? obj.slice() : _.extend({}, obj) : obj;
}, // Invokes interceptor with the obj, and then returns obj.
// The primary purpose of this method is to "tap into" a method chain, in
// order to perform operations on intermediate results within the chain.
_.tap = function(obj, interceptor) {
return interceptor(obj), obj;
};
// Internal recursive comparison function for `isEqual`.
var eq = function(a, b, aStack, bStack) {
// Identical objects are equal. `0 === -0`, but they aren't identical.
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
if (a === b) return 0 !== a || 1 / a == 1 / b;
// A strict comparison is necessary because `null == undefined`.
if (null == a || null == b) return a === b;
a instanceof _ && (a = a._wrapped), b instanceof _ && (b = b._wrapped);
// Compare `[[Class]]` names.
var className = toString.call(a);
if (className != toString.call(b)) return !1;
switch(className){
// Strings, numbers, dates, and booleans are compared by value.
case "[object String]":
// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
// equivalent to `new String("5")`.
return a == String(b);
case "[object Number]":
// `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
// other numeric values.
return a != +a ? b != +b : 0 == a ? 1 / a == 1 / b : a == +b;
case "[object Date]":
case "[object Boolean]":
// Coerce dates and booleans to numeric primitive values. Dates are compared by their
// millisecond representations. Note that invalid dates with millisecond representations
// of `NaN` are not equivalent.
return +a == +b;
// RegExps are compared by their source patterns and flags.
case "[object RegExp]":
return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;
}
if ("object" != typeof a || "object" != typeof b) return !1;
for(// Assume equality for cyclic structures. The algorithm for detecting cyclic
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
var length = aStack.length; length--;)// Linear search. Performance is inversely proportional to the number of
// unique nested structures.
if (aStack[length] == a) return bStack[length] == b;
// Objects with different constructors are not equivalent, but `Object`s
// from different frames are.
var aCtor = a.constructor, bCtor = b.constructor;
if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && _.isFunction(bCtor) && bCtor instanceof bCtor)) return !1;
// Add the first object to the stack of traversed objects.
aStack.push(a), bStack.push(b);
var size = 0, result = !0;
// Recursively compare objects and arrays.
if ("[object Array]" == className) {
if (result = // Compare array lengths to determine if a deep comparison is necessary.
(size = a.length) == b.length) // Deep compare the contents, ignoring non-numeric properties.
for(; size-- && (result = eq(a[size], b[size], aStack, bStack)););
} else {
// Deep compare objects.
for(var key in a)if (_.has(a, key) && (// Count the expected number of properties.
size++, !(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack)))) break;
// Ensure that both objects contain the same number of properties.
if (result) {
for(key in b)if (_.has(b, key) && !size--) break;
result = !size;
}
}
return(// Remove the first object from the stack of traversed objects.
aStack.pop(), bStack.pop(), result);
};
// Perform a deep comparison to check if two objects are equal.
_.isEqual = function(a, b) {
return eq(a, b, [], []);
}, // Is a given array, string, or object empty?
// An "empty" object has no enumerable own-properties.
_.isEmpty = function(obj) {
if (null == obj) return !0;
if (_.isArray(obj) || _.isString(obj)) return 0 === obj.length;
for(var key in obj)if (_.has(obj, key)) return !1;
return !0;
}, // Is a given value a DOM element?
_.isElement = function(obj) {
return !!(obj && 1 === obj.nodeType);
}, // Is a given value an array?
// Delegates to ECMA5's native Array.isArray
_.isArray = nativeIsArray || function(obj) {
return "[object Array]" == toString.call(obj);
}, // Is a given variable an object?
_.isObject = function(obj) {
return obj === Object(obj);
}, // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
each([
"Arguments",
"Function",
"String",
"Number",
"Date",
"RegExp"
], function(name) {
_["is" + name] = function(obj) {
return toString.call(obj) == "[object " + name + "]";
};
}), _.isArguments(arguments) || (_.isArguments = function(obj) {
return !!(obj && _.has(obj, "callee"));
}), "function" != typeof /./ && (_.isFunction = function(obj) {
return "function" == typeof obj;
}), // Is a given object a finite number?
_.isFinite = function(obj) {
return isFinite(obj) && !isNaN(parseFloat(obj));
}, // Is the given value `NaN`? (NaN is the only number which does not equal itself).
_.isNaN = function(obj) {
return _.isNumber(obj) && obj != +obj;
}, // Is a given value a boolean?
_.isBoolean = function(obj) {
return !0 === obj || !1 === obj || "[object Boolean]" == toString.call(obj);
}, // Is a given value equal to null?
_.isNull = function(obj) {
return null === obj;
}, // Is a given variable undefined?
_.isUndefined = function(obj) {
return void 0 === obj;
}, // Shortcut function for checking if an object has a given property directly
// on itself (in other words, not on a prototype).
_.has = function(obj, key) {
return hasOwnProperty.call(obj, key);
}, // Utility Functions
// -----------------
// Run Underscore.js in *noConflict* mode, returning the `_` variable to its
// previous owner. Returns a reference to the Underscore object.
_.noConflict = function() {
return root._ = previousUnderscore, this;
}, // Keep the identity function around for default iterators.
_.identity = function(value) {
return value;
}, // Run a function **n** times.
_.times = function(n, iterator, context) {
for(var accum = Array(Math.max(0, n)), i = 0; i < n; i++)accum[i] = iterator.call(context, i);
return accum;
}, // Return a random integer between min and max (inclusive).
_.random = function(min, max) {
return null == max && (max = min, min = 0), min + Math.floor(Math.random() * (max - min + 1));
};
// List of HTML entities for escaping.
var entityMap = {
escape: {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'"
}
};
entityMap.unescape = _.invert(entityMap.escape);
// Regexes containing the keys and values listed immediately above.
var entityRegexes = {
escape: RegExp("[" + _.keys(entityMap.escape).join("") + "]", "g"),
unescape: RegExp("(" + _.keys(entityMap.unescape).join("|") + ")", "g")
};
// Functions for escaping and unescaping strings to/from HTML interpolation.
_.each([
"escape",
"unescape"
], function(method) {
_[method] = function(string) {
return null == string ? "" : ("" + string).replace(entityRegexes[method], function(match) {
return entityMap[method][match];
});
};
}), // If the value of the named `property` is a function then invoke it with the
// `object` as context; otherwise, return it.
_.result = function(object, property) {
if (null != object) {
var value = object[property];
return _.isFunction(value) ? value.call(object) : value;
}
}, // Add your own custom functions to the Underscore object.
_.mixin = function(obj) {
each(_.functions(obj), function(name) {
var func = _[name] = obj[name];
_.prototype[name] = function() {
var args = [
this._wrapped
];
return push.apply(args, arguments), result.call(this, func.apply(_, args));
};
});
};
// Generate a unique integer id (unique within the entire client session).
// Useful for temporary DOM ids.
var idCounter = 0;
_.uniqueId = function(prefix) {
var id = ++idCounter + "";
return prefix ? prefix + id : id;
}, // By default, Underscore uses ERB-style template delimiters, change the
// following template settings to use alternative delimiters.
_.templateSettings = {
evaluate: /<%([\s\S]+?)%>/g,
interpolate: /<%=([\s\S]+?)%>/g,
escape: /<%-([\s\S]+?)%>/g
};
// When customizing `templateSettings`, if you don't want to define an
// interpolation, evaluation or escaping regex, we need one that is
// guaranteed not to match.
var noMatch = /(.)^/, escapes = {
"'": "'",
"\\": "\\",
"\r": "r",
"\n": "n",
"\t": "t",
"\u2028": "u2028",
"\u2029": "u2029"
}, escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
// JavaScript micro-templating, similar to John Resig's implementation.
// Underscore templating handles arbitrary delimiters, preserves whitespace,
// and correctly escapes quotes within interpolated code.
_.template = function(text, data, settings) {
// Combine delimiters into one regular expression via alternation.
var render, matcher = RegExp([
((settings = _.defaults({}, settings, _.templateSettings)).escape || noMatch).source,
(settings.interpolate || noMatch).source,
(settings.evaluate || noMatch).source
].join("|") + "|$", "g"), index = 0, source = "__p+='";
text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
return source += text.slice(index, offset).replace(escaper, function(match) {
return "\\" + escapes[match];
}), escape && (source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"), interpolate && (source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"), evaluate && (source += "';\n" + evaluate + "\n__p+='"), index = offset + match.length, match;
}), source += "';\n", settings.variable || (source = "with(obj||{}){\n" + source + "}\n"), source = "var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n" + source + "return __p;\n";
try {
render = Function(settings.variable || "obj", "_", source);
} catch (e) {
throw e.source = source, e;
}
if (data) return render(data, _);
var template = function(data) {
return render.call(this, data, _);
};
return(// Provide the compiled function source as a convenience for precompilation.
template.source = "function(" + (settings.variable || "obj") + "){\n" + source + "}", template);
}, // Add a "chain" function, which will delegate to the wrapper.
_.chain = function(obj) {
return _(obj).chain();
};
// OOP
// ---------------
// If Underscore is called as a function, it returns a wrapped object that
// can be used OO-style. This wrapper holds altered versions of all the
// underscore functions. Wrapped objects may be chained.
// Helper function to continue chaining intermediate results.
var result = function(obj) {
return this._chain ? _(obj).chain() : obj;
};
// Add all of the Underscore functions to the wrapper object.
_.mixin(_), // Add all mutator Array functions to the wrapper.
each([
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift"
], function(name) {
var method = ArrayProto[name];
_.prototype[name] = function() {
var obj = this._wrapped;
return method.apply(obj, arguments), ("shift" == name || "splice" == name) && 0 === obj.length && delete obj[0], result.call(this, obj);
};
}), // Add all accessor Array functions to the wrapper.
each([
"concat",
"join",
"slice"
], function(name) {
var method = ArrayProto[name];
_.prototype[name] = function() {
return result.call(this, method.apply(this._wrapped, arguments));
};
}), _.extend(_.prototype, {
// Start chaining a wrapped Underscore object.
chain: function() {
return this._chain = !0, this;
},
// Extracts the result from a wrapped and chained object.
value: function() {
return this._wrapped;
}
});
}).call(this);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/projects/output/yui-3.12.0.js | JavaScript | /*
YUI 3.12.0 (build 8655935)
Copyright 2013 Yahoo! Inc. All rights reserved.
Licensed under the BSD License.
http://yuilibrary.com/license/
*/ /**
The YUI module contains the components required for building the YUI seed file.
This includes the script loading mechanism, a simple queue, and the core
utilities for the library.
@module yui
@main yui
@submodule yui-base
**/ /*jshint eqeqeq: false*/ void 0 !== YUI && (YUI._YUI = YUI);
/**
The YUI global namespace object. This is the constructor for all YUI instances.
This is a self-instantiable factory function, meaning you don't need to precede
it with the `new` operator. You can invoke it directly like this:
YUI().use('*', function (Y) {
// Y is a new YUI instance.
});
But it also works like this:
var Y = YUI();
The `YUI` constructor accepts an optional config object, like this:
YUI({
debug: true,
combine: false
}).use('node', function (Y) {
// Y.Node is ready to use.
});
See the API docs for the <a href="config.html">Config</a> class for the complete
list of supported configuration properties accepted by the YUI constuctor.
If a global `YUI` object is already defined, the existing YUI object will not be
overwritten, to ensure that defined namespaces are preserved.
Each YUI instance has full custom event support, but only if the event system is
available.
@class YUI
@uses EventTarget
@constructor
@global
@param {Object} [config]* Zero or more optional configuration objects. Config
values are stored in the `Y.config` property. See the
<a href="config.html">Config</a> docs for the list of supported properties.
**/ /*global YUI*/ /*global YUI_config*/ var YUI = function() {
var i = 0, Y = this, args = arguments, l = args.length, instanceOf = function(o, type) {
return o && o.hasOwnProperty && o instanceof type;
}, gconf = "undefined" != typeof YUI_config && YUI_config;
if (instanceOf(Y, YUI) ? (// set up the core environment
Y._init(), YUI.GlobalConfig && Y.applyConfig(YUI.GlobalConfig), gconf && Y.applyConfig(gconf), l || Y._setup()) : Y = new YUI(), l) {
// Each instance can accept one or more configuration objects.
// These are applied after YUI.GlobalConfig and YUI_Config,
// overriding values set in those config files if there is a
// matching property.
for(; i < l; i++)Y.applyConfig(args[i]);
Y._setup();
}
return Y.instanceOf = instanceOf, Y;
};
!function() {
var proto, prop, VERSION = "3.12.0", BASE = "http://yui.yahooapis.com/", /*
These CSS class names can't be generated by
getClassName since it is not available at the
time they are being used.
*/ DOC_LABEL = "yui3-js-enabled", CSS_STAMP_EL = "yui3-css-stamp", NOOP = function() {}, SLICE = Array.prototype.slice, APPLY_TO_AUTH = {
"io.xdrReady": 1,
"io.xdrResponse": 1,
"SWF.eventHandler": 1
}, hasWin = "undefined" != typeof window, win = hasWin ? window : null, doc = hasWin ? win.document : null, docEl = doc && doc.documentElement, docClass = docEl && docEl.className, instances = {}, time = new Date().getTime(), add = function(el, type, fn, capture) {
el && el.addEventListener ? el.addEventListener(type, fn, capture) : el && el.attachEvent && el.attachEvent("on" + type, fn);
}, remove = function(el, type, fn, capture) {
if (el && el.removeEventListener) // this can throw an uncaught exception in FF
try {
el.removeEventListener(type, fn, capture);
} catch (ex) {}
else el && el.detachEvent && el.detachEvent("on" + type, fn);
}, handleLoad = function() {
YUI.Env.windowLoaded = !0, YUI.Env.DOMReady = !0, hasWin && remove(window, "load", handleLoad);
}, getLoader = function(Y, o) {
var loader = Y.Env._loader, lCore = [
"loader-base"
], mods = YUI.Env.mods;
return loader ? (//loader._config(Y.config);
loader.ignoreRegistered = !1, loader.onEnd = null, loader.data = null, loader.required = [], loader.loadType = null) : (loader = new Y.Loader(Y.config), Y.Env._loader = loader), mods && mods.loader && (lCore = [].concat(lCore, YUI.Env.loaderExtras)), YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, lCore)), loader;
}, clobber = function(r, s) {
for(var i in s)s.hasOwnProperty(i) && (r[i] = s[i]);
}, ALREADY_DONE = {
success: !0
};
// inheritance utilities are not available yet
for(prop in docEl && -1 == docClass.indexOf(DOC_LABEL) && (docClass && (docClass += " "), docEl.className = docClass += DOC_LABEL), VERSION.indexOf("@") > -1 && (VERSION = "3.5.0"), proto = {
/**
Applies a new configuration object to the config of this YUI instance. This
will merge new group/module definitions, and will also update the loader
cache if necessary. Updating `Y.config` directly will not update the cache.
@method applyConfig
@param {Object} o the configuration object.
@since 3.2.0
**/ applyConfig: function(o) {
o = o || NOOP;
var attr, name, // detail,
config = this.config, mods = config.modules, groups = config.groups, aliases = config.aliases, loader = this.Env._loader;
for(name in o)o.hasOwnProperty(name) && (attr = o[name], mods && "modules" == name ? clobber(mods, attr) : aliases && "aliases" == name ? clobber(aliases, attr) : groups && "groups" == name ? clobber(groups, attr) : "win" == name ? (config[name] = attr && attr.contentWindow || attr, config.doc = config[name] ? config[name].document : null) : "_yuid" == name || (config[name] = attr));
loader && loader._config(o);
},
/**
Old way to apply a config to this instance (calls `applyConfig` under the
hood).
@private
@method _config
@param {Object} o The config to apply
**/ _config: function(o) {
this.applyConfig(o);
},
/**
Initializes this YUI instance.
@private
@method _init
**/ _init: function() {
var filter, el, prop, Y = this, G_ENV = YUI.Env, Env = Y.Env;
if (/**
The version number of this YUI instance.
This value is typically updated by a script when a YUI release is built,
so it may not reflect the correct version number when YUI is run from
the development source tree.
@property {String} version
**/ Y.version = VERSION, !Env) {
if (Y.Env = {
core: [
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3"
],
loaderExtras: [
"loader-rollup",
"loader-yui3"
],
mods: {},
versions: {},
base: BASE,
cdn: BASE + VERSION + "/build/",
// bootstrapped: false,
_idx: 0,
_used: {},
_attached: {},
_missed: [],
_yidx: 0,
_uidx: 0,
_guidp: "y",
_loaded: {},
// serviced: {},
// Regex in English:
// I'll start at the \b(simpleyui).
// 1. Look in the test string for "simpleyui" or "yui" or
// "yui-base" or "yui-davglass" or "yui-foobar" that comes after a word break. That is, it
// can't match "foyui" or "i_heart_simpleyui". This can be anywhere in the string.
// 2. After #1 must come a forward slash followed by the string matched in #1, so
// "yui-base/yui-base" or "simpleyui/simpleyui" or "yui-pants/yui-pants".
// 3. The second occurence of the #1 token can optionally be followed by "-debug" or "-min",
// so "yui/yui-min", "yui/yui-debug", "yui-base/yui-base-debug". NOT "yui/yui-tshirt".
// 4. This is followed by ".js", so "yui/yui.js", "simpleyui/simpleyui-min.js"
// 0. Going back to the beginning, now. If all that stuff in 1-4 comes after a "?" in the string,
// then capture the junk between the LAST "&" and the string in 1-4. So
// "blah?foo/yui/yui.js" will capture "foo/" and "blah?some/thing.js&3.3.0/build/yui-davglass/yui-davglass.js"
// will capture "3.3.0/build/"
//
// Regex Exploded:
// (?:\? Find a ?
// (?:[^&]*&) followed by 0..n characters followed by an &
// * in fact, find as many sets of characters followed by a & as you can
// ([^&]*) capture the stuff after the last & in \1
// )? but it's ok if all this ?junk&more_junk stuff isn't even there
// \b(simpleyui| after a word break find either the string "simpleyui" or
// yui(?:-\w+)? the string "yui" optionally followed by a -, then more characters
// ) and store the simpleyui or yui-* string in \2
// \/\2 then comes a / followed by the simpleyui or yui-* string in \2
// (?:-(min|debug))? optionally followed by "-min" or "-debug"
// .js and ending in ".js"
_BASE_RE: /(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,
parseBasePath: function(src, pattern) {
var path, filter, match = src.match(pattern);
return match && (path = RegExp.leftContext || src.slice(0, src.indexOf(match[0])), // this is to set up the path to the loader. The file
// filter for loader should match the yui include.
filter = match[3], match[1] && (path += "?" + match[1]), path = {
filter: filter,
path: path
}), path;
},
getBase: G_ENV && G_ENV.getBase || function(pattern) {
var parsed, i, len, src, nodes = doc && doc.getElementsByTagName("script") || [], path = Env.cdn;
for(i = 0, len = nodes.length; i < len; ++i)if ((src = nodes[i].src) && (parsed = Y.Env.parseBasePath(src, pattern))) {
filter = parsed.filter, path = parsed.path;
break;
}
// use CDN default
return path;
}
}, (Env = Y.Env)._loaded[VERSION] = {}, G_ENV && Y !== YUI) Env._yidx = ++G_ENV._yidx, Env._guidp = ("yui_" + VERSION + "_" + Env._yidx + "_" + time).replace(/[^a-z0-9_]+/g, "_");
else if (YUI._YUI) {
for(prop in G_ENV = YUI._YUI.Env, Env._yidx += G_ENV._yidx, Env._uidx += G_ENV._uidx, G_ENV)prop in Env || (Env[prop] = G_ENV[prop]);
delete YUI._YUI;
}
Y.id = Y.stamp(Y), instances[Y.id] = Y;
}
Y.constructor = YUI, // configuration defaults
Y.config = Y.config || {
bootstrap: !0,
cacheUse: !0,
debug: !0,
doc: doc,
fetchCSS: !0,
throwFail: !0,
useBrowserConsole: !0,
useNativeES5: !0,
win: win,
global: Function("return this")()
}, doc && !doc.getElementById(CSS_STAMP_EL) ? ((el = doc.createElement("div")).innerHTML = '<div id="' + CSS_STAMP_EL + '" style="position: absolute !important; visibility: hidden !important"></div>', YUI.Env.cssStampEl = el.firstChild, doc.body ? doc.body.appendChild(YUI.Env.cssStampEl) : docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild)) : doc && doc.getElementById(CSS_STAMP_EL) && !YUI.Env.cssStampEl && (YUI.Env.cssStampEl = doc.getElementById(CSS_STAMP_EL)), Y.config.lang = Y.config.lang || "en-US", Y.config.base = YUI.config.base || Y.Env.getBase(Y.Env._BASE_RE), filter && "mindebug".indexOf(filter) || (filter = "min"), filter = filter ? "-" + filter : filter, Y.config.loaderPath = YUI.config.loaderPath || "loader/loader" + filter + ".js";
},
/**
Finishes the instance setup. Attaches whatever YUI modules were defined
at the time that this instance was created.
@method _setup
@private
**/ _setup: function() {
var i, core = [], mods = YUI.Env.mods, extras = this.config.core || [].concat(YUI.Env.core); //Clone it..
for(i = 0; i < extras.length; i++)mods[extras[i]] && core.push(extras[i]);
this._attach([
"yui-base"
]), this._attach(core), this.Loader && getLoader(this);
},
/**
Executes the named method on the specified YUI instance if that method is
whitelisted.
@method applyTo
@param {String} id YUI instance id.
@param {String} method Name of the method to execute. For example:
'Object.keys'.
@param {Array} args Arguments to apply to the method.
@return {Mixed} Return value from the applied method, or `null` if the
specified instance was not found or the method was not whitelisted.
**/ applyTo: function(id, method, args) {
if (!(method in APPLY_TO_AUTH)) return this.log(method + ": applyTo not allowed", "warn", "yui"), null;
var nest, m, i, instance = instances[id];
if (instance) {
for(i = 0, nest = method.split("."), m = instance; i < nest.length; i += 1)(m = m[nest[i]]) || this.log("applyTo not found: " + method, "warn", "yui");
return m && m.apply(instance, args);
}
return null;
},
/**
Registers a YUI module and makes it available for use in a `YUI().use()` call or
as a dependency for other modules.
The easiest way to create a first-class YUI module is to use
<a href="http://yui.github.com/shifter/">Shifter</a>, the YUI component build
tool.
Shifter will automatically wrap your module code in a `YUI.add()` call along
with any configuration info required for the module.
@example
YUI.add('davglass', function (Y) {
Y.davglass = function () {
};
}, '3.4.0', {
requires: ['harley-davidson', 'mt-dew']
});
@method add
@param {String} name Module name.
@param {Function} fn Function containing module code. This function will be
executed whenever the module is attached to a specific YUI instance.
@param {YUI} fn.Y The YUI instance to which this module is attached.
@param {String} fn.name Name of the module
@param {String} version Module version number. This is currently used only for
informational purposes, and is not used internally by YUI.
@param {Object} [config] Module config.
@param {Array} [config.requires] Array of other module names that must be
attached before this module can be attached.
@param {Array} [config.optional] Array of optional module names that should
be attached before this module is attached if they've already been
loaded. If the `loadOptional` YUI option is `true`, optional modules
that have not yet been loaded will be loaded just as if they were hard
requirements.
@param {Array} [config.use] Array of module names that are included within
or otherwise provided by this module, and which should be attached
automatically when this module is attached. This makes it possible to
create "virtual rollup" modules that simply attach a collection of other
modules or submodules.
@return {YUI} This YUI instance.
**/ add: function(name, fn, version, details) {
details = details || {};
var loader, inst, i, env = YUI.Env, mod = {
name: name,
fn: fn,
version: version,
details: details
}, //Instance hash so we don't apply it to the same instance twice
applied = {}, versions = env.versions;
for(i in env.mods[name] = mod, versions[version] = versions[version] || {}, versions[version][name] = mod, instances)instances.hasOwnProperty(i) && !applied[(inst = instances[i]).id] && (applied[inst.id] = !0, (loader = inst.Env._loader) && (!loader.moduleInfo[name] || loader.moduleInfo[name].temp) && loader.addModule(details, name));
return this;
},
/**
Executes the callback function associated with each required module,
attaching the module to this YUI instance.
@method _attach
@param {Array} r The array of modules to attach
@param {Boolean} [moot=false] If `true`, don't throw a warning if the module
is not attached.
@private
**/ _attach: function(r, moot) {
var i, name, mod, details, req, use, after, j, loader, def, mods = YUI.Env.mods, aliases = YUI.Env.aliases, cache = YUI.Env._renderedMods, loader = this.Env._loader, done = this.Env._attached, len = r.length, c = [];
//Check for conditional modules (in a second+ instance) and add their requirements
//TODO I hate this entire method, it needs to be fixed ASAP (3.5.0) ^davglass
for(i = 0; i < len; i++)if (mod = mods[name = r[i]], c.push(name), loader && loader.conditions[name]) for(j in loader.conditions[name])loader.conditions[name].hasOwnProperty(j) && (def = loader.conditions[name][j]) && (def.ua && this.UA[def.ua] || def.test && def.test(this)) && c.push(def.name);
for(i = 0, len = (r = c).length; i < len; i++)if (!done[r[i]]) {
if (mod = mods[name = r[i]], aliases && aliases[name] && !mod) {
this._attach(aliases[name]);
continue;
}
if (mod) {
//Don't like this, but in case a mod was asked for once, then we fetch it
//We need to remove it from the missed list ^davglass
for(j = 0, done[name] = !0; j < this.Env._missed.length; j++)this.Env._missed[j] === name && (this.message("Found: " + name + " (was reported as missing earlier)", "warn", "yui"), this.Env._missed.splice(j, 1));
/*
If it's a temp module, we need to redo it's requirements if it's already loaded
since it may have been loaded by another instance and it's dependencies might
have been redefined inside the fetched file.
*/ if (loader && cache && cache[name] && cache[name].temp) {
for(j in loader.getRequires(cache[name]), req = [], loader.moduleInfo[name].expanded_map)loader.moduleInfo[name].expanded_map.hasOwnProperty(j) && req.push(j);
this._attach(req);
}
if (req = (details = mod.details).requires, use = details.use, after = details.after, details.lang && (req = req || []).unshift("intl"), req) {
for(j = 0; j < req.length; j++)if (!done[req[j]]) {
if (!this._attach(req)) return !1;
break;
}
}
if (after) {
for(j = 0; j < after.length; j++)if (!done[after[j]]) {
if (!this._attach(after, !0)) return !1;
break;
}
}
if (mod.fn) {
if (this.config.throwFail) mod.fn(this, name);
else try {
mod.fn(this, name);
} catch (e) {
return this.error("Attach error: " + name, e, name), !1;
}
}
if (use) {
for(j = 0; j < use.length; j++)if (!done[use[j]]) {
if (!this._attach(use)) return !1;
break;
}
}
} else loader && loader.moduleInfo[name] && (mod = loader.moduleInfo[name], moot = !0), !moot && name && -1 === name.indexOf("skin-") && -1 === name.indexOf("css") && (this.Env._missed.push(name), this.Env._missed = this.Array.dedupe(this.Env._missed), this.message("NOT loaded: " + name, "warn", "yui"));
}
return !0;
},
/**
Delays the `use` callback until another event has taken place such as
`window.onload`, `domready`, `contentready`, or `available`.
@private
@method _delayCallback
@param {Function} cb The original `use` callback.
@param {String|Object} until Either an event name ('load', 'domready', etc.)
or an object containing event/args keys for contentready/available.
@return {Function}
**/ _delayCallback: function(cb, until) {
var Y = this, mod = [
"event-base"
];
return "load" === (until = Y.Lang.isObject(until) ? until : {
event: until
}).event && mod.push("event-synthetic"), function() {
var args = arguments;
Y._use(mod, function() {
Y.on(until.event, function() {
args[1].delayUntil = until.event, cb.apply(Y, args);
}, until.args);
});
};
},
/**
Attaches one or more modules to this YUI instance. When this is executed,
the requirements of the desired modules are analyzed, and one of several
things can happen:
* All required modules have already been loaded, and just need to be
attached to this YUI instance. In this case, the `use()` callback will
be executed synchronously after the modules are attached.
* One or more modules have not yet been loaded, or the Get utility is not
available, or the `bootstrap` config option is `false`. In this case,
a warning is issued indicating that modules are missing, but all
available modules will still be attached and the `use()` callback will
be executed synchronously.
* One or more modules are missing and the Loader is not available but the
Get utility is, and `bootstrap` is not `false`. In this case, the Get
utility will be used to load the Loader, and we will then proceed to
the following state:
* One or more modules are missing and the Loader is available. In this
case, the Loader will be used to resolve the dependency tree for the
missing modules and load them and their dependencies. When the Loader is
finished loading modules, the `use()` callback will be executed
asynchronously.
@example
// Loads and attaches dd and its dependencies.
YUI().use('dd', function (Y) {
// ...
});
// Loads and attaches dd and node as well as all of their dependencies.
YUI().use(['dd', 'node'], function (Y) {
// ...
});
// Attaches all modules that have already been loaded.
YUI().use('*', function (Y) {
// ...
});
// Attaches a gallery module.
YUI().use('gallery-yql', function (Y) {
// ...
});
// Attaches a YUI 2in3 module.
YUI().use('yui2-datatable', function (Y) {
// ...
});
@method use
@param {String|Array} modules* One or more module names to attach.
@param {Function} [callback] Callback function to be executed once all
specified modules and their dependencies have been attached.
@param {YUI} callback.Y The YUI instance created for this sandbox.
@param {Object} callback.status Object containing `success`, `msg` and
`data` properties.
@chainable
**/ use: function() {
var name, args = SLICE.call(arguments, 0), callback = args[args.length - 1], i = 0, Env = this.Env, provisioned = !0;
if (this.Lang.isFunction(callback) ? (args.pop(), this.config.delayUntil && (callback = this._delayCallback(callback, this.config.delayUntil))) : callback = null, this.Lang.isArray(args[0]) && (args = args[0]), this.config.cacheUse) {
for(; name = args[i++];)if (!Env._attached[name]) {
provisioned = !1;
break;
}
if (provisioned) return args.length, this._notify(callback, ALREADY_DONE, args), this;
}
return this._loading ? (this._useQueue = this._useQueue || new this.Queue(), this._useQueue.add([
args,
callback
])) : this._use(args, function(Y, response) {
Y._notify(callback, response, args);
}), this;
},
/**
Handles Loader notifications about attachment/load errors.
@method _notify
@param {Function} callback Callback to pass to `Y.config.loadErrorFn`.
@param {Object} response Response returned from Loader.
@param {Array} args Arguments passed from Loader.
@private
**/ _notify: function(callback, response, args) {
if (!response.success && this.config.loadErrorFn) this.config.loadErrorFn.call(this, this, callback, response, args);
else if (callback) {
if (this.Env._missed && this.Env._missed.length && (response.msg = "Missing modules: " + this.Env._missed.join(), response.success = !1), this.config.throwFail) callback(this, response);
else try {
callback(this, response);
} catch (e) {
this.error("use callback error", e, args);
}
}
},
/**
Called from the `use` method queue to ensure that only one set of loading
logic is performed at a time.
@method _use
@param {String} args* One or more modules to attach.
@param {Function} [callback] Function to call once all required modules have
been attached.
@private
**/ _use: function(args, callback) {
this.Array || this._attach([
"yui-base"
]);
var len, loader, handleBoot, i, Y = this, G_ENV = YUI.Env, mods = G_ENV.mods, Env = Y.Env, used = Env._used, aliases = G_ENV.aliases, queue = G_ENV._loaderQueue, firstArg = args[0], YArray = Y.Array, config = Y.config, boot = config.bootstrap, missing = [], r = [], ret = !0, fetchCSS = config.fetchCSS, process1 = function(names, skip) {
var name, len, m, req, use, i = 0, a = [];
if (names.length) {
if (aliases) {
for(i = 0, len = names.length; i < len; i++)aliases[names[i]] && !mods[names[i]] ? a = [].concat(a, aliases[names[i]]) : a.push(names[i]);
names = a;
}
for(i = 0, len = names.length; i < len; i++)// only attach a module once
name = names[i], skip || r.push(name), !used[name] && (m = mods[name], req = null, use = null, m ? (used[name] = !0, req = m.details.requires, use = m.details.use) : G_ENV._loaded[VERSION][name] ? used[name] = !0 : missing.push(name), req && req.length && process1(req), use && use.length && process1(use, 1));
}
}, handleLoader = function(fromLoader) {
var redo, origMissing, response = fromLoader || {
success: !0,
msg: "not dynamic"
}, ret = !0, data = response.data;
Y._loading = !1, data && (origMissing = missing, missing = [], r = [], process1(data), (redo = missing.length) && [].concat(missing).sort().join() == origMissing.sort().join() && (redo = !1)), redo && data ? (Y._loading = !0, Y._use(missing, function() {
Y._attach(data) && Y._notify(callback, response, data);
})) : (data && (ret = Y._attach(data)), ret && Y._notify(callback, response, args)), Y._useQueue && Y._useQueue.size() && !Y._loading && Y._use.apply(Y, Y._useQueue.next());
};
// YUI().use('*'); // bind everything available
if ("*" === firstArg) {
for(i in args = [], mods)mods.hasOwnProperty(i) && args.push(i);
return Y._attach(args) && handleLoader(), Y;
}
return (mods.loader || mods["loader-base"]) && !Y.Loader && Y._attach([
"loader" + (mods.loader ? "" : "-base")
]), boot && Y.Loader && args.length && ((loader = getLoader(Y)).require(args), loader.ignoreRegistered = !0, loader._boot = !0, loader.calculate(null, fetchCSS ? null : "js"), args = loader.sorted, loader._boot = !1), process1(args), (len = missing.length) && (len = (missing = YArray.dedupe(missing)).length), boot && len && Y.Loader ? (Y._loading = !0, (loader = getLoader(Y)).onEnd = handleLoader, loader.context = Y, loader.data = args, loader.ignoreRegistered = !1, loader.require(missing), loader.insert(null, fetchCSS ? null : "js")) : boot && len && Y.Get && !Env.bootstrapped ? (Y._loading = !0, handleBoot = function() {
Y._loading = !1, queue.running = !1, Env.bootstrapped = !0, G_ENV._bootstrapping = !1, Y._attach([
"loader"
]) && Y._use(args, callback);
}, G_ENV._bootstrapping ? queue.add(handleBoot) : (G_ENV._bootstrapping = !0, Y.Get.script(config.base + config.loaderPath, {
onEnd: handleBoot
}))) : Y._attach(args) && handleLoader(), Y;
},
/**
Utility method for safely creating namespaces if they don't already exist.
May be called statically on the YUI global object or as a method on a YUI
instance.
When called statically, a namespace will be created on the YUI global
object:
// Create `YUI.your.namespace.here` as nested objects, preserving any
// objects that already exist instead of overwriting them.
YUI.namespace('your.namespace.here');
When called as a method on a YUI instance, a namespace will be created on
that instance:
// Creates `Y.property.package`.
Y.namespace('property.package');
Dots in the input string cause `namespace` to create nested objects for each
token. If any part of the requested namespace already exists, the current
object will be left in place and will not be overwritten. This allows
multiple calls to `namespace` to preserve existing namespaced properties.
If the first token in the namespace string is "YAHOO", that token is
discarded. This is legacy behavior for backwards compatibility with YUI 2.
Be careful with namespace tokens. Reserved words may work in some browsers
and not others. For instance, the following will fail in some browsers
because the supported version of JavaScript reserves the word "long":
Y.namespace('really.long.nested.namespace');
Note: If you pass multiple arguments to create multiple namespaces, only the
last one created is returned from this function.
@method namespace
@param {String} namespace* One or more namespaces to create.
@return {Object} Reference to the last namespace object created.
**/ namespace: function() {
for(var o, j, d, arg, a = arguments, i = 0; i < a.length; i++)if (o = this, (arg = a[i]).indexOf(".") > -1) for(j = +("YAHOO" == //Skip this if no "." is present
(d = arg.split("."))[0]); j < d.length; j++)o[d[j]] = o[d[j]] || {}, o = o[d[j]];
else o[arg] = o[arg] || {}, o = o[arg];
return o;
},
// this is replaced if the log module is included
log: NOOP,
message: NOOP,
// this is replaced if the dump module is included
dump: function(o) {
return "" + o;
},
/**
Reports an error.
The reporting mechanism is controlled by the `throwFail` configuration
attribute. If `throwFail` is falsy, the message is logged. If `throwFail` is
truthy, a JS exception is thrown.
If an `errorFn` is specified in the config it must return `true` to indicate
that the exception was handled and keep it from being thrown.
@method error
@param {String} msg Error message.
@param {Error|String} [e] JavaScript error object or an error string.
@param {String} [src] Source of the error (such as the name of the module in
which the error occurred).
@chainable
**/ error: function(msg, e, src) {
//TODO Add check for window.onerror here
var ret;
if (this.config.errorFn && (ret = this.config.errorFn.apply(this, arguments)), ret) this.message(msg, "error", "" + src); // don't scrub this one
else throw e || Error(msg);
return this;
},
/**
Generates an id string that is unique among all YUI instances in this
execution context.
@method guid
@param {String} [pre] Prefix.
@return {String} Unique id.
**/ guid: function(pre) {
var id = this.Env._guidp + "_" + ++this.Env._uidx;
return pre ? pre + id : id;
},
/**
Returns a unique id associated with the given object and (if *readOnly* is
falsy) stamps the object with that id so it can be identified in the future.
Stamping an object involves adding a `_yuid` property to it that contains
the object's id. One exception to this is that in Internet Explorer, DOM
nodes have a `uniqueID` property that contains a browser-generated unique
id, which will be used instead of a YUI-generated id when available.
@method stamp
@param {Object} o Object to stamp.
@param {Boolean} readOnly If truthy and the given object has not already
been stamped, the object will not be modified and `null` will be
returned.
@return {String} Object's unique id, or `null` if *readOnly* was truthy and
the given object was not already stamped.
**/ stamp: function(o, readOnly) {
var uid;
if (!o) return o;
if (!(uid = o.uniqueID && o.nodeType && 9 !== o.nodeType ? o.uniqueID : "string" == typeof o ? o : o._yuid) && (uid = this.guid(), !readOnly)) try {
o._yuid = uid;
} catch (e) {
uid = null;
}
return uid;
},
/**
Destroys this YUI instance.
@method destroy
@since 3.3.0
**/ destroy: function() {
this.Event && this.Event._unload(), delete instances[this.id], delete this.Env, delete this.config;
}
}, YUI.prototype = proto, proto)proto.hasOwnProperty(prop) && (YUI[prop] = proto[prop]);
/**
Applies a configuration to all YUI instances in this execution context.
The main use case for this method is in "mashups" where several third-party
scripts need to write to a global YUI config, but cannot share a single
centrally-managed config object. This way they can all call
`YUI.applyConfig({})` instead of overwriting the single global config.
@example
YUI.applyConfig({
modules: {
davglass: {
fullpath: './davglass.js'
}
}
});
YUI.applyConfig({
modules: {
foo: {
fullpath: './foo.js'
}
}
});
YUI().use('davglass', function (Y) {
// Module davglass will be available here.
});
@method applyConfig
@param {Object} o Configuration object to apply.
@static
@since 3.5.0
**/ YUI.applyConfig = function(o) {
o && (YUI.GlobalConfig && this.prototype.applyConfig.call(this, YUI.GlobalConfig), //Apply this config to it
this.prototype.applyConfig.call(this, o), //Reset GlobalConfig to the combined config
YUI.GlobalConfig = this.config);
}, // set up the environment
YUI._init(), hasWin ? // add a window load event at load time so we can capture
// the case where it fires before dynamic loading is
// complete.
add(window, "load", handleLoad) : handleLoad(), YUI.Env.add = add, YUI.Env.remove = remove, "object" == typeof exports && (exports.YUI = YUI, /**
* Set a method to be called when `Get.script` is called in Node.js
* `Get` will open the file, then pass it's content and it's path
* to this method before attaching it. Commonly used for code coverage
* instrumentation. <strong>Calling this multiple times will only
* attach the last hook method</strong>. This method is only
* available in Node.js.
* @method setLoadHook
* @static
* @param {Function} fn The function to set
* @param {String} fn.data The content of the file
* @param {String} fn.path The file path of the file
*/ YUI.setLoadHook = function(fn) {
YUI._getLoadHook = fn;
}, /**
* Load hook for `Y.Get.script` in Node.js, see `YUI.setLoadHook`
* @method _getLoadHook
* @private
* @param {String} data The content of the file
* @param {String} path The file path of the file
*/ YUI._getLoadHook = null), YUI.Env[VERSION] = {};
}(), /**
Config object that contains all of the configuration options for
this `YUI` instance.
This object is supplied by the implementer when instantiating YUI. Some
properties have default values if they are not supplied by the implementer.
This object should not be updated directly because some values are cached. Use
`applyConfig()` to update the config object on a YUI instance that has already
been configured.
@class config
@static
**/ /**
If `true` (the default), YUI will "bootstrap" the YUI Loader and module metadata
if they're needed to load additional dependencies and aren't already available.
Setting this to `false` will prevent YUI from automatically loading the Loader
and module metadata, so you will need to manually ensure that they're available
or handle dependency resolution yourself.
@property {Boolean} bootstrap
@default true
**/ /**
@property {Object} aliases
**/ /**
A hash of module group definitions.
For each group you can specify a list of modules and the base path and
combo spec to use when dynamically loading the modules.
@example
groups: {
yui2: {
// specify whether or not this group has a combo service
combine: true,
// The comboSeperator to use with this group's combo handler
comboSep: ';',
// The maxURLLength for this server
maxURLLength: 500,
// the base path for non-combo paths
base: 'http://yui.yahooapis.com/2.8.0r4/build/',
// the path to the combo service
comboBase: 'http://yui.yahooapis.com/combo?',
// a fragment to prepend to the path attribute when
// when building combo urls
root: '2.8.0r4/build/',
// the module definitions
modules: {
yui2_yde: {
path: "yahoo-dom-event/yahoo-dom-event.js"
},
yui2_anim: {
path: "animation/animation.js",
requires: ['yui2_yde']
}
}
}
}
@property {Object} groups
**/ /**
Path to the Loader JS file, relative to the `base` path.
This is used to dynamically bootstrap the Loader when it's needed and isn't yet
available.
@property {String} loaderPath
@default "loader/loader-min.js"
**/ /**
If `true`, YUI will attempt to load CSS dependencies and skins. Set this to
`false` to prevent YUI from loading any CSS, or set it to the string `"force"`
to force CSS dependencies to be loaded even if their associated JS modules are
already loaded.
@property {Boolean|String} fetchCSS
@default true
**/ /**
Default gallery version used to build gallery module urls.
@property {String} gallery
@since 3.1.0
**/ /**
Default YUI 2 version used to build YUI 2 module urls.
This is used for intrinsic YUI 2 support via the 2in3 project. Also see the
`2in3` config for pulling different revisions of the wrapped YUI 2 modules.
@property {String} yui2
@default "2.9.0"
@since 3.1.0
**/ /**
Revision number of YUI 2in3 modules that should be used when loading YUI 2in3.
@property {String} 2in3
@default "4"
@since 3.1.0
**/ /**
Alternate console log function that should be used in environments without a
supported native console. This function is executed with the YUI instance as its
`this` object.
@property {Function} logFn
@since 3.1.0
**/ /**
The minimum log level to log messages for. Log levels are defined
incrementally. Messages greater than or equal to the level specified will
be shown. All others will be discarded. The order of log levels in
increasing priority is:
debug
info
warn
error
@property {String} logLevel
@default 'debug'
@since 3.10.0
**/ /**
Callback to execute when `Y.error()` is called. It receives the error message
and a JavaScript error object if one was provided.
This function is executed with the YUI instance as its `this` object.
Returning `true` from this function will prevent an exception from being thrown.
@property {Function} errorFn
@param {String} errorFn.msg Error message
@param {Object} [errorFn.err] Error object (if one was provided).
@since 3.2.0
**/ /**
A callback to execute when Loader fails to load one or more resources.
This could be because of a script load failure. It could also be because a
module fails to register itself when the `requireRegistration` config is `true`.
If this function is defined, the `use()` callback will only be called when the
loader succeeds. Otherwise, `use()` will always executes unless there was a
JavaScript error when attaching a module.
@property {Function} loadErrorFn
@since 3.3.0
**/ /**
If `true`, Loader will expect all loaded scripts to be first-class YUI modules
that register themselves with the YUI global, and will trigger a failure if a
loaded script does not register a YUI module.
@property {Boolean} requireRegistration
@default false
@since 3.3.0
**/ /**
Cache serviced use() requests.
@property {Boolean} cacheUse
@default true
@since 3.3.0
@deprecated No longer used.
**/ /**
Whether or not YUI should use native ES5 functionality when available for
features like `Y.Array.each()`, `Y.Object()`, etc.
When `false`, YUI will always use its own fallback implementations instead of
relying on ES5 functionality, even when ES5 functionality is available.
@property {Boolean} useNativeES5
@default true
@since 3.5.0
**/ /**
* Leverage native JSON stringify if the browser has a native
* implementation. In general, this is a good idea. See the Known Issues
* section in the JSON user guide for caveats. The default value is true
* for browsers with native JSON support.
*
* @property useNativeJSONStringify
* @type Boolean
* @default true
* @since 3.8.0
*/ /**
* Leverage native JSON parse if the browser has a native implementation.
* In general, this is a good idea. See the Known Issues section in the
* JSON user guide for caveats. The default value is true for browsers with
* native JSON support.
*
* @property useNativeJSONParse
* @type Boolean
* @default true
* @since 3.8.0
*/ /**
Delay the `use` callback until a specific event has passed (`load`, `domready`, `contentready` or `available`)
@property {Object|String} delayUntil
@since 3.6.0
@example
You can use `load` or `domready` strings by default:
YUI({
delayUntil: 'domready'
}, function (Y) {
// This will not execute until 'domeready' occurs.
});
Or you can delay until a node is available (with `available` or `contentready`):
YUI({
delayUntil: {
event: 'available',
args : '#foo'
}
}, function (Y) {
// This will not execute until a node matching the selector "#foo" is
// available in the DOM.
});
**/ YUI.add("yui-base", function(Y, NAME) {
/*
* YUI stub
* @module yui
* @submodule yui-base
*/ /**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/ /**
* Provides core language utilites and extensions used throughout YUI.
*
* @class Lang
* @static
*/ var L = Y.Lang || (Y.Lang = {}), STRING_PROTO = String.prototype, TOSTRING = Object.prototype.toString, TYPES = {
undefined: "undefined",
number: "number",
boolean: "boolean",
string: "string",
"[object Function]": "function",
"[object RegExp]": "regexp",
"[object Array]": "array",
"[object Date]": "date",
"[object Error]": "error"
}, SUBREGEX = /\{\s*([^|}]+?)\s*(?:\|([^}]*))?\s*\}/g, WHITESPACE = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF", WHITESPACE_CLASS = "[\x09-\x0D\x20\xA0\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+", TRIM_LEFT_REGEX = RegExp("^" + WHITESPACE_CLASS), TRIM_RIGHT_REGEX = RegExp(WHITESPACE_CLASS + "$"), TRIMREGEX = RegExp(TRIM_LEFT_REGEX.source + "|" + TRIM_RIGHT_REGEX.source, "g"), NATIVE_FN_REGEX = /\{\s*\[(?:native code|function)\]\s*\}/i;
// -- Protected Methods --------------------------------------------------------
/**
Returns `true` if the given function appears to be implemented in native code,
`false` otherwise. Will always return `false` -- even in ES5-capable browsers --
if the `useNativeES5` YUI config option is set to `false`.
This isn't guaranteed to be 100% accurate and won't work for anything other than
functions, but it can be useful for determining whether a function like
`Array.prototype.forEach` is native or a JS shim provided by another library.
There's a great article by @kangax discussing certain flaws with this technique:
<http://perfectionkills.com/detecting-built-in-host-methods/>
While his points are valid, it's still possible to benefit from this function
as long as it's used carefully and sparingly, and in such a way that false
negatives have minimal consequences. It's used internally to avoid using
potentially broken non-native ES5 shims that have been added to the page by
other libraries.
@method _isNative
@param {Function} fn Function to test.
@return {Boolean} `true` if _fn_ appears to be native, `false` otherwise.
@static
@protected
@since 3.5.0
**/ L._isNative = function(fn) {
return !!(Y.config.useNativeES5 && fn && NATIVE_FN_REGEX.test(fn));
}, // -- Public Methods -----------------------------------------------------------
/**
* Determines whether or not the provided item is an array.
*
* Returns `false` for array-like collections such as the function `arguments`
* collection or `HTMLElement` collections. Use `Y.Array.test()` if you want to
* test for an array-like collection.
*
* @method isArray
* @param o The object to test.
* @return {boolean} true if o is an array.
* @static
*/ L.isArray = L._isNative(Array.isArray) ? Array.isArray : function(o) {
return "array" === L.type(o);
}, /**
* Determines whether or not the provided item is a boolean.
* @method isBoolean
* @static
* @param o The object to test.
* @return {boolean} true if o is a boolean.
*/ L.isBoolean = function(o) {
return "boolean" == typeof o;
}, /**
* Determines whether or not the supplied item is a date instance.
* @method isDate
* @static
* @param o The object to test.
* @return {boolean} true if o is a date.
*/ L.isDate = function(o) {
return "date" === L.type(o) && "Invalid Date" !== o.toString() && !isNaN(o);
}, /**
* <p>
* Determines whether or not the provided item is a function.
* Note: Internet Explorer thinks certain functions are objects:
* </p>
*
* <pre>
* var obj = document.createElement("object");
* Y.Lang.isFunction(obj.getAttribute) // reports false in IE
*
* var input = document.createElement("input"); // append to body
* Y.Lang.isFunction(input.focus) // reports false in IE
* </pre>
*
* <p>
* You will have to implement additional tests if these functions
* matter to you.
* </p>
*
* @method isFunction
* @static
* @param o The object to test.
* @return {boolean} true if o is a function.
*/ L.isFunction = function(o) {
return "function" === L.type(o);
}, /**
* Determines whether or not the provided item is null.
* @method isNull
* @static
* @param o The object to test.
* @return {boolean} true if o is null.
*/ L.isNull = function(o) {
return null === o;
}, /**
* Determines whether or not the provided item is a legal number.
* @method isNumber
* @static
* @param o The object to test.
* @return {boolean} true if o is a number.
*/ L.isNumber = function(o) {
return "number" == typeof o && isFinite(o);
}, /**
* Determines whether or not the provided item is of type object
* or function. Note that arrays are also objects, so
* <code>Y.Lang.isObject([]) === true</code>.
* @method isObject
* @static
* @param o The object to test.
* @param failfn {boolean} fail if the input is a function.
* @return {boolean} true if o is an object.
* @see isPlainObject
*/ L.isObject = function(o, failfn) {
var t = typeof o;
return o && ("object" === t || !failfn && ("function" === t || L.isFunction(o))) || !1;
}, /**
* Determines whether or not the provided item is a string.
* @method isString
* @static
* @param o The object to test.
* @return {boolean} true if o is a string.
*/ L.isString = function(o) {
return "string" == typeof o;
}, /**
* Determines whether or not the provided item is undefined.
* @method isUndefined
* @static
* @param o The object to test.
* @return {boolean} true if o is undefined.
*/ L.isUndefined = function(o) {
return void 0 === o;
}, /**
* A convenience method for detecting a legitimate non-null value.
* Returns false for null/undefined/NaN, true for other values,
* including 0/false/''
* @method isValue
* @static
* @param o The item to test.
* @return {boolean} true if it is not null/undefined/NaN || false.
*/ L.isValue = function(o) {
var t = L.type(o);
switch(t){
case "number":
return isFinite(o);
case "null":
case "undefined":
return !1;
default:
return !!t;
}
}, /**
* Returns the current time in milliseconds.
*
* @method now
* @return {Number} Current time in milliseconds.
* @static
* @since 3.3.0
*/ L.now = Date.now || function() {
return new Date().getTime();
}, /**
* Lightweight version of <code>Y.substitute</code>. Uses the same template
* structure as <code>Y.substitute</code>, but doesn't support recursion,
* auto-object coersion, or formats.
* @method sub
* @param {string} s String to be modified.
* @param {object} o Object containing replacement values.
* @return {string} the substitute result.
* @static
* @since 3.2.0
*/ L.sub = function(s, o) {
return s.replace ? s.replace(SUBREGEX, function(match, key) {
return L.isUndefined(o[key]) ? match : o[key];
}) : s;
}, /**
* Returns a string without any leading or trailing whitespace. If
* the input is not a string, the input will be returned untouched.
* @method trim
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/ L.trim = L._isNative(STRING_PROTO.trim) && !WHITESPACE.trim() ? function(s) {
return s && s.trim ? s.trim() : s;
} : function(s) {
try {
return s.replace(TRIMREGEX, "");
} catch (e) {
return s;
}
}, /**
* Returns a string without any leading whitespace.
* @method trimLeft
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/ L.trimLeft = L._isNative(STRING_PROTO.trimLeft) && !WHITESPACE.trimLeft() ? function(s) {
return s.trimLeft();
} : function(s) {
return s.replace(TRIM_LEFT_REGEX, "");
}, /**
* Returns a string without any trailing whitespace.
* @method trimRight
* @static
* @param s {string} the string to trim.
* @return {string} the trimmed string.
*/ L.trimRight = L._isNative(STRING_PROTO.trimRight) && !WHITESPACE.trimRight() ? function(s) {
return s.trimRight();
} : function(s) {
return s.replace(TRIM_RIGHT_REGEX, "");
}, /**
Returns one of the following strings, representing the type of the item passed
in:
* "array"
* "boolean"
* "date"
* "error"
* "function"
* "null"
* "number"
* "object"
* "regexp"
* "string"
* "undefined"
Known issues:
* `typeof HTMLElementCollection` returns function in Safari, but
`Y.Lang.type()` reports "object", which could be a good thing --
but it actually caused the logic in <code>Y.Lang.isObject</code> to fail.
@method type
@param o the item to test.
@return {string} the detected type.
@static
**/ L.type = function(o) {
return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? "object" : "null");
};
/**
@module yui
@submodule yui-base
*/ var Lang = Y.Lang, Native = Array.prototype, hasOwn = Object.prototype.hasOwnProperty;
/**
Provides utility methods for working with arrays. Additional array helpers can
be found in the `collection` and `array-extras` modules.
`Y.Array(thing)` returns a native array created from _thing_. Depending on
_thing_'s type, one of the following will happen:
* Arrays are returned unmodified unless a non-zero _startIndex_ is
specified.
* Array-like collections (see `Array.test()`) are converted to arrays.
* For everything else, a new array is created with _thing_ as the sole
item.
Note: elements that are also collections, such as `<form>` and `<select>`
elements, are not automatically converted to arrays. To force a conversion,
pass `true` as the value of the _force_ parameter.
@class Array
@constructor
@param {Any} thing The thing to arrayify.
@param {Number} [startIndex=0] If non-zero and _thing_ is an array or array-like
collection, a subset of items starting at the specified index will be
returned.
@param {Boolean} [force=false] If `true`, _thing_ will be treated as an
array-like collection no matter what.
@return {Array} A native array created from _thing_, according to the rules
described above.
**/ function YArray(thing, startIndex, force) {
var len, result;
if (/*jshint expr: true*/ startIndex || (startIndex = 0), force || YArray.test(thing)) // IE throws when trying to slice HTMLElement collections.
try {
return Native.slice.call(thing, startIndex);
} catch (ex) {
for(result = [], len = thing.length; startIndex < len; ++startIndex)result.push(thing[startIndex]);
return result;
}
return [
thing
];
}
/**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/ /**
* A simple FIFO queue. Items are added to the Queue with add(1..n items) and
* removed using next().
*
* @class Queue
* @constructor
* @param {MIXED} item* 0..n items to seed the queue.
*/ function Queue() {
this._init(), this.add.apply(this, arguments);
}
Y.Array = YArray, /**
Dedupes an array of strings, returning an array that's guaranteed to contain
only one copy of a given string.
This method differs from `Array.unique()` in that it's optimized for use only
with arrays consisting entirely of strings or entirely of numbers, whereas
`unique` may be used with other value types (but is slower).
Using `dedupe()` with values other than strings or numbers, or with arrays
containing a mix of strings and numbers, may result in unexpected behavior.
@method dedupe
@param {String[]|Number[]} array Array of strings or numbers to dedupe.
@return {Array} Copy of _array_ containing no duplicate values.
@static
@since 3.4.0
**/ YArray.dedupe = Lang._isNative(Object.create) ? function(array) {
var i, item, len, hash = Object.create(null), results = [];
for(i = 0, len = array.length; i < len; ++i)hash[item = array[i]] || (hash[item] = 1, results.push(item));
return results;
} : function(array) {
var i, item, len, hash = {}, results = [];
for(i = 0, len = array.length; i < len; ++i)item = array[i], hasOwn.call(hash, item) || (hash[item] = 1, results.push(item));
return results;
}, /**
Executes the supplied function on each item in the array. This method wraps
the native ES5 `Array.forEach()` method if available.
@method each
@param {Array} array Array to iterate.
@param {Function} fn Function to execute on each item in the array. The function
will receive the following arguments:
@param {Any} fn.item Current array item.
@param {Number} fn.index Current array index.
@param {Array} fn.array Array being iterated.
@param {Object} [thisObj] `this` object to use when calling _fn_.
@return {YUI} The YUI instance.
@static
**/ YArray.each = YArray.forEach = Lang._isNative(Native.forEach) ? function(array, fn, thisObj) {
return Native.forEach.call(array || [], fn, thisObj || Y), Y;
} : function(array, fn, thisObj) {
for(var i = 0, len = array && array.length || 0; i < len; ++i)i in array && fn.call(thisObj || Y, array[i], i, array);
return Y;
}, /**
Alias for `each()`.
@method forEach
@static
**/ /**
Returns an object using the first array as keys and the second as values. If
the second array is not provided, or if it doesn't contain the same number of
values as the first array, then `true` will be used in place of the missing
values.
@example
Y.Array.hash(['a', 'b', 'c'], ['foo', 'bar']);
// => {a: 'foo', b: 'bar', c: true}
@method hash
@param {String[]} keys Array of strings to use as keys.
@param {Array} [values] Array to use as values.
@return {Object} Hash using the first array as keys and the second as values.
@static
**/ YArray.hash = function(keys, values) {
var i, len, hash = {}, vlen = values && values.length || 0;
for(i = 0, len = keys.length; i < len; ++i)i in keys && (hash[keys[i]] = !(vlen > i) || !(i in values) || values[i]);
return hash;
}, /**
Returns the index of the first item in the array that's equal (using a strict
equality check) to the specified _value_, or `-1` if the value isn't found.
This method wraps the native ES5 `Array.indexOf()` method if available.
@method indexOf
@param {Array} array Array to search.
@param {Any} value Value to search for.
@param {Number} [from=0] The index at which to begin the search.
@return {Number} Index of the item strictly equal to _value_, or `-1` if not
found.
@static
**/ YArray.indexOf = Lang._isNative(Native.indexOf) ? function(array, value, from) {
return Native.indexOf.call(array, value, from);
} : function(array, value, from) {
// http://es5.github.com/#x15.4.4.14
var len = array.length;
for((from = ((from = +from || 0) > 0 || -1) * Math.floor(Math.abs(from))) < 0 && (from += len) < 0 && (from = 0); from < len; ++from)if (from in array && array[from] === value) return from;
return -1;
}, /**
Numeric sort convenience function.
The native `Array.prototype.sort()` function converts values to strings and
sorts them in lexicographic order, which is unsuitable for sorting numeric
values. Provide `Array.numericSort` as a custom sort function when you want
to sort values in numeric order.
@example
[42, 23, 8, 16, 4, 15].sort(Y.Array.numericSort);
// => [4, 8, 15, 16, 23, 42]
@method numericSort
@param {Number} a First value to compare.
@param {Number} b Second value to compare.
@return {Number} Difference between _a_ and _b_.
@static
**/ YArray.numericSort = function(a, b) {
return a - b;
}, /**
Executes the supplied function on each item in the array. Returning a truthy
value from the function will stop the processing of remaining items.
@method some
@param {Array} array Array to iterate over.
@param {Function} fn Function to execute on each item. The function will receive
the following arguments:
@param {Any} fn.value Current array item.
@param {Number} fn.index Current array index.
@param {Array} fn.array Array being iterated over.
@param {Object} [thisObj] `this` object to use when calling _fn_.
@return {Boolean} `true` if the function returns a truthy value on any of the
items in the array; `false` otherwise.
@static
**/ YArray.some = Lang._isNative(Native.some) ? function(array, fn, thisObj) {
return Native.some.call(array, fn, thisObj);
} : function(array, fn, thisObj) {
for(var i = 0, len = array.length; i < len; ++i)if (i in array && fn.call(thisObj, array[i], i, array)) return !0;
return !1;
}, /**
Evaluates _obj_ to determine if it's an array, an array-like collection, or
something else. This is useful when working with the function `arguments`
collection and `HTMLElement` collections.
Note: This implementation doesn't consider elements that are also
collections, such as `<form>` and `<select>`, to be array-like.
@method test
@param {Object} obj Object to test.
@return {Number} A number indicating the results of the test:
* 0: Neither an array nor an array-like collection.
* 1: Real array.
* 2: Array-like collection.
@static
**/ YArray.test = function(obj) {
var result = 0;
if (Lang.isArray(obj)) result = 1;
else if (Lang.isObject(obj)) try {
// indexed, but no tagName (element) or scrollTo/document (window. From DOM.isWindow test which we can't use here),
// or functions without apply/call (Safari
// HTMLElementCollection bug).
"length" in obj && !obj.tagName && !(obj.scrollTo && obj.document) && !obj.apply && (result = 2);
} catch (ex) {}
return result;
}, Queue.prototype = {
/**
* Initialize the queue
*
* @method _init
* @protected
*/ _init: function() {
/**
* The collection of enqueued items
*
* @property _q
* @type Array
* @protected
*/ this._q = [];
},
/**
* Get the next item in the queue. FIFO support
*
* @method next
* @return {MIXED} the next item in the queue.
*/ next: function() {
return this._q.shift();
},
/**
* Get the last in the queue. LIFO support.
*
* @method last
* @return {MIXED} the last item in the queue.
*/ last: function() {
return this._q.pop();
},
/**
* Add 0..n items to the end of the queue.
*
* @method add
* @param {MIXED} item* 0..n items.
* @return {object} this queue.
*/ add: function() {
return this._q.push.apply(this._q, arguments), this;
},
/**
* Returns the current number of queued items.
*
* @method size
* @return {Number} The size.
*/ size: function() {
return this._q.length;
}
}, Y.Queue = Queue, YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Queue();
/**
The YUI module contains the components required for building the YUI seed file.
This includes the script loading mechanism, a simple queue, and the core
utilities for the library.
@module yui
@submodule yui-base
**/ var hasOwn = Object.prototype.hasOwnProperty, isObject = Y.Lang.isObject;
/**
Returns a wrapper for a function which caches the return value of that function,
keyed off of the combined string representation of the argument values provided
when the wrapper is called.
Calling this function again with the same arguments will return the cached value
rather than executing the wrapped function.
Note that since the cache is keyed off of the string representation of arguments
passed to the wrapper function, arguments that aren't strings and don't provide
a meaningful `toString()` method may result in unexpected caching behavior. For
example, the objects `{}` and `{foo: 'bar'}` would both be converted to the
string `[object Object]` when used as a cache key.
@method cached
@param {Function} source The function to memoize.
@param {Object} [cache={}] Object in which to store cached values. You may seed
this object with pre-existing cached values if desired.
@param {any} [refetch] If supplied, this value is compared with the cached value
using a `==` comparison. If the values are equal, the wrapped function is
executed again even though a cached value exists.
@return {Function} Wrapped function.
@for YUI
**/ Y.cached = function(source, cache, refetch) {
return /*jshint expr: true*/ cache || (cache = {}), function(arg) {
var key = arguments.length > 1 ? Array.prototype.join.call(arguments, "__") : String(arg);
return key in cache && (!refetch || cache[key] != refetch) || (cache[key] = source.apply(source, arguments)), cache[key];
};
}, /**
Returns the `location` object from the window/frame in which this YUI instance
operates, or `undefined` when executing in a non-browser environment
(e.g. Node.js).
It is _not_ recommended to hold references to the `window.location` object
outside of the scope of a function in which its properties are being accessed or
its methods are being called. This is because of a nasty bug/issue that exists
in both Safari and MobileSafari browsers:
[WebKit Bug 34679](https://bugs.webkit.org/show_bug.cgi?id=34679).
@method getLocation
@return {location} The `location` object from the window/frame in which this YUI
instance operates.
@since 3.5.0
**/ Y.getLocation = function() {
// It is safer to look this up every time because yui-base is attached to a
// YUI instance before a user's config is applied; i.e. `Y.config.win` does
// not point the correct window object when this file is loaded.
var win = Y.config.win;
// It is not safe to hold a reference to the `location` object outside the
// scope in which it is being used. The WebKit engine used in Safari and
// MobileSafari will "disconnect" the `location` object from the `window`
// when a page is restored from back/forward history cache.
return win && win.location;
}, /**
Returns a new object containing all of the properties of all the supplied
objects. The properties from later objects will overwrite those in earlier
objects.
Passing in a single object will create a shallow copy of it. For a deep copy,
use `clone()`.
@method merge
@param {Object} objects* One or more objects to merge.
@return {Object} A new merged object.
**/ Y.merge = function() {
for(var key, obj, i = 0, len = arguments.length, result = {}; i < len; ++i)for(key in obj = arguments[i])hasOwn.call(obj, key) && (result[key] = obj[key]);
return result;
}, /**
Mixes _supplier_'s properties into _receiver_.
Properties on _receiver_ or _receiver_'s prototype will not be overwritten or
shadowed unless the _overwrite_ parameter is `true`, and will not be merged
unless the _merge_ parameter is `true`.
In the default mode (0), only properties the supplier owns are copied (prototype
properties are not copied). The following copying modes are available:
* `0`: _Default_. Object to object.
* `1`: Prototype to prototype.
* `2`: Prototype to prototype and object to object.
* `3`: Prototype to object.
* `4`: Object to prototype.
@method mix
@param {Function|Object} receiver The object or function to receive the mixed
properties.
@param {Function|Object} supplier The object or function supplying the
properties to be mixed.
@param {Boolean} [overwrite=false] If `true`, properties that already exist
on the receiver will be overwritten with properties from the supplier.
@param {String[]} [whitelist] An array of property names to copy. If
specified, only the whitelisted properties will be copied, and all others
will be ignored.
@param {Number} [mode=0] Mix mode to use. See above for available modes.
@param {Boolean} [merge=false] If `true`, objects and arrays that already
exist on the receiver will have the corresponding object/array from the
supplier merged into them, rather than being skipped or overwritten. When
both _overwrite_ and _merge_ are `true`, _merge_ takes precedence.
@return {Function|Object|YUI} The receiver, or the YUI instance if the
specified receiver is falsy.
**/ Y.mix = function(receiver, supplier, overwrite, whitelist, mode, merge) {
var alwaysOverwrite, exists, from, i, key, len, to;
// If no supplier is given, we return the receiver. If no receiver is given,
// we return Y. Returning Y doesn't make much sense to me, but it's
// grandfathered in for backcompat reasons.
if (!receiver || !supplier) return receiver || Y;
if (mode) // If either the supplier or receiver doesn't actually have a
// prototype property, then we could end up with an undefined `from`
// or `to`. If that happens, we abort and return the receiver.
{
if (2 === mode && Y.mix(receiver.prototype, supplier.prototype, overwrite, whitelist, 0, merge), // Depending on which mode is specified, we may be copying from or to
// the prototypes of the supplier and receiver.
from = 1 === mode || 3 === mode ? supplier.prototype : supplier, to = 1 === mode || 4 === mode ? receiver.prototype : receiver, !from || !to) return receiver;
} else from = supplier, to = receiver;
if (// If `overwrite` is truthy and `merge` is falsy, then we can skip a
// property existence check on each iteration and save some time.
alwaysOverwrite = overwrite && !merge, whitelist) for(i = 0, len = whitelist.length; i < len; ++i)// We call `Object.prototype.hasOwnProperty` instead of calling
// `hasOwnProperty` on the object itself, since the object's
// `hasOwnProperty` method may have been overridden or removed.
// Also, some native objects don't implement a `hasOwnProperty`
// method.
key = whitelist[i], hasOwn.call(from, key) && (// The `key in to` check here is (sadly) intentional for backwards
// compatibility reasons. It prevents undesired shadowing of
// prototype members on `to`.
exists = !alwaysOverwrite && key in to, merge && exists && isObject(to[key], !0) && isObject(from[key], !0) ? // If we're in merge mode, and the key is present on both
// objects, and the value on both objects is either an object or
// an array (but not a function), then we recurse to merge the
// `from` value into the `to` value instead of overwriting it.
//
// Note: It's intentional that the whitelist isn't passed to the
// recursive call here. This is legacy behavior that lots of
// code still depends on.
Y.mix(to[key], from[key], overwrite, null, 0, merge) : (overwrite || !exists) && // We're not in merge mode, so we'll only copy the `from` value
// to the `to` value if we're in overwrite mode or if the
// current key doesn't exist on the `to` object.
(to[key] = from[key]));
else {
for(key in from)// The code duplication here is for runtime performance reasons.
// Combining whitelist and non-whitelist operations into a single
// loop or breaking the shared logic out into a function both result
// in worse performance, and Y.mix is critical enough that the byte
// tradeoff is worth it.
hasOwn.call(from, key) && (// The `key in to` check here is (sadly) intentional for backwards
// compatibility reasons. It prevents undesired shadowing of
// prototype members on `to`.
exists = !alwaysOverwrite && key in to, merge && exists && isObject(to[key], !0) && isObject(from[key], !0) ? Y.mix(to[key], from[key], overwrite, null, 0, merge) : (overwrite || !exists) && (to[key] = from[key]));
// If this is an IE browser with the JScript enumeration bug, force
// enumeration of the buggy properties by making a recursive call with
// the buggy properties as the whitelist.
Y.Object._hasEnumBug && Y.mix(to, from, overwrite, Y.Object._forceEnum, mode, merge);
}
return receiver;
};
/**
* The YUI module contains the components required for building the YUI
* seed file. This includes the script loading mechanism, a simple queue,
* and the core utilities for the library.
* @module yui
* @submodule yui-base
*/ /**
* Adds utilities to the YUI instance for working with objects.
*
* @class Object
*/ var UNDEFINED, Lang = Y.Lang, hasOwn = Object.prototype.hasOwnProperty, /**
* Returns a new object that uses _obj_ as its prototype. This method wraps the
* native ES5 `Object.create()` method if available, but doesn't currently
* pass through `Object.create()`'s second argument (properties) in order to
* ensure compatibility with older browsers.
*
* @method ()
* @param {Object} obj Prototype object.
* @return {Object} New object using _obj_ as its prototype.
* @static
*/ O = Y.Object = Lang._isNative(Object.create) ? function(obj) {
// We currently wrap the native Object.create instead of simply aliasing it
// to ensure consistency with our fallback shim, which currently doesn't
// support Object.create()'s second argument (properties). Once we have a
// safe fallback for the properties arg, we can stop wrapping
// Object.create().
return Object.create(obj);
} : function() {
// Reusable constructor function for the Object.create() shim.
function F() {}
// The actual shim.
return function(obj) {
return F.prototype = obj, new F();
};
}(), /**
* Property names that IE doesn't enumerate in for..in loops, even when they
* should be enumerable. When `_hasEnumBug` is `true`, it's necessary to
* manually enumerate these properties.
*
* @property _forceEnum
* @type String[]
* @protected
* @static
*/ forceEnum = O._forceEnum = [
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"toString",
"toLocaleString",
"valueOf"
], /**
* `true` if this browser has the JScript enumeration bug that prevents
* enumeration of the properties named in the `_forceEnum` array, `false`
* otherwise.
*
* See:
* - <https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug>
* - <http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation>
*
* @property _hasEnumBug
* @type Boolean
* @protected
* @static
*/ hasEnumBug = O._hasEnumBug = !({
valueOf: 0
}).propertyIsEnumerable("valueOf"), /**
* `true` if this browser incorrectly considers the `prototype` property of
* functions to be enumerable. Currently known to affect Opera 11.50 and Android 2.3.x.
*
* @property _hasProtoEnumBug
* @type Boolean
* @protected
* @static
*/ hasProtoEnumBug = O._hasProtoEnumBug = (function() {}).propertyIsEnumerable("prototype"), /**
* Returns `true` if _key_ exists on _obj_, `false` if _key_ doesn't exist or
* exists only on _obj_'s prototype. This is essentially a safer version of
* `obj.hasOwnProperty()`.
*
* @method owns
* @param {Object} obj Object to test.
* @param {String} key Property name to look for.
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
* @static
*/ owns = O.owns = function(obj, key) {
return !!obj && hasOwn.call(obj, key);
}; // <-- End of var declarations.
/**
* Alias for `owns()`.
*
* @method hasKey
* @param {Object} obj Object to test.
* @param {String} key Property name to look for.
* @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
* @static
*/ O.hasKey = owns, /**
* Returns an array containing the object's enumerable keys. Does not include
* prototype keys or non-enumerable keys.
*
* Note that keys are returned in enumeration order (that is, in the same order
* that they would be enumerated by a `for-in` loop), which may not be the same
* as the order in which they were defined.
*
* This method is an alias for the native ES5 `Object.keys()` method if
* available and non-buggy. The Opera 11.50 and Android 2.3.x versions of
* `Object.keys()` have an inconsistency as they consider `prototype` to be
* enumerable, so a non-native shim is used to rectify the difference.
*
* @example
*
* Y.Object.keys({a: 'foo', b: 'bar', c: 'baz'});
* // => ['a', 'b', 'c']
*
* @method keys
* @param {Object} obj An object.
* @return {String[]} Array of keys.
* @static
*/ O.keys = Lang._isNative(Object.keys) && !hasProtoEnumBug ? Object.keys : function(obj) {
if (!Lang.isObject(obj)) throw TypeError("Object.keys called on a non-object");
var i, key, len, keys = [];
if (hasProtoEnumBug && "function" == typeof obj) for(key in obj)owns(obj, key) && "prototype" !== key && keys.push(key);
else for(key in obj)owns(obj, key) && keys.push(key);
if (hasEnumBug) for(i = 0, len = forceEnum.length; i < len; ++i)owns(obj, key = forceEnum[i]) && keys.push(key);
return keys;
}, /**
* Returns an array containing the values of the object's enumerable keys.
*
* Note that values are returned in enumeration order (that is, in the same
* order that they would be enumerated by a `for-in` loop), which may not be the
* same as the order in which they were defined.
*
* @example
*
* Y.Object.values({a: 'foo', b: 'bar', c: 'baz'});
* // => ['foo', 'bar', 'baz']
*
* @method values
* @param {Object} obj An object.
* @return {Array} Array of values.
* @static
*/ O.values = function(obj) {
for(var keys = O.keys(obj), i = 0, len = keys.length, values = []; i < len; ++i)values.push(obj[keys[i]]);
return values;
}, /**
* Returns the number of enumerable keys owned by an object.
*
* @method size
* @param {Object} obj An object.
* @return {Number} The object's size.
* @static
*/ O.size = function(obj) {
try {
return O.keys(obj).length;
} catch (ex) {
return 0; // Legacy behavior for non-objects.
}
}, /**
* Returns `true` if the object owns an enumerable property with the specified
* value.
*
* @method hasValue
* @param {Object} obj An object.
* @param {any} value The value to search for.
* @return {Boolean} `true` if _obj_ contains _value_, `false` otherwise.
* @static
*/ O.hasValue = function(obj, value) {
return Y.Array.indexOf(O.values(obj), value) > -1;
}, /**
* Executes a function on each enumerable property in _obj_. The function
* receives the value, the key, and the object itself as parameters (in that
* order).
*
* By default, only properties owned by _obj_ are enumerated. To include
* prototype properties, set the _proto_ parameter to `true`.
*
* @method each
* @param {Object} obj Object to enumerate.
* @param {Function} fn Function to execute on each enumerable property.
* @param {mixed} fn.value Value of the current property.
* @param {String} fn.key Key of the current property.
* @param {Object} fn.obj Object being enumerated.
* @param {Object} [thisObj] `this` object to use when calling _fn_.
* @param {Boolean} [proto=false] Include prototype properties.
* @return {YUI} the YUI instance.
* @chainable
* @static
*/ O.each = function(obj, fn, thisObj, proto) {
var key;
for(key in obj)(proto || owns(obj, key)) && fn.call(thisObj || Y, obj[key], key, obj);
return Y;
}, /**
* Executes a function on each enumerable property in _obj_, but halts if the
* function returns a truthy value. The function receives the value, the key,
* and the object itself as paramters (in that order).
*
* By default, only properties owned by _obj_ are enumerated. To include
* prototype properties, set the _proto_ parameter to `true`.
*
* @method some
* @param {Object} obj Object to enumerate.
* @param {Function} fn Function to execute on each enumerable property.
* @param {mixed} fn.value Value of the current property.
* @param {String} fn.key Key of the current property.
* @param {Object} fn.obj Object being enumerated.
* @param {Object} [thisObj] `this` object to use when calling _fn_.
* @param {Boolean} [proto=false] Include prototype properties.
* @return {Boolean} `true` if any execution of _fn_ returns a truthy value,
* `false` otherwise.
* @static
*/ O.some = function(obj, fn, thisObj, proto) {
var key;
for(key in obj)if ((proto || owns(obj, key)) && fn.call(thisObj || Y, obj[key], key, obj)) return !0;
return !1;
}, /**
* Retrieves the sub value at the provided path,
* from the value object provided.
*
* @method getValue
* @static
* @param o The object from which to extract the property value.
* @param path {Array} A path array, specifying the object traversal path
* from which to obtain the sub value.
* @return {Any} The value stored in the path, undefined if not found,
* undefined if the source is not an object. Returns the source object
* if an empty path is provided.
*/ O.getValue = function(o, path) {
if (!Lang.isObject(o)) return UNDEFINED;
var i, p = Y.Array(path), l = p.length;
for(i = 0; o !== UNDEFINED && i < l; i++)o = o[p[i]];
return o;
}, /**
* Sets the sub-attribute value at the provided path on the
* value object. Returns the modified value object, or
* undefined if the path is invalid.
*
* @method setValue
* @static
* @param o The object on which to set the sub value.
* @param path {Array} A path array, specifying the object traversal path
* at which to set the sub value.
* @param val {Any} The new value for the sub-attribute.
* @return {Object} The modified object, with the new sub value set, or
* undefined, if the path was invalid.
*/ O.setValue = function(o, path, val) {
var i, p = Y.Array(path), leafIdx = p.length - 1, ref = o;
if (leafIdx >= 0) {
for(i = 0; ref !== UNDEFINED && i < leafIdx; i++)ref = ref[p[i]];
if (ref === UNDEFINED) return UNDEFINED;
ref[p[i]] = val;
}
return o;
}, /**
* Returns `true` if the object has no enumerable properties of its own.
*
* @method isEmpty
* @param {Object} obj An object.
* @return {Boolean} `true` if the object is empty.
* @static
* @since 3.2.0
*/ O.isEmpty = function(obj) {
return !O.keys(Object(obj)).length;
}, /**
* The YUI module contains the components required for building the YUI seed
* file. This includes the script loading mechanism, a simple queue, and the
* core utilities for the library.
* @module yui
* @submodule yui-base
*/ /**
* YUI user agent detection.
* Do not fork for a browser if it can be avoided. Use feature detection when
* you can. Use the user agent as a last resort. For all fields listed
* as @type float, UA stores a version number for the browser engine,
* 0 otherwise. This value may or may not map to the version number of
* the browser using the engine. The value is presented as a float so
* that it can easily be used for boolean evaluation as well as for
* looking for a particular range of versions. Because of this,
* some of the granularity of the version info may be lost. The fields that
* are @type string default to null. The API docs list the values that
* these fields can have.
* @class UA
* @static
*/ /**
* Static method on `YUI.Env` for parsing a UA string. Called at instantiation
* to populate `Y.UA`.
*
* @static
* @method parseUA
* @param {String} [subUA=navigator.userAgent] UA string to parse
* @return {Object} The Y.UA object
*/ YUI.Env.parseUA = function(subUA) {
var m, numberify = function(s) {
var c = 0;
return parseFloat(s.replace(/\./g, function() {
return 1 == c++ ? "" : ".";
}));
}, win = Y.config.win, nav = win && win.navigator, o = {
/**
* Internet Explorer version number or 0. Example: 6
* @property ie
* @type float
* @static
*/ ie: 0,
/**
* Opera version number or 0. Example: 9.2
* @property opera
* @type float
* @static
*/ opera: 0,
/**
* Gecko engine revision number. Will evaluate to 1 if Gecko
* is detected but the revision could not be found. Other browsers
* will be 0. Example: 1.8
* <pre>
* Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7
* Firefox 1.5.0.9: 1.8.0.9 <-- 1.8
* Firefox 2.0.0.3: 1.8.1.3 <-- 1.81
* Firefox 3.0 <-- 1.9
* Firefox 3.5 <-- 1.91
* </pre>
* @property gecko
* @type float
* @static
*/ gecko: 0,
/**
* AppleWebKit version. KHTML browsers that are not WebKit browsers
* will evaluate to 1, other browsers 0. Example: 418.9
* <pre>
* Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the
* latest available for Mac OSX 10.3.
* Safari 2.0.2: 416 <-- hasOwnProperty introduced
* Safari 2.0.4: 418 <-- preventDefault fixed
* Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run
* different versions of webkit
* Safari 2.0.4 (419.3): 419 <-- Tiger installations that have been
* updated, but not updated
* to the latest patch.
* Webkit 212 nightly: 522+ <-- Safari 3.0 precursor (with native
* SVG and many major issues fixed).
* Safari 3.0.4 (523.12) 523.12 <-- First Tiger release - automatic
* update from 2.x via the 10.4.11 OS patch.
* Webkit nightly 1/2008:525+ <-- Supports DOMContentLoaded event.
* yahoo.com user agent hack removed.
* </pre>
* http://en.wikipedia.org/wiki/Safari_version_history
* @property webkit
* @type float
* @static
*/ webkit: 0,
/**
* Safari will be detected as webkit, but this property will also
* be populated with the Safari version number
* @property safari
* @type float
* @static
*/ safari: 0,
/**
* Chrome will be detected as webkit, but this property will also
* be populated with the Chrome version number
* @property chrome
* @type float
* @static
*/ chrome: 0,
/**
* The mobile property will be set to a string containing any relevant
* user agent information when a modern mobile browser is detected.
* Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series
* devices with the WebKit-based browser, and Opera Mini.
* @property mobile
* @type string
* @default null
* @static
*/ mobile: null,
/**
* Adobe AIR version number or 0. Only populated if webkit is detected.
* Example: 1.0
* @property air
* @type float
*/ air: 0,
/**
* PhantomJS version number or 0. Only populated if webkit is detected.
* Example: 1.0
* @property phantomjs
* @type float
*/ phantomjs: 0,
/**
* Detects Apple iPad's OS version
* @property ipad
* @type float
* @static
*/ ipad: 0,
/**
* Detects Apple iPhone's OS version
* @property iphone
* @type float
* @static
*/ iphone: 0,
/**
* Detects Apples iPod's OS version
* @property ipod
* @type float
* @static
*/ ipod: 0,
/**
* General truthy check for iPad, iPhone or iPod
* @property ios
* @type Boolean
* @default null
* @static
*/ ios: null,
/**
* Detects Googles Android OS version
* @property android
* @type float
* @static
*/ android: 0,
/**
* Detects Kindle Silk
* @property silk
* @type float
* @static
*/ silk: 0,
/**
* Detects Kindle Silk Acceleration
* @property accel
* @type Boolean
* @static
*/ accel: !1,
/**
* Detects Palms WebOS version
* @property webos
* @type float
* @static
*/ webos: 0,
/**
* Google Caja version number or 0.
* @property caja
* @type float
*/ caja: nav && nav.cajaVersion,
/**
* Set to true if the page appears to be in SSL
* @property secure
* @type boolean
* @static
*/ secure: !1,
/**
* The operating system. Currently only detecting windows or macintosh
* @property os
* @type string
* @default null
* @static
*/ os: null,
/**
* The Nodejs Version
* @property nodejs
* @type float
* @default 0
* @static
*/ nodejs: 0,
/**
* Window8/IE10 Application host environment
* @property winjs
* @type Boolean
* @static
*/ winjs: !!("undefined" != typeof Windows && Windows.System),
/**
* Are touch/msPointer events available on this device
* @property touchEnabled
* @type Boolean
* @static
*/ touchEnabled: !1
}, ua = subUA || nav && nav.userAgent, loc = win && win.location, href = loc && loc.href;
return(/**
* The User Agent string that was parsed
* @property userAgent
* @type String
* @static
*/ o.userAgent = ua, o.secure = href && 0 === href.toLowerCase().indexOf("https"), ua && (/windows|win32/i.test(ua) ? o.os = "windows" : /macintosh|mac_powerpc/i.test(ua) ? o.os = "macintosh" : /android/i.test(ua) ? o.os = "android" : /symbos/i.test(ua) ? o.os = "symbos" : /linux/i.test(ua) ? o.os = "linux" : /rhino/i.test(ua) && (o.os = "rhino"), /KHTML/.test(ua) && (o.webkit = 1), /IEMobile|XBLWP7/.test(ua) && (o.mobile = "windows"), /Fennec/.test(ua) && (o.mobile = "gecko"), // Modern WebKit browsers are at least X-Grade
(m = ua.match(/AppleWebKit\/([^\s]*)/)) && m[1] && (o.webkit = numberify(m[1]), o.safari = o.webkit, /PhantomJS/.test(ua) && (m = ua.match(/PhantomJS\/([^\s]*)/)) && m[1] && (o.phantomjs = numberify(m[1])), / Mobile\//.test(ua) || /iPad|iPod|iPhone/.test(ua) ? (o.mobile = "Apple", (m = ua.match(/OS ([^\s]*)/)) && m[1] && (m = numberify(m[1].replace("_", "."))), o.ios = m, o.os = "ios", o.ipad = o.ipod = o.iphone = 0, (m = ua.match(/iPad|iPod|iPhone/)) && m[0] && (o[m[0].toLowerCase()] = o.ios)) : ((m = ua.match(/NokiaN[^\/]*|webOS\/\d\.\d/)) && // Nokia N-series, webOS, ex: NokiaN95
(o.mobile = m[0]), /webOS/.test(ua) && (o.mobile = "WebOS", (m = ua.match(/webOS\/([^\s]*);/)) && m[1] && (o.webos = numberify(m[1]))), / Android/.test(ua) && (/Mobile/.test(ua) && (o.mobile = "Android"), (m = ua.match(/Android ([^\s]*);/)) && m[1] && (o.android = numberify(m[1]))), /Silk/.test(ua) && ((m = ua.match(/Silk\/([^\s]*)\)/)) && m[1] && (o.silk = numberify(m[1])), o.android || (o.android = 2.34, o.os = "Android"), /Accelerated=true/.test(ua) && (o.accel = !0))), (m = ua.match(/OPR\/(\d+\.\d+)/)) && m[1] ? // Opera 15+ with Blink (pretends to be both Chrome and Safari)
o.opera = numberify(m[1]) : (m = ua.match(/(Chrome|CrMo|CriOS)\/([^\s]*)/)) && m[1] && m[2] ? (o.chrome = numberify(m[2]), o.safari = 0, "CrMo" === m[1] && (o.mobile = "chrome")) : (m = ua.match(/AdobeAIR\/([^\s]*)/)) && (o.air = m[0])), !o.webkit && (/Opera/.test(ua) ? ((m = ua.match(/Opera[\s\/]([^\s]*)/)) && m[1] && (o.opera = numberify(m[1])), (m = ua.match(/Version\/([^\s]*)/)) && m[1] && (o.opera = numberify(m[1])), /Opera Mobi/.test(ua) && (o.mobile = "opera", (m = ua.replace("Opera Mobi", "").match(/Opera ([^\s]*)/)) && m[1] && (o.opera = numberify(m[1]))), (m = ua.match(/Opera Mini[^;]*/)) && (o.mobile = m[0])) : // not opera or webkit
(m = ua.match(/MSIE ([^;]*)|Trident.*; rv:([0-9.]+)/)) && (m[1] || m[2]) ? o.ie = numberify(m[1] || m[2]) : // not opera, webkit, or ie
(m = ua.match(/Gecko\/([^\s]*)/)) && (o.gecko = 1, (m = ua.match(/rv:([^\s\)]*)/)) && m[1] && (o.gecko = numberify(m[1]), /Mobile|Tablet/.test(ua) && (o.mobile = "ffos"))))), win && nav && !(o.chrome && o.chrome < 6) && (o.touchEnabled = "ontouchstart" in win || "msMaxTouchPoints" in nav && nav.msMaxTouchPoints > 0), subUA || ("object" == typeof process && process.versions && process.versions.node && (//NodeJS
o.os = process.platform, o.nodejs = numberify(process.versions.node)), YUI.Env.UA = o), o);
}, Y.UA = YUI.Env.UA || YUI.Env.parseUA(), /**
Performs a simple comparison between two version numbers, accounting for
standard versioning logic such as the fact that "535.8" is a lower version than
"535.24", even though a simple numerical comparison would indicate that it's
greater. Also accounts for cases such as "1.1" vs. "1.1.0", which are
considered equivalent.
Returns -1 if version _a_ is lower than version _b_, 0 if they're equivalent,
1 if _a_ is higher than _b_.
Versions may be numbers or strings containing numbers and dots. For example,
both `535` and `"535.8.10"` are acceptable. A version string containing
non-numeric characters, like `"535.8.beta"`, may produce unexpected results.
@method compareVersions
@param {Number|String} a First version number to compare.
@param {Number|String} b Second version number to compare.
@return -1 if _a_ is lower than _b_, 0 if they're equivalent, 1 if _a_ is
higher than _b_.
**/ Y.UA.compareVersions = function(a, b) {
var aPart, aParts, bPart, bParts, i, len;
if (a === b) return 0;
for(i = 0, aParts = (a + "").split("."), bParts = (b + "").split("."), len = Math.max(aParts.length, bParts.length); i < len; ++i){
if (aPart = parseInt(aParts[i], 10), bPart = parseInt(bParts[i], 10), /*jshint expr: true*/ isNaN(aPart) && (aPart = 0), isNaN(bPart) && (bPart = 0), aPart < bPart) return -1;
if (aPart > bPart) return 1;
}
return 0;
}, YUI.Env.aliases = {
anim: [
"anim-base",
"anim-color",
"anim-curve",
"anim-easing",
"anim-node-plugin",
"anim-scroll",
"anim-xy"
],
"anim-shape-transform": [
"anim-shape"
],
app: [
"app-base",
"app-content",
"app-transitions",
"lazy-model-list",
"model",
"model-list",
"model-sync-rest",
"router",
"view",
"view-node-map"
],
attribute: [
"attribute-base",
"attribute-complex"
],
"attribute-events": [
"attribute-observable"
],
autocomplete: [
"autocomplete-base",
"autocomplete-sources",
"autocomplete-list",
"autocomplete-plugin"
],
axes: [
"axis-numeric",
"axis-category",
"axis-time",
"axis-stacked"
],
"axes-base": [
"axis-numeric-base",
"axis-category-base",
"axis-time-base",
"axis-stacked-base"
],
base: [
"base-base",
"base-pluginhost",
"base-build"
],
cache: [
"cache-base",
"cache-offline",
"cache-plugin"
],
charts: [
"charts-base"
],
collection: [
"array-extras",
"arraylist",
"arraylist-add",
"arraylist-filter",
"array-invoke"
],
color: [
"color-base",
"color-hsl",
"color-harmony"
],
controller: [
"router"
],
dataschema: [
"dataschema-base",
"dataschema-json",
"dataschema-xml",
"dataschema-array",
"dataschema-text"
],
datasource: [
"datasource-local",
"datasource-io",
"datasource-get",
"datasource-function",
"datasource-cache",
"datasource-jsonschema",
"datasource-xmlschema",
"datasource-arrayschema",
"datasource-textschema",
"datasource-polling"
],
datatable: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"datatable-base",
"datatable-column-widths",
"datatable-message",
"datatable-mutable",
"datatable-sort",
"datatable-datasource"
],
datatype: [
"datatype-date",
"datatype-number",
"datatype-xml"
],
"datatype-date": [
"datatype-date-parse",
"datatype-date-format",
"datatype-date-math"
],
"datatype-number": [
"datatype-number-parse",
"datatype-number-format"
],
"datatype-xml": [
"datatype-xml-parse",
"datatype-xml-format"
],
dd: [
"dd-ddm-base",
"dd-ddm",
"dd-ddm-drop",
"dd-drag",
"dd-proxy",
"dd-constrain",
"dd-drop",
"dd-scroll",
"dd-delegate"
],
dom: [
"dom-base",
"dom-screen",
"dom-style",
"selector-native",
"selector"
],
editor: [
"frame",
"editor-selection",
"exec-command",
"editor-base",
"editor-para",
"editor-br",
"editor-bidi",
"editor-tab",
"createlink-base"
],
event: [
"event-base",
"event-delegate",
"event-synthetic",
"event-mousewheel",
"event-mouseenter",
"event-key",
"event-focus",
"event-resize",
"event-hover",
"event-outside",
"event-touch",
"event-move",
"event-flick",
"event-valuechange",
"event-tap"
],
"event-custom": [
"event-custom-base",
"event-custom-complex"
],
"event-gestures": [
"event-flick",
"event-move"
],
handlebars: [
"handlebars-compiler"
],
highlight: [
"highlight-base",
"highlight-accentfold"
],
history: [
"history-base",
"history-hash",
"history-hash-ie",
"history-html5"
],
io: [
"io-base",
"io-xdr",
"io-form",
"io-upload-iframe",
"io-queue"
],
json: [
"json-parse",
"json-stringify"
],
loader: [
"loader-base",
"loader-rollup",
"loader-yui3"
],
node: [
"node-base",
"node-event-delegate",
"node-pluginhost",
"node-screen",
"node-style"
],
pluginhost: [
"pluginhost-base",
"pluginhost-config"
],
querystring: [
"querystring-parse",
"querystring-stringify"
],
recordset: [
"recordset-base",
"recordset-sort",
"recordset-filter",
"recordset-indexer"
],
resize: [
"resize-base",
"resize-proxy",
"resize-constrain"
],
slider: [
"slider-base",
"slider-value-range",
"clickable-rail",
"range-slider"
],
template: [
"template-base",
"template-micro"
],
text: [
"text-accentfold",
"text-wordbreak"
],
widget: [
"widget-base",
"widget-htmlparser",
"widget-skin",
"widget-uievents"
]
};
}, "3.12.0", {
use: [
"yui-base",
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3"
]
}), YUI.add("get", function(Y, NAME) {
/*jslint boss:true, expr:true, laxbreak: true */ /**
Provides dynamic loading of remote JavaScript and CSS resources.
@module get
@class Get
@static
**/ var CUSTOM_ATTRS, Get, Transaction, Lang = Y.Lang;
Y.Get = Get = {
// -- Public Properties ----------------------------------------------------
/**
Default options for CSS requests. Options specified here will override
global defaults for CSS requests.
See the `options` property for all available options.
@property cssOptions
@type Object
@static
@since 3.5.0
**/ cssOptions: {
attributes: {
rel: "stylesheet"
},
doc: Y.config.linkDoc || Y.config.doc,
pollInterval: 50
},
/**
Default options for JS requests. Options specified here will override global
defaults for JS requests.
See the `options` property for all available options.
@property jsOptions
@type Object
@static
@since 3.5.0
**/ jsOptions: {
autopurge: !0,
doc: Y.config.scriptDoc || Y.config.doc
},
/**
Default options to use for all requests.
Note that while all available options are documented here for ease of
discovery, some options (like callback functions) only make sense at the
transaction level.
Callback functions specified via the options object or the `options`
parameter of the `css()`, `js()`, or `load()` methods will receive the
transaction object as a parameter. See `Y.Get.Transaction` for details on
the properties and methods available on transactions.
@static
@since 3.5.0
@property {Object} options
@property {Boolean} [options.async=false] Whether or not to load scripts
asynchronously, meaning they're requested in parallel and execution
order is not guaranteed. Has no effect on CSS, since CSS is always
loaded asynchronously.
@property {Object} [options.attributes] HTML attribute name/value pairs that
should be added to inserted nodes. By default, the `charset` attribute
will be set to "utf-8" and nodes will be given an auto-generated `id`
attribute, but you can override these with your own values if desired.
@property {Boolean} [options.autopurge] Whether or not to automatically
purge inserted nodes after the purge threshold is reached. This is
`true` by default for JavaScript, but `false` for CSS since purging a
CSS node will also remove any styling applied by the referenced file.
@property {Object} [options.context] `this` object to use when calling
callback functions. Defaults to the transaction object.
@property {Mixed} [options.data] Arbitrary data object to pass to "on*"
callbacks.
@property {Document} [options.doc] Document into which nodes should be
inserted. By default, the current document is used.
@property {HTMLElement|String} [options.insertBefore] HTML element or id
string of an element before which all generated nodes should be
inserted. If not specified, Get will automatically determine the best
place to insert nodes for maximum compatibility.
@property {Function} [options.onEnd] Callback to execute after a transaction
is complete, regardless of whether it succeeded or failed.
@property {Function} [options.onFailure] Callback to execute after a
transaction fails, times out, or is aborted.
@property {Function} [options.onProgress] Callback to execute after each
individual request in a transaction either succeeds or fails.
@property {Function} [options.onSuccess] Callback to execute after a
transaction completes successfully with no errors. Note that in browsers
that don't support the `error` event on CSS `<link>` nodes, a failed CSS
request may still be reported as a success because in these browsers
it can be difficult or impossible to distinguish between success and
failure for CSS resources.
@property {Function} [options.onTimeout] Callback to execute after a
transaction times out.
@property {Number} [options.pollInterval=50] Polling interval (in
milliseconds) for detecting CSS load completion in browsers that don't
support the `load` event on `<link>` nodes. This isn't used for
JavaScript.
@property {Number} [options.purgethreshold=20] Number of nodes to insert
before triggering an automatic purge when `autopurge` is `true`.
@property {Number} [options.timeout] Number of milliseconds to wait before
aborting a transaction. When a timeout occurs, the `onTimeout` callback
is called, followed by `onFailure` and finally `onEnd`. By default,
there is no timeout.
@property {String} [options.type] Resource type ("css" or "js"). This option
is set automatically by the `css()` and `js()` functions and will be
ignored there, but may be useful when using the `load()` function. If
not specified, the type will be inferred from the URL, defaulting to
"js" if the URL doesn't contain a recognizable file extension.
**/ options: {
attributes: {
charset: "utf-8"
},
purgethreshold: 20
},
// -- Protected Properties -------------------------------------------------
/**
Regex that matches a CSS URL. Used to guess the file type when it's not
specified.
@property REGEX_CSS
@type RegExp
@final
@protected
@static
@since 3.5.0
**/ REGEX_CSS: /\.css(?:[?;].*)?$/i,
/**
Regex that matches a JS URL. Used to guess the file type when it's not
specified.
@property REGEX_JS
@type RegExp
@final
@protected
@static
@since 3.5.0
**/ REGEX_JS: /\.js(?:[?;].*)?$/i,
/**
Contains information about the current environment, such as what script and
link injection features it supports.
This object is created and populated the first time the `_getEnv()` method
is called.
@property _env
@type Object
@protected
@static
@since 3.5.0
**/ /**
Mapping of document _yuid strings to <head> or <base> node references so we
don't have to look the node up each time we want to insert a request node.
@property _insertCache
@type Object
@protected
@static
@since 3.5.0
**/ _insertCache: {},
/**
Information about the currently pending transaction, if any.
This is actually an object with two properties: `callback`, containing the
optional callback passed to `css()`, `load()`, or `js()`; and `transaction`,
containing the actual transaction instance.
@property _pending
@type Object
@protected
@static
@since 3.5.0
**/ _pending: null,
/**
HTML nodes eligible to be purged next time autopurge is triggered.
@property _purgeNodes
@type HTMLElement[]
@protected
@static
@since 3.5.0
**/ _purgeNodes: [],
/**
Queued transactions and associated callbacks.
@property _queue
@type Object[]
@protected
@static
@since 3.5.0
**/ _queue: [],
// -- Public Methods -------------------------------------------------------
/**
Aborts the specified transaction.
This will cause the transaction's `onFailure` callback to be called and
will prevent any new script and link nodes from being added to the document,
but any resources that have already been requested will continue loading
(there's no safe way to prevent this, unfortunately).
*Note:* This method is deprecated as of 3.5.0, and will be removed in a
future version of YUI. Use the transaction-level `abort()` method instead.
@method abort
@param {Get.Transaction} transaction Transaction to abort.
@deprecated Use the `abort()` method on the transaction instead.
@static
**/ abort: function(transaction) {
var i, id, item, len, pending;
if (!transaction.abort) {
if (id = transaction, pending = this._pending, transaction = null, pending && pending.transaction.id === id) transaction = pending.transaction, this._pending = null;
else for(i = 0, len = this._queue.length; i < len; ++i)if ((item = this._queue[i].transaction).id === id) {
transaction = item, this._queue.splice(i, 1);
break;
}
}
transaction && transaction.abort();
},
/**
Loads one or more CSS files.
The _urls_ parameter may be provided as a URL string, a request object,
or an array of URL strings and/or request objects.
A request object is just an object that contains a `url` property and zero
or more options that should apply specifically to that request.
Request-specific options take priority over transaction-level options and
default options.
URLs may be relative or absolute, and do not have to have the same origin
as the current page.
The `options` parameter may be omitted completely and a callback passed in
its place, if desired.
@example
// Load a single CSS file and log a message on completion.
Y.Get.css('foo.css', function (err) {
if (err) {
} else {
}
});
// Load multiple CSS files and log a message when all have finished
// loading.
var urls = ['foo.css', 'http://example.com/bar.css', 'baz/quux.css'];
Y.Get.css(urls, function (err) {
if (err) {
} else {
}
});
// Specify transaction-level options, which will apply to all requests
// within the transaction.
Y.Get.css(urls, {
attributes: {'class': 'my-css'},
timeout : 5000
});
// Specify per-request options, which override transaction-level and
// default options.
Y.Get.css([
{url: 'foo.css', attributes: {id: 'foo'}},
{url: 'bar.css', attributes: {id: 'bar', charset: 'iso-8859-1'}}
]);
@method css
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} callback.err Array of errors that occurred during
the transaction, or `null` on success.
@param {Get.Transaction} callback.transaction Transaction object.
@return {Get.Transaction} Transaction object.
@static
**/ css: function(urls, options, callback) {
return this._load("css", urls, options, callback);
},
/**
Loads one or more JavaScript resources.
The _urls_ parameter may be provided as a URL string, a request object,
or an array of URL strings and/or request objects.
A request object is just an object that contains a `url` property and zero
or more options that should apply specifically to that request.
Request-specific options take priority over transaction-level options and
default options.
URLs may be relative or absolute, and do not have to have the same origin
as the current page.
The `options` parameter may be omitted completely and a callback passed in
its place, if desired.
Scripts will be executed in the order they're specified unless the `async`
option is `true`, in which case they'll be loaded in parallel and executed
in whatever order they finish loading.
@example
// Load a single JS file and log a message on completion.
Y.Get.js('foo.js', function (err) {
if (err) {
} else {
}
});
// Load multiple JS files, execute them in order, and log a message when
// all have finished loading.
var urls = ['foo.js', 'http://example.com/bar.js', 'baz/quux.js'];
Y.Get.js(urls, function (err) {
if (err) {
} else {
}
});
// Specify transaction-level options, which will apply to all requests
// within the transaction.
Y.Get.js(urls, {
attributes: {'class': 'my-js'},
timeout : 5000
});
// Specify per-request options, which override transaction-level and
// default options.
Y.Get.js([
{url: 'foo.js', attributes: {id: 'foo'}},
{url: 'bar.js', attributes: {id: 'bar', charset: 'iso-8859-1'}}
]);
@method js
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} callback.err Array of errors that occurred during
the transaction, or `null` on success.
@param {Get.Transaction} callback.transaction Transaction object.
@return {Get.Transaction} Transaction object.
@since 3.5.0
@static
**/ js: function(urls, options, callback) {
return this._load("js", urls, options, callback);
},
/**
Loads one or more CSS and/or JavaScript resources in the same transaction.
Use this method when you want to load both CSS and JavaScript in a single
transaction and be notified when all requested URLs have finished loading,
regardless of type.
Behavior and options are the same as for the `css()` and `js()` methods. If
a resource type isn't specified in per-request options or transaction-level
options, Get will guess the file type based on the URL's extension (`.css`
or `.js`, with or without a following query string). If the file type can't
be guessed from the URL, a warning will be logged and Get will assume the
URL is a JavaScript resource.
@example
// Load both CSS and JS files in a single transaction, and log a message
// when all files have finished loading.
Y.Get.load(['foo.css', 'bar.js', 'baz.css'], function (err) {
if (err) {
} else {
}
});
@method load
@param {String|Object|Array} urls URL string, request object, or array
of URLs and/or request objects to load.
@param {Object} [options] Options for this transaction. See the
`Y.Get.options` property for a complete list of available options.
@param {Function} [callback] Callback function to be called on completion.
This is a general callback and will be called before any more granular
callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
object.
@param {Array|null} err Array of errors that occurred during the
transaction, or `null` on success.
@param {Get.Transaction} Transaction object.
@return {Get.Transaction} Transaction object.
@since 3.5.0
@static
**/ load: function(urls, options, callback) {
return this._load(null, urls, options, callback);
},
// -- Protected Methods ----------------------------------------------------
/**
Triggers an automatic purge if the purge threshold has been reached.
@method _autoPurge
@param {Number} threshold Purge threshold to use, in milliseconds.
@protected
@since 3.5.0
@static
**/ _autoPurge: function(threshold) {
threshold && this._purgeNodes.length >= threshold && this._purge(this._purgeNodes);
},
/**
Populates the `_env` property with information about the current
environment.
@method _getEnv
@return {Object} Environment information.
@protected
@since 3.5.0
@static
**/ _getEnv: function() {
var doc = Y.config.doc, ua = Y.UA;
// Note: some of these checks require browser sniffs since it's not
// feasible to load test files on every pageview just to perform a
// feature test. I'm sorry if this makes you sad.
return this._env = {
// True if this is a browser that supports disabling async mode on
// dynamically created script nodes. See
// https://developer.mozilla.org/En/HTML/Element/Script#Attributes
// IE10 doesn't return true for the MDN feature test, so setting it explicitly,
// because it is async by default, and allows you to disable async by setting it to false
async: doc && !0 === doc.createElement("script").async || ua.ie >= 10,
// True if this browser fires an event when a dynamically injected
// link node fails to load. This is currently true for Firefox 9+
// and WebKit 535.24+
cssFail: ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0,
// True if this browser fires an event when a dynamically injected
// link node finishes loading. This is currently true for IE, Opera,
// Firefox 9+, and WebKit 535.24+. Note that IE versions <9 fire the
// DOM 0 "onload" event, but not "load". All versions of IE fire
// "onload".
// davglass: Seems that Chrome on Android needs this to be false.
cssLoad: (!ua.gecko && !ua.webkit || ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0) && !(ua.chrome && ua.chrome <= 18),
// True if this browser preserves script execution order while
// loading scripts in parallel as long as the script node's `async`
// attribute is set to false to explicitly disable async execution.
preservesScriptOrder: !!(ua.gecko || ua.opera || ua.ie && ua.ie >= 10)
};
},
_getTransaction: function(urls, options) {
var i, len, req, url, requests = [];
for(Lang.isArray(urls) || (urls = [
urls
]), // Clone the attributes object so we don't end up modifying it by ref.
(options = Y.merge(this.options, options)).attributes = Y.merge(this.options.attributes, options.attributes), i = 0, len = urls.length; i < len; ++i){
// If `url` is a string, we create a URL object for it, then mix in
// global options and request-specific options. If it's an object
// with a "url" property, we assume it's a request object containing
// URL-specific options.
if (url = urls[i], req = {
attributes: {}
}, "string" == typeof url) req.url = url;
else {
if (!url.url) continue;
// URL-specific options override both global defaults and
// request-specific options.
Y.mix(req, url, !1, null, 0, !0), url = url.url;
}
Y.mix(req, options, !1, null, 0, !0), req.type || (this.REGEX_CSS.test(url) ? req.type = "css" : (this.REGEX_JS.test(url), req.type = "js")), // Mix in type-specific default options, but don't overwrite any
// options that have already been set.
Y.mix(req, "js" === req.type ? this.jsOptions : this.cssOptions, !1, null, 0, !0), // Give the node an id attribute if it doesn't already have one.
req.attributes.id || (req.attributes.id = Y.guid()), req.win ? req.doc = req.win.document : req.win = req.doc.defaultView || req.doc.parentWindow, req.charset && (req.attributes.charset = req.charset), requests.push(req);
}
return new Transaction(requests, options);
},
_load: function(type, urls, options, callback) {
var transaction;
return "function" == typeof options && (callback = options, options = {}), options || (options = {}), options.type = type, options._onFinish = Get._onTransactionFinish, this._env || this._getEnv(), transaction = this._getTransaction(urls, options), this._queue.push({
callback: callback,
transaction: transaction
}), this._next(), transaction;
},
_onTransactionFinish: function() {
Get._pending = null, Get._next();
},
_next: function() {
var item;
!this._pending && (item = this._queue.shift()) && (this._pending = item, item.transaction.execute(item.callback));
},
_purge: function(nodes) {
for(var index, node, purgeNodes = this._purgeNodes, isTransaction = nodes !== purgeNodes; node = nodes.pop();)// assignment
// Don't purge nodes that haven't finished loading (or errored out),
// since this can hang the transaction.
node._yuiget_finished && (node.parentNode && node.parentNode.removeChild(node), isTransaction && (index = Y.Array.indexOf(purgeNodes, node)) > -1 && purgeNodes.splice(index, 1));
}
}, /**
Alias for `js()`.
@method script
@static
**/ Get.script = Get.js, /**
Represents a Get transaction, which may contain requests for one or more JS or
CSS files.
This class should not be instantiated manually. Instances will be created and
returned as needed by Y.Get's `css()`, `js()`, and `load()` methods.
@class Get.Transaction
@constructor
@since 3.5.0
**/ Get.Transaction = Transaction = function(requests, options) {
this.id = Transaction._lastId += 1, this.data = options.data, this.errors = [], this.nodes = [], this.options = options, this.requests = requests, this._callbacks = [], this._queue = [], this._reqsWaiting = 0, // Deprecated pre-3.5.0 properties.
this.tId = this.id, this.win = options.win || Y.config.win;
}, /**
Arbitrary data object associated with this transaction.
This object comes from the options passed to `Get.css()`, `Get.js()`, or
`Get.load()`, and will be `undefined` if no data object was specified.
@property {Object} data
**/ /**
Array of errors that have occurred during this transaction, if any.
@since 3.5.0
@property {Object[]} errors
@property {String} errors.error Error message.
@property {Object} errors.request Request object related to the error.
**/ /**
Numeric id for this transaction, unique among all transactions within the same
YUI sandbox in the current pageview.
@property {Number} id
@since 3.5.0
**/ /**
HTMLElement nodes (native ones, not YUI Node instances) that have been inserted
during the current transaction.
@property {HTMLElement[]} nodes
**/ /**
Options associated with this transaction.
See `Get.options` for the full list of available options.
@property {Object} options
@since 3.5.0
**/ /**
Request objects contained in this transaction. Each request object represents
one CSS or JS URL that will be (or has been) requested and loaded into the page.
@property {Object} requests
@since 3.5.0
**/ /**
Id of the most recent transaction.
@property _lastId
@type Number
@protected
@static
**/ Transaction._lastId = 0, Transaction.prototype = {
// -- Public Properties ----------------------------------------------------
/**
Current state of this transaction. One of "new", "executing", or "done".
@property _state
@type String
@protected
**/ _state: "new",
// -- Public Methods -------------------------------------------------------
/**
Aborts this transaction.
This will cause the transaction's `onFailure` callback to be called and
will prevent any new script and link nodes from being added to the document,
but any resources that have already been requested will continue loading
(there's no safe way to prevent this, unfortunately).
@method abort
@param {String} [msg="Aborted."] Optional message to use in the `errors`
array describing why the transaction was aborted.
**/ abort: function(msg) {
this._pending = null, this._pendingCSS = null, this._pollTimer = clearTimeout(this._pollTimer), this._queue = [], this._reqsWaiting = 0, this.errors.push({
error: msg || "Aborted"
}), this._finish();
},
/**
Begins execting the transaction.
There's usually no reason to call this manually, since Get will call it
automatically when other pending transactions have finished. If you really
want to execute your transaction before Get does, you can, but be aware that
this transaction's scripts may end up executing before the scripts in other
pending transactions.
If the transaction is already executing, the specified callback (if any)
will be queued and called after execution finishes. If the transaction has
already finished, the callback will be called immediately (the transaction
will not be executed again).
@method execute
@param {Function} callback Callback function to execute after all requests
in the transaction are complete, or after the transaction is aborted.
**/ execute: function(callback) {
var i, len, queue, req, self = this, requests = self.requests, state = self._state;
if ("done" === state) {
callback && callback(self.errors.length ? self.errors : null, self);
return;
}
if (callback && self._callbacks.push(callback), "executing" !== state) {
for(self._state = "executing", self._queue = queue = [], self.options.timeout && (self._timeout = setTimeout(function() {
self.abort("Timeout");
}, self.options.timeout)), self._reqsWaiting = requests.length, i = 0, len = requests.length; i < len; ++i)(req = requests[i]).async || "css" === req.type ? // No need to queue CSS or fully async JS.
self._insert(req) : queue.push(req);
self._next();
}
},
/**
Manually purges any `<script>` or `<link>` nodes this transaction has
created.
Be careful when purging a transaction that contains CSS requests, since
removing `<link>` nodes will also remove any styles they applied.
@method purge
**/ purge: function() {
Get._purge(this.nodes);
},
// -- Protected Methods ----------------------------------------------------
_createNode: function(name, attrs, doc) {
var attr, testEl, node = doc.createElement(name);
for(attr in CUSTOM_ATTRS || (// IE6 and IE7 expect property names rather than attribute names for
// certain attributes. Rather than sniffing, we do a quick feature
// test the first time _createNode() runs to determine whether we
// need to provide a workaround.
(testEl = doc.createElement("div")).setAttribute("class", "a"), CUSTOM_ATTRS = "a" === testEl.className ? {} : {
for: "htmlFor",
class: "className"
}), attrs)attrs.hasOwnProperty(attr) && node.setAttribute(CUSTOM_ATTRS[attr] || attr, attrs[attr]);
return node;
},
_finish: function() {
var data, i, len, errors = this.errors.length ? this.errors : null, options = this.options, thisObj = options.context || this;
if ("done" !== this._state) {
for(i = 0, this._state = "done", len = this._callbacks.length; i < len; ++i)this._callbacks[i].call(thisObj, errors, this);
data = this._getEventData(), errors ? (options.onTimeout && "Timeout" === errors[errors.length - 1].error && options.onTimeout.call(thisObj, data), options.onFailure && options.onFailure.call(thisObj, data)) : options.onSuccess && options.onSuccess.call(thisObj, data), options.onEnd && options.onEnd.call(thisObj, data), options._onFinish && options._onFinish();
}
},
_getEventData: function(req) {
return req ? Y.merge(this, {
abort: this.abort,
purge: this.purge,
request: req,
url: req.url,
win: req.win
}) : this;
},
_getInsertBefore: function(req) {
var cache, docStamp, doc = req.doc, el = req.insertBefore;
return el ? "string" == typeof el ? doc.getElementById(el) : el : (el = (cache = Get._insertCache)[docStamp = Y.stamp(doc)]) ? el : (el = doc.getElementsByTagName("base")[0]) ? cache[docStamp] = el : // Look for a <head> element.
(el = doc.head || doc.getElementsByTagName("head")[0]) ? (// Create a marker node at the end of <head> to use as an insertion
// point. Inserting before this node will ensure that all our CSS
// gets inserted in the correct order, to maintain style precedence.
el.appendChild(doc.createTextNode("")), cache[docStamp] = el.lastChild) : cache[docStamp] = doc.getElementsByTagName("script")[0];
},
_insert: function(req) {
var cssTimeout, nodeType, env = Get._env, insertBefore = this._getInsertBefore(req), isScript = "js" === req.type, node = req.node, self = this, ua = Y.UA;
function onError() {
self._progress("Failed to load " + req.url, req);
}
function onLoad() {
cssTimeout && clearTimeout(cssTimeout), self._progress(null, req);
}
node || (nodeType = isScript ? "script" : !env.cssLoad && ua.gecko ? "style" : "link", node = req.node = this._createNode(nodeType, req.attributes, req.doc)), isScript ? (node.setAttribute("src", req.url), req.async ? // Explicitly indicate that we want the browser to execute this
// script asynchronously. This is necessary for older browsers
// like Firefox <4.
node.async = !0 : (env.async && // This browser treats injected scripts as async by default
// (standard HTML5 behavior) but asynchronous loading isn't
// desired, so tell the browser not to mark this script as
// async.
(node.async = !1), env.preservesScriptOrder || (this._pending = req))) : !env.cssLoad && ua.gecko ? // In Firefox <9, we can import the requested URL into a <style>
// node and poll for the existence of node.sheet.cssRules. This
// gives us a reliable way to determine CSS load completion that
// also works for cross-domain stylesheets.
//
// Props to Zach Leatherman for calling my attention to this
// technique.
node.innerHTML = (req.attributes.charset ? '@charset "' + req.attributes.charset + '";' : "") + '@import "' + req.url + '";' : node.setAttribute("href", req.url), isScript && ua.ie && (ua.ie < 9 || document.documentMode && document.documentMode < 9) ? // Script on IE < 9, and IE 9+ when in IE 8 or older modes, including quirks mode.
node.onreadystatechange = function() {
/loaded|complete/.test(node.readyState) && (node.onreadystatechange = null, onLoad());
} : isScript || env.cssLoad ? (ua.ie >= 10 ? (// We currently need to introduce a timeout for IE10, since it
// calls onerror/onload synchronously for 304s - messing up existing
// program flow.
// Remove this block if the following bug gets fixed by GA
/*jshint maxlen: 1500 */ // https://connect.microsoft.com/IE/feedback/details/763871/dynamically-loaded-scripts-with-304s-responses-interrupt-the-currently-executing-js-thread-onload
node.onerror = function() {
setTimeout(onError, 0);
}, node.onload = function() {
setTimeout(onLoad, 0);
}) : (node.onerror = onError, node.onload = onLoad), env.cssFail || isScript || (cssTimeout = setTimeout(onError, req.timeout || 3000))) : // CSS on Firefox <9 or WebKit.
this._poll(req), this.nodes.push(node), insertBefore.parentNode.insertBefore(node, insertBefore);
},
_next: function() {
!this._pending && (this._queue.length ? this._insert(this._queue.shift()) : this._reqsWaiting || this._finish());
},
_poll: function(newReq) {
var i, j, nodeHref, req, sheets, self = this, pendingCSS = self._pendingCSS, isWebKit = Y.UA.webkit;
if (!newReq || (pendingCSS || (pendingCSS = self._pendingCSS = []), pendingCSS.push(newReq), !self._pollTimer)) {
// Note: in both the WebKit and Gecko hacks below, a CSS URL that 404s
// will still be treated as a success. There's no good workaround for
// this.
for(i = 0, self._pollTimer = null; i < pendingCSS.length; ++i)if (req = pendingCSS[i], isWebKit) {
for(j = // Look for a stylesheet matching the pending URL.
(sheets = req.doc.styleSheets).length, nodeHref = req.node.href; --j >= 0;)if (sheets[j].href === nodeHref) {
pendingCSS.splice(i, 1), i -= 1, self._progress(null, req);
break;
}
} else // Many thanks to Zach Leatherman for calling my attention to
// the @import-based cross-domain technique used here, and to
// Oleg Slobodskoi for an earlier same-domain implementation.
//
// See Zach's blog for more details:
// http://www.zachleat.com/web/2010/07/29/load-css-dynamically/
try {
req.node.sheet.cssRules, // If we get here, the stylesheet has loaded.
pendingCSS.splice(i, 1), i -= 1, self._progress(null, req);
} catch (ex) {
// An exception means the stylesheet is still loading.
}
pendingCSS.length && (self._pollTimer = setTimeout(function() {
self._poll.call(self);
}, self.options.pollInterval));
}
},
_progress: function(err, req) {
var options = this.options;
err && (req.error = err, this.errors.push({
error: err,
request: req
})), req.node._yuiget_finished = req.finished = !0, options.onProgress && options.onProgress.call(options.context || this, this._getEventData(req)), req.autopurge && (// Pre-3.5.0 Get always excludes the most recent node from an
// autopurge. I find this odd, but I'm keeping that behavior for
// the sake of backcompat.
Get._autoPurge(this.options.purgethreshold), Get._purgeNodes.push(req.node)), this._pending === req && (this._pending = null), this._reqsWaiting -= 1, this._next();
}
};
}, "3.12.0", {
requires: [
"yui-base"
]
}), YUI.add("features", function(Y, NAME) {
var feature_tests = {};
/**
Contains the core of YUI's feature test architecture.
@module features
*/ /**
* Feature detection
* @class Features
* @static
*/ Y.mix(Y.namespace("Features"), {
/**
* Object hash of all registered feature tests
* @property tests
* @type Object
*/ tests: feature_tests,
/**
* Add a test to the system
*
* ```
* Y.Features.add("load", "1", {});
* ```
*
* @method add
* @param {String} cat The category, right now only 'load' is supported
* @param {String} name The number sequence of the test, how it's reported in the URL or config: 1, 2, 3
* @param {Object} o Object containing test properties
* @param {String} o.name The name of the test
* @param {Function} o.test The test function to execute, the only argument to the function is the `Y` instance
* @param {String} o.trigger The module that triggers this test.
*/ add: function(cat, name, o) {
feature_tests[cat] = feature_tests[cat] || {}, feature_tests[cat][name] = o;
},
/**
* Execute all tests of a given category and return the serialized results
*
* ```
* caps=1:1;2:1;3:0
* ```
* @method all
* @param {String} cat The category to execute
* @param {Array} args The arguments to pass to the test function
* @return {String} A semi-colon separated string of tests and their success/failure: 1:1;2:1;3:0
*/ all: function(cat, args) {
var cat_o = feature_tests[cat], // results = {};
result = [];
return cat_o && Y.Object.each(cat_o, function(v, k) {
result.push(k + ":" + +!!Y.Features.test(cat, k, args));
}), result.length ? result.join(";") : "";
},
/**
* Run a sepecific test and return a Boolean response.
*
* ```
* Y.Features.test("load", "1");
* ```
*
* @method test
* @param {String} cat The category of the test to run
* @param {String} name The name of the test to run
* @param {Array} args The arguments to pass to the test function
* @return {Boolean} True or false if the test passed/failed.
*/ test: function(cat, name, args) {
args = args || [];
var result, ua, test, cat_o = feature_tests[cat], feature = cat_o && cat_o[name];
return feature && (result = feature.result, Y.Lang.isUndefined(result) && ((ua = feature.ua) && (result = Y.UA[ua]), (test = feature.test) && (!ua || result) && (result = test.apply(Y, args)), feature.result = result)), result;
}
});
// Y.Features.add("load", "1", {});
// Y.Features.test("load", "1");
// caps=1:1;2:0;3:1;
/* This file is auto-generated by (yogi.js loader --mix --yes) */ /*jshint maxlen:900, eqeqeq: false */ var add = Y.Features.add;
// app-transitions-native
add("load", "0", {
name: "app-transitions-native",
test: function(Y) {
var doc = Y.config.doc, node = doc ? doc.documentElement : null;
return !!node && !!node.style && ("MozTransition" in node.style || "WebkitTransition" in node.style || "transition" in node.style);
},
trigger: "app-transitions"
}), // autocomplete-list-keys
add("load", "1", {
name: "autocomplete-list-keys",
test: function(Y) {
// Only add keyboard support to autocomplete-list if this doesn't appear to
// be an iOS or Android-based mobile device.
//
// There's currently no feasible way to actually detect whether a device has
// a hardware keyboard, so this sniff will have to do. It can easily be
// overridden by manually loading the autocomplete-list-keys module.
//
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
// doesn't fire the keyboard events used by AutoCompleteList, so there's
// no point loading the -keys module even when a bluetooth keyboard may be
// available.
return !(Y.UA.ios || Y.UA.android);
},
trigger: "autocomplete-list"
}), // dd-gestures
add("load", "2", {
name: "dd-gestures",
trigger: "dd-drag",
ua: "touchEnabled"
}), // dom-style-ie
add("load", "3", {
name: "dom-style-ie",
test: function(Y) {
var testFeature = Y.Features.test, addFeature = Y.Features.add, WINDOW = Y.config.win, DOCUMENT = Y.config.doc, ret = !1;
return addFeature("style", "computedStyle", {
test: function() {
return WINDOW && "getComputedStyle" in WINDOW;
}
}), addFeature("style", "opacity", {
test: function() {
return DOCUMENT && "opacity" in DOCUMENT.documentElement.style;
}
}), !testFeature("style", "opacity") && !testFeature("style", "computedStyle");
},
trigger: "dom-style"
}), // editor-para-ie
add("load", "4", {
name: "editor-para-ie",
trigger: "editor-para",
ua: "ie",
when: "instead"
}), // event-base-ie
add("load", "5", {
name: "event-base-ie",
test: function(Y) {
var imp = Y.config.doc && Y.config.doc.implementation;
return imp && !imp.hasFeature("Events", "2.0");
},
trigger: "node-base"
}), // graphics-canvas
add("load", "6", {
name: "graphics-canvas",
test: function(Y) {
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
},
trigger: "graphics"
}), // graphics-canvas-default
add("load", "7", {
name: "graphics-canvas-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
},
trigger: "graphics"
}), // graphics-svg
add("load", "8", {
name: "graphics-svg",
test: function(Y) {
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (useSVG || !canvas);
},
trigger: "graphics"
}), // graphics-svg-default
add("load", "9", {
name: "graphics-svg-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (useSVG || !canvas);
},
trigger: "graphics"
}), // graphics-vml
add("load", "10", {
name: "graphics-vml",
test: function(Y) {
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
},
trigger: "graphics"
}), // graphics-vml-default
add("load", "11", {
name: "graphics-vml-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
},
trigger: "graphics"
}), // history-hash-ie
add("load", "12", {
name: "history-hash-ie",
test: function(Y) {
var docMode = Y.config.doc && Y.config.doc.documentMode;
return Y.UA.ie && (!("onhashchange" in Y.config.win) || !docMode || docMode < 8);
},
trigger: "history-hash"
}), // io-nodejs
add("load", "13", {
name: "io-nodejs",
trigger: "io-base",
ua: "nodejs"
}), // json-parse-shim
add("load", "14", {
name: "json-parse-shim",
test: function(Y) {
var _JSON = Y.config.global.JSON, Native = "[object JSON]" === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONParse && !!Native;
// Double check basic functionality. This is mainly to catch early broken
// implementations of the JSON API in Firefox 3.1 beta1 and beta2
if (nativeSupport) try {
nativeSupport = Native.parse('{"ok":false}', function(k, v) {
return "ok" === k || v;
}).ok;
} catch (e) {
nativeSupport = !1;
}
return !nativeSupport;
},
trigger: "json-parse"
}), // json-stringify-shim
add("load", "15", {
name: "json-stringify-shim",
test: function(Y) {
var _JSON = Y.config.global.JSON, Native = "[object JSON]" === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONStringify && !!Native;
// Double check basic native functionality. This is primarily to catch broken
// early JSON API implementations in Firefox 3.1 beta1 and beta2.
if (nativeSupport) try {
nativeSupport = "0" === Native.stringify(0);
} catch (e) {
nativeSupport = !1;
}
return !nativeSupport;
},
trigger: "json-stringify"
}), // scrollview-base-ie
add("load", "16", {
name: "scrollview-base-ie",
trigger: "scrollview-base",
ua: "ie"
}), // selector-css2
add("load", "17", {
name: "selector-css2",
test: function(Y) {
var DOCUMENT = Y.config.doc;
return DOCUMENT && !("querySelectorAll" in DOCUMENT);
},
trigger: "selector"
}), // transition-timer
add("load", "18", {
name: "transition-timer",
test: function(Y) {
var DOCUMENT = Y.config.doc, node = DOCUMENT ? DOCUMENT.documentElement : null, ret = !0;
return node && node.style && (ret = !("MozTransition" in node.style || "WebkitTransition" in node.style || "transition" in node.style)), ret;
},
trigger: "transition"
}), // widget-base-ie
add("load", "19", {
name: "widget-base-ie",
trigger: "widget-base",
ua: "ie"
}), // yql-jsonp
add("load", "20", {
name: "yql-jsonp",
test: function(Y) {
/* Only load the JSONP module when not in nodejs or winjs
TODO Make the winjs module a CORS module
*/ return !Y.UA.nodejs && !Y.UA.winjs;
},
trigger: "yql",
when: "after"
}), // yql-nodejs
add("load", "21", {
name: "yql-nodejs",
trigger: "yql",
ua: "nodejs",
when: "after"
}), // yql-winjs
add("load", "22", {
name: "yql-winjs",
trigger: "yql",
ua: "winjs",
when: "after"
});
}, "3.12.0", {
requires: [
"yui-base"
]
}), YUI.add("intl-base", function(Y, NAME) {
/**
* The Intl utility provides a central location for managing sets of
* localized resources (strings and formatting patterns).
*
* @class Intl
* @uses EventTarget
* @static
*/ var SPLIT_REGEX = /[, ]/;
Y.mix(Y.namespace("Intl"), {
/**
* Returns the language among those available that
* best matches the preferred language list, using the Lookup
* algorithm of BCP 47.
* If none of the available languages meets the user's preferences,
* then "" is returned.
* Extended language ranges are not supported.
*
* @method lookupBestLang
* @param {String[] | String} preferredLanguages The list of preferred
* languages in descending preference order, represented as BCP 47
* language tags. A string array or a comma-separated list.
* @param {String[]} availableLanguages The list of languages
* that the application supports, represented as BCP 47 language
* tags.
*
* @return {String} The available language that best matches the
* preferred language list, or "".
* @since 3.1.0
*/ lookupBestLang: function(preferredLanguages, availableLanguages) {
var i, language, result, index;
for(Y.Lang.isString(preferredLanguages) && (preferredLanguages = preferredLanguages.split(SPLIT_REGEX)), i = 0; i < preferredLanguages.length; i += 1)if ((language = preferredLanguages[i]) && "*" !== language) // check the fallback sequence for one language
for(; language.length > 0;){
if (result = // check whether the list of available languages contains language;
// if so return it
function(language) {
var i;
for(i = 0; i < availableLanguages.length; i += 1)if (language.toLowerCase() === availableLanguages[i].toLowerCase()) return availableLanguages[i];
}(language)) return result;
if ((index = language.lastIndexOf("-")) >= 0) language = language.substring(0, index), index >= 2 && "-" === language.charAt(index - 2) && (language = language.substring(0, index - 2));
else break;
}
return "";
}
});
}, "3.12.0", {
requires: [
"yui-base"
]
}), YUI.add("yui-log", function(Y, NAME) {
/**
* Provides console log capability and exposes a custom event for
* console implementations. This module is a `core` YUI module,
* <a href="../classes/YUI.html#method_log">it's documentation is located under the YUI class</a>.
*
* @module yui
* @submodule yui-log
*/ var LOGEVENT = "yui:log", UNDEFINED = "undefined", LEVELS = {
debug: 1,
info: 2,
warn: 4,
error: 8
};
/**
* If the 'debug' config is true, a 'yui:log' event will be
* dispatched, which the Console widget and anything else
* can consume. If the 'useBrowserConsole' config is true, it will
* write to the browser console if available. YUI-specific log
* messages will only be present in the -debug versions of the
* JS files. The build system is supposed to remove log statements
* from the raw and minified versions of the files.
*
* @method log
* @for YUI
* @param {String} msg The message to log.
* @param {String} cat The log category for the message. Default
* categories are "info", "warn", "error", time".
* Custom categories can be used as well. (opt).
* @param {String} src The source of the the message (opt).
* @param {boolean} silent If true, the log event won't fire.
* @return {YUI} YUI instance.
*/ Y.log = function(msg, cat, src, silent) {
var bail, excl, incl, m, f, minlevel, c = Y.config, publisher = Y.fire ? Y : YUI.Env.globalEvents;
return c.debug && (void 0 !== // apply source filters
(src = src || "") && (excl = c.logExclude, !(incl = c.logInclude) || src in incl ? incl && src in incl ? bail = !incl[src] : excl && src in excl && (bail = excl[src]) : bail = 1, // Determine the current minlevel as defined in configuration
Y.config.logLevel = Y.config.logLevel || "debug", minlevel = LEVELS[Y.config.logLevel.toLowerCase()], cat in LEVELS && LEVELS[cat] < minlevel && // Skip this message if the we don't meet the defined minlevel
(bail = 1)), bail || (c.useBrowserConsole && (m = src ? src + ": " + msg : msg, Y.Lang.isFunction(c.logFn) ? c.logFn.call(Y, msg, cat, src) : typeof console !== UNDEFINED && console.log ? (f = cat && console[cat] && cat in LEVELS ? cat : "log", console[f](m)) : typeof opera !== UNDEFINED && opera.postError(m)), publisher && !silent && (publisher !== Y || publisher.getEvent(LOGEVENT) || publisher.publish(LOGEVENT, {
broadcast: 2
}), publisher.fire(LOGEVENT, {
msg: msg,
cat: cat,
src: src
})))), Y;
}, /**
* Write a system message. This message will be preserved in the
* minified and raw versions of the YUI files, unlike log statements.
* @method message
* @for YUI
* @param {String} msg The message to log.
* @param {String} cat The log category for the message. Default
* categories are "info", "warn", "error", time".
* Custom categories can be used as well. (opt).
* @param {String} src The source of the the message (opt).
* @param {boolean} silent If true, the log event won't fire.
* @return {YUI} YUI instance.
*/ Y.message = function() {
return Y.log.apply(Y, arguments);
};
}, "3.12.0", {
requires: [
"yui-base"
]
}), YUI.add("yui-later", function(Y, NAME) {
/**
* Provides a setTimeout/setInterval wrapper. This module is a `core` YUI module,
* <a href="../classes/YUI.html#method_later">it's documentation is located under the YUI class</a>.
*
* @module yui
* @submodule yui-later
*/ var NO_ARGS = [];
/**
* Executes the supplied function in the context of the supplied
* object 'when' milliseconds later. Executes the function a
* single time unless periodic is set to true.
* @for YUI
* @method later
* @param when {int} the number of milliseconds to wait until the fn
* is executed.
* @param o the context object.
* @param fn {Function|String} the function to execute or the name of
* the method in the 'o' object to execute.
* @param data [Array] data that is provided to the function. This
* accepts either a single item or an array. If an array is provided,
* the function is executed with one parameter for each array item.
* If you need to pass a single array parameter, it needs to be wrapped
* in an array [myarray].
*
* Note: native methods in IE may not have the call and apply methods.
* In this case, it will work, but you are limited to four arguments.
*
* @param periodic {boolean} if true, executes continuously at supplied
* interval until canceled.
* @return {object} a timer object. Call the cancel() method on this
* object to stop the timer.
*/ Y.later = function(when, o, fn, data, periodic) {
when = when || 0, data = Y.Lang.isUndefined(data) ? NO_ARGS : Y.Array(data);
var cancelled = !1, method = (o = o || Y.config.win || Y) && Y.Lang.isString(fn) ? o[fn] : fn, wrapper = function() {
// IE 8- may execute a setInterval callback one last time
// after clearInterval was called, so in order to preserve
// the cancel() === no more runny-run, we have to jump through
// an extra hoop.
cancelled || (method.apply ? method.apply(o, data || NO_ARGS) : method(data[0], data[1], data[2], data[3]));
}, id = periodic ? setInterval(wrapper, when) : setTimeout(wrapper, when);
return {
id: id,
interval: periodic,
cancel: function() {
cancelled = !0, this.interval ? clearInterval(id) : clearTimeout(id);
}
};
}, Y.Lang.later = Y.later;
}, "3.12.0", {
requires: [
"yui-base"
]
}), YUI.add("loader-base", function(Y, NAME) {
VERSION = Y.version, BUILD = "/build/", COMBO_BASE = (CDN_BASE = Y.Env.base) + "combo?", groups = (META = {
version: VERSION,
root: VERSION + "/",
base: Y.Env.base,
comboBase: COMBO_BASE,
skin: {
defaultSkin: "sam",
base: "assets/skins/",
path: "skin.css",
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssbase",
"cssreset-context",
"cssfonts-context"
]
},
groups: {},
patterns: {}
}).groups, yui2Update = function(tnt, yui2, config) {
var root = "2in3." + (tnt || "4") + "/" + (yui2 || "2.9.0") + BUILD, base = config && config.base ? config.base : CDN_BASE, combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
groups.yui2.base = base + root, groups.yui2.root = root, groups.yui2.comboBase = combo;
}, galleryUpdate = function(tag, config) {
var root = (tag || "gallery-2013.08.22-21-03") + BUILD, base = config && config.base ? config.base : CDN_BASE, combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
groups.gallery.base = base + root, groups.gallery.root = root, groups.gallery.comboBase = combo;
}, groups[VERSION] = {}, groups.gallery = {
ext: !1,
combine: !0,
comboBase: COMBO_BASE,
update: galleryUpdate,
patterns: {
"gallery-": {},
"lang/gallery-": {},
"gallerycss-": {
type: "css"
}
}
}, groups.yui2 = {
combine: !0,
ext: !1,
comboBase: COMBO_BASE,
update: yui2Update,
patterns: {
"yui2-": {
configFn: function(me) {
/-skin|reset|fonts|grids|base/.test(me.name) && (me.type = "css", me.path = me.path.replace(/\.js/, ".css"), // this makes skins in builds earlier than
// 2.6.0 work as long as combine is false
me.path = me.path.replace(/\/yui2-skin/, "/assets/skins/sam/yui2-skin"));
}
}
}
}, galleryUpdate(), yui2Update(), YUI.Env[VERSION] && Y.mix(META, YUI.Env[VERSION], !1, [
"modules",
"groups",
"skin"
], 0, !0), YUI.Env[VERSION] = META;
/*jslint forin: true, maxlen: 350 */ /**
* Loader dynamically loads script and css files. It includes the dependency
* information for the version of the library in use, and will automatically pull in
* dependencies for the modules requested. It can also load the
* files from the Yahoo! CDN, and it can utilize the combo service provided on
* this network to reduce the number of http connections required to download
* YUI files.
*
* @module loader
* @main loader
* @submodule loader-base
*/ var VERSION, BUILD, CDN_BASE, COMBO_BASE, META, groups, yui2Update, galleryUpdate, NOT_FOUND = {}, NO_REQUIREMENTS = [], GLOBAL_ENV = YUI.Env, GLOBAL_LOADED = GLOBAL_ENV._loaded, INTL = "intl", VERSION1 = Y.version, YObject = Y.Object, oeach = YObject.each, yArray = Y.Array, _queue = GLOBAL_ENV._loaderQueue, META1 = GLOBAL_ENV[VERSION1], L = Y.Lang, ON_PAGE = GLOBAL_ENV.mods, _path = function(dir, file, type, nomin) {
var path = dir + "/" + file;
return nomin || (path += "-min"), path += "." + (type || "css");
};
YUI.Env._cssLoaded || (YUI.Env._cssLoaded = {}), /**
* The component metadata is stored in Y.Env.meta.
* Part of the loader module.
* @property meta
* @for YUI
*/ Y.Env.meta = META1, /**
* Loader dynamically loads script and css files. It includes the dependency
* info for the version of the library in use, and will automatically pull in
* dependencies for the modules requested. It can load the
* files from the Yahoo! CDN, and it can utilize the combo service provided on
* this network to reduce the number of http connections required to download
* YUI files. You can also specify an external, custom combo service to host
* your modules as well.
var Y = YUI();
var loader = new Y.Loader({
filter: 'debug',
base: '../../',
root: 'build/',
combine: true,
require: ['node', 'dd', 'console']
});
var out = loader.resolve(true);
* @constructor
* @class Loader
* @param {Object} config an optional set of configuration options.
* @param {String} config.base The base dir which to fetch this module from
* @param {String} config.comboBase The Combo service base path. Ex: `http://yui.yahooapis.com/combo?`
* @param {String} config.root The root path to prepend to module names for the combo service. Ex: `2.5.2/build/`
* @param {String|Object} config.filter A filter to apply to result urls. <a href="#property_filter">See filter property</a>
* @param {Object} config.filters Per-component filter specification. If specified for a given component, this overrides the filter config.
* @param {Boolean} config.combine Use a combo service to reduce the number of http connections required to load your dependencies
* @param {Boolean} [config.async=true] Fetch files in async
* @param {Array} config.ignore: A list of modules that should never be dynamically loaded
* @param {Array} config.force A list of modules that should always be loaded when required, even if already present on the page
* @param {HTMLElement|String} config.insertBefore Node or id for a node that should be used as the insertion point for new nodes
* @param {Object} config.jsAttributes Object literal containing attributes to add to script nodes
* @param {Object} config.cssAttributes Object literal containing attributes to add to link nodes
* @param {Number} config.timeout The number of milliseconds before a timeout occurs when dynamically loading nodes. If not set, there is no timeout
* @param {Object} config.context Execution context for all callbacks
* @param {Function} config.onSuccess Callback for the 'success' event
* @param {Function} config.onFailure Callback for the 'failure' event
* @param {Function} config.onCSS Callback for the 'CSSComplete' event. When loading YUI components with CSS the CSS is loaded first, then the script. This provides a moment you can tie into to improve the presentation of the page while the script is loading.
* @param {Function} config.onTimeout Callback for the 'timeout' event
* @param {Function} config.onProgress Callback executed each time a script or css file is loaded
* @param {Object} config.modules A list of module definitions. See <a href="#method_addModule">Loader.addModule</a> for the supported module metadata
* @param {Object} config.groups A list of group definitions. Each group can contain specific definitions for `base`, `comboBase`, `combine`, and accepts a list of `modules`.
* @param {String} config.2in3 The version of the YUI 2 in 3 wrapper to use. The intrinsic support for YUI 2 modules in YUI 3 relies on versions of the YUI 2 components inside YUI 3 module wrappers. These wrappers change over time to accomodate the issues that arise from running YUI 2 in a YUI 3 sandbox.
* @param {String} config.yui2 When using the 2in3 project, you can select the version of YUI 2 to use. Valid values are `2.2.2`, `2.3.1`, `2.4.1`, `2.5.2`, `2.6.0`, `2.7.0`, `2.8.0`, `2.8.1` and `2.9.0` [default] -- plus all versions of YUI 2 going forward.
*/ Y.Loader = function(o) {
//Catch no config passed.
o = o || {}, META1.md5, /**
* Internal callback to handle multiple internal insert() calls
* so that css is inserted prior to js
* @property _internalCallback
* @private
*/ // self._internalCallback = null;
/**
* Callback that will be executed when the loader is finished
* with an insert
* @method onSuccess
* @type function
*/ // self.onSuccess = null;
/**
* Callback that will be executed if there is a failure
* @method onFailure
* @type function
*/ // self.onFailure = null;
/**
* Callback for the 'CSSComplete' event. When loading YUI components
* with CSS the CSS is loaded first, then the script. This provides
* a moment you can tie into to improve the presentation of the page
* while the script is loading.
* @method onCSS
* @type function
*/ // self.onCSS = null;
/**
* Callback executed each time a script or css file is loaded
* @method onProgress
* @type function
*/ // self.onProgress = null;
/**
* Callback that will be executed if a timeout occurs
* @method onTimeout
* @type function
*/ // self.onTimeout = null;
/**
* The execution context for all callbacks
* @property context
* @default {YUI} the YUI instance
*/ this.context = Y, /**
* Data that is passed to all callbacks
* @property data
*/ // self.data = null;
/**
* Node reference or id where new nodes should be inserted before
* @property insertBefore
* @type string|HTMLElement
*/ // self.insertBefore = null;
/**
* The charset attribute for inserted nodes
* @property charset
* @type string
* @deprecated , use cssAttributes or jsAttributes.
*/ // self.charset = null;
/**
* An object literal containing attributes to add to link nodes
* @property cssAttributes
* @type object
*/ // self.cssAttributes = null;
/**
* An object literal containing attributes to add to script nodes
* @property jsAttributes
* @type object
*/ // self.jsAttributes = null;
/**
* The base directory.
* @property base
* @type string
* @default http://yui.yahooapis.com/[YUI VERSION]/build/
*/ this.base = Y.Env.meta.base + Y.Env.meta.root, /**
* Base path for the combo service
* @property comboBase
* @type string
* @default http://yui.yahooapis.com/combo?
*/ this.comboBase = Y.Env.meta.comboBase, /*
* Base path for language packs.
*/ // self.langBase = Y.Env.meta.langBase;
// self.lang = "";
/**
* If configured, the loader will attempt to use the combo
* service for YUI resources and configured external resources.
* @property combine
* @type boolean
* @default true if a base dir isn't in the config
*/ this.combine = o.base && o.base.indexOf(this.comboBase.substr(0, 20)) > -1, /**
* The default seperator to use between files in a combo URL
* @property comboSep
* @type {String}
* @default Ampersand
*/ this.comboSep = "&", /**
* Max url length for combo urls. The default is 1024. This is the URL
* limit for the Yahoo! hosted combo servers. If consuming
* a different combo service that has a different URL limit
* it is possible to override this default by supplying
* the maxURLLength config option. The config option will
* only take effect if lower than the default.
*
* @property maxURLLength
* @type int
*/ this.maxURLLength = 1024, /**
* Ignore modules registered on the YUI global
* @property ignoreRegistered
* @default false
*/ this.ignoreRegistered = o.ignoreRegistered, /**
* Root path to prepend to module path for the combo
* service
* @property root
* @type string
* @default [YUI VERSION]/build/
*/ this.root = Y.Env.meta.root, /**
* Timeout value in milliseconds. If set, self value will be used by
* the get utility. the timeout event will fire if
* a timeout occurs.
* @property timeout
* @type int
*/ this.timeout = 0, /**
* A list of modules that should not be loaded, even if
* they turn up in the dependency tree
* @property ignore
* @type string[]
*/ // self.ignore = null;
/**
* A list of modules that should always be loaded, even
* if they have already been inserted into the page.
* @property force
* @type string[]
*/ // self.force = null;
this.forceMap = {}, /**
* Should we allow rollups
* @property allowRollup
* @type boolean
* @default false
*/ this.allowRollup = !1, /**
* A filter to apply to result urls. This filter will modify the default
* path for all modules. The default path for the YUI library is the
* minified version of the files (e.g., event-min.js). The filter property
* can be a predefined filter or a custom filter. The valid predefined
* filters are:
* <dl>
* <dt>DEBUG</dt>
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
* This option will automatically include the Logger widget</dd>
* <dt>RAW</dt>
* <dd>Selects the non-minified version of the library (e.g., event.js).
* </dd>
* </dl>
* You can also define a custom filter, which must be an object literal
* containing a search expression and a replace string:
*
* myFilter: {
* 'searchExp': "-min\\.js",
* 'replaceStr': "-debug.js"
* }
*
* @property filter
* @type string| {searchExp: string, replaceStr: string}
*/ // self.filter = null;
/**
* per-component filter specification. If specified for a given
* component, this overrides the filter config.
* @property filters
* @type object
*/ this.filters = {}, /**
* The list of requested modules
* @property required
* @type {string: boolean}
*/ this.required = {}, /**
* If a module name is predefined when requested, it is checked againsts
* the patterns provided in this property. If there is a match, the
* module is added with the default configuration.
*
* At the moment only supporting module prefixes, but anticipate
* supporting at least regular expressions.
* @property patterns
* @type Object
*/ // self.patterns = Y.merge(Y.Env.meta.patterns);
this.patterns = {}, /**
* The library metadata
* @property moduleInfo
*/ // self.moduleInfo = Y.merge(Y.Env.meta.moduleInfo);
this.moduleInfo = {}, this.groups = Y.merge(Y.Env.meta.groups), /**
* Provides the information used to skin the skinnable components.
* The following skin definition would result in 'skin1' and 'skin2'
* being loaded for calendar (if calendar was requested), and
* 'sam' for all other skinnable components:
*
* skin: {
* // The default skin, which is automatically applied if not
* // overriden by a component-specific skin definition.
* // Change this in to apply a different skin globally
* defaultSkin: 'sam',
*
* // This is combined with the loader base property to get
* // the default root directory for a skin. ex:
* // http://yui.yahooapis.com/2.3.0/build/assets/skins/sam/
* base: 'assets/skins/',
*
* // Any component-specific overrides can be specified here,
* // making it possible to load different skins for different
* // components. It is possible to load more than one skin
* // for a given component as well.
* overrides: {
* calendar: ['skin1', 'skin2']
* }
* }
* @property skin
* @type {Object}
*/ this.skin = Y.merge(Y.Env.meta.skin), /*
* Map of conditional modules
* @since 3.2.0
*/ this.conditions = {}, // map of modules with a hash of modules that meet the requirement
// self.provides = {};
this.config = o, this._internal = !0, this._populateCache(), /**
* Set when beginning to compute the dependency tree.
* Composed of what YUI reports to be loaded combined
* with what has been loaded by any instance on the page
* with the version number specified in the metadata.
* @property loaded
* @type {string: boolean}
*/ this.loaded = GLOBAL_LOADED[VERSION1], /**
* Should Loader fetch scripts in `async`, defaults to `true`
* @property async
*/ this.async = !0, this._inspectPage(), this._internal = !1, this._config(o), this.forceMap = this.force ? Y.Array.hash(this.force) : {}, this.testresults = null, Y.config.tests && (this.testresults = Y.config.tests), /**
* List of rollup files found in the library metadata
* @property rollups
*/ // self.rollups = null;
/**
* Whether or not to load optional dependencies for
* the requested modules
* @property loadOptional
* @type boolean
* @default false
*/ // self.loadOptional = false;
/**
* All of the derived dependencies in sorted order, which
* will be populated when either calculate() or insert()
* is called
* @property sorted
* @type string[]
*/ this.sorted = [], /*
* A list of modules to attach to the YUI instance when complete.
* If not supplied, the sorted list of dependencies are applied.
* @property attaching
*/ // self.attaching = null;
/**
* Flag to indicate the dependency tree needs to be recomputed
* if insert is called again.
* @property dirty
* @type boolean
* @default true
*/ this.dirty = !0, /**
* List of modules inserted by the utility
* @property inserted
* @type {string: boolean}
*/ this.inserted = {}, /**
* List of skipped modules during insert() because the module
* was not defined
* @property skipped
*/ this.skipped = {}, // Y.on('yui:load', self.loadNext, self);
this.tested = {}, this.ignoreRegistered && //Clear inpage already processed modules.
this._resetModules();
}, Y.Loader.prototype = {
/**
* Checks the cache for modules and conditions, if they do not exist
* process the default metadata and populate the local moduleInfo hash.
* @method _populateCache
* @private
*/ _populateCache: function() {
var i, defaults = META1.modules, cache = GLOBAL_ENV._renderedMods;
if (cache && !this.ignoreRegistered) {
for(i in cache)cache.hasOwnProperty(i) && (this.moduleInfo[i] = Y.merge(cache[i]));
for(i in cache = GLOBAL_ENV._conditions)cache.hasOwnProperty(i) && (this.conditions[i] = Y.merge(cache[i]));
} else for(i in defaults)defaults.hasOwnProperty(i) && this.addModule(defaults[i], i);
},
/**
* Reset modules in the module cache to a pre-processed state so additional
* computations with a different skin or language will work as expected.
* @method _resetModules
* @private
*/ _resetModules: function() {
var i, o, mod, name, details;
for(i in this.moduleInfo)if (this.moduleInfo.hasOwnProperty(i)) {
if (name = (mod = this.moduleInfo[i]).name, (details = YUI.Env.mods[name] ? YUI.Env.mods[name].details : null) && (this.moduleInfo[name]._reset = !0, this.moduleInfo[name].requires = details.requires || [], this.moduleInfo[name].optional = details.optional || [], this.moduleInfo[name].supersedes = details.supercedes || []), mod.defaults) for(o in mod.defaults)mod.defaults.hasOwnProperty(o) && mod[o] && (mod[o] = mod.defaults[o]);
delete mod.langCache, delete mod.skinCache, mod.skinnable && this._addSkin(this.skin.defaultSkin, mod.name);
}
},
/**
Regex that matches a CSS URL. Used to guess the file type when it's not
specified.
@property REGEX_CSS
@type RegExp
@final
@protected
@since 3.5.0
**/ REGEX_CSS: /\.css(?:[?;].*)?$/i,
/**
* Default filters for raw and debug
* @property FILTER_DEFS
* @type Object
* @final
* @protected
*/ FILTER_DEFS: {
RAW: {
searchExp: "-min\\.js",
replaceStr: ".js"
},
DEBUG: {
searchExp: "-min\\.js",
replaceStr: "-debug.js"
},
COVERAGE: {
searchExp: "-min\\.js",
replaceStr: "-coverage.js"
}
},
/*
* Check the pages meta-data and cache the result.
* @method _inspectPage
* @private
*/ _inspectPage: function() {
var v, m, req, mr, i;
//Inspect the page for CSS only modules and mark them as loaded.
for(i in this.moduleInfo)this.moduleInfo.hasOwnProperty(i) && (v = this.moduleInfo[i]).type && "css" === v.type && this.isCSSLoaded(v.name) && (this.loaded[i] = !0);
for(i in ON_PAGE)ON_PAGE.hasOwnProperty(i) && (v = ON_PAGE[i]).details && (m = this.moduleInfo[v.name], req = v.details.requires, mr = m && m.requires, m ? !m._inspected && req && mr.length !== req.length && // console.log('deleting ' + m.name);
delete m.expanded : m = this.addModule(v.details, i), m._inspected = !0);
},
/*
* returns true if b is not loaded, and is required directly or by means of modules it supersedes.
* @private
* @method _requires
* @param {String} mod1 The first module to compare
* @param {String} mod2 The second module to compare
*/ _requires: function(mod1, mod2) {
var i, rm, after_map, s, info = this.moduleInfo, m = info[mod1], other = info[mod2];
if (!m || !other) return !1;
// check if this module should be sorted after the other
// do this first to short circut circular deps
if (rm = m.expanded_map, (after_map = m.after_map) && mod2 in after_map) return !0;
// and vis-versa
if ((after_map = other.after_map) && mod1 in after_map) return !1;
if (// check if this module requires one the other supersedes
s = info[mod2] && info[mod2].supersedes) {
for(i = 0; i < s.length; i++)if (this._requires(mod1, s[i])) return !0;
}
if (s = info[mod1] && info[mod1].supersedes) {
for(i = 0; i < s.length; i++)if (this._requires(mod2, s[i])) return !1;
}
return !!rm && mod2 in rm || !!m.ext && "css" === m.type && !other.ext && "css" === other.type;
},
/**
* Apply a new config to the Loader instance
* @method _config
* @private
* @param {Object} o The new configuration
*/ _config: function(o) {
var i, j, val, a, f, group, mod, self = this, mods = [];
// apply config values
if (o) {
for(i in o)if (o.hasOwnProperty(i)) {
//TODO This should be a case
if (val = o[i], "require" === i) self.require(val);
else if ("skin" === i) "string" == typeof val && (self.skin.defaultSkin = o.skin, val = {
defaultSkin: val
}), Y.mix(self.skin, val, !0);
else if ("groups" === i) {
for(j in val)if (val.hasOwnProperty(j) && (group = val[j], self.addGroup(group, j), group.aliases)) for(a in group.aliases)group.aliases.hasOwnProperty(a) && self.addAlias(group.aliases[a], a);
} else if ("modules" === i) // add a hash of module definitions
for(j in val)val.hasOwnProperty(j) && self.addModule(val[j], j);
else if ("aliases" === i) for(j in val)val.hasOwnProperty(j) && self.addAlias(val[j], j);
else "gallery" === i ? this.groups.gallery.update && this.groups.gallery.update(val, o) : "yui2" === i || "2in3" === i ? this.groups.yui2.update && this.groups.yui2.update(o["2in3"], o.yui2, o) : self[i] = val;
}
}
if (// fix filter
f = self.filter, L.isString(f) && (self.filterName = f = f.toUpperCase(), self.filter = self.FILTER_DEFS[f], "DEBUG" === f && self.require("yui-log", "dump")), self.filterName && self.coverage && "COVERAGE" === self.filterName && L.isArray(self.coverage) && self.coverage.length) {
for(i = 0; i < self.coverage.length; i++)mod = self.coverage[i], self.moduleInfo[mod] && self.moduleInfo[mod].use ? mods = [].concat(mods, self.moduleInfo[mod].use) : mods.push(mod);
self.filters = self.filters || {}, Y.Array.each(mods, function(mod) {
self.filters[mod] = self.FILTER_DEFS.COVERAGE;
}), self.filterName = "RAW", self.filter = self.FILTER_DEFS[self.filterName];
}
},
/**
* Returns the skin module name for the specified skin name. If a
* module name is supplied, the returned skin module name is
* specific to the module passed in.
* @method formatSkin
* @param {string} skin the name of the skin.
* @param {string} mod optional: the name of a module to skin.
* @return {string} the full skin module name.
*/ formatSkin: function(skin, mod) {
var s = "skin-" + skin;
return mod && (s = s + "-" + mod), s;
},
/**
* Adds the skin def to the module info
* @method _addSkin
* @param {string} skin the name of the skin.
* @param {string} mod the name of the module.
* @param {string} parent parent module if this is a skin of a
* submodule or plugin.
* @return {string} the module name for the skin.
* @private
*/ _addSkin: function(skin, mod, parent) {
var mdef, pkg, name, nmod, info = this.moduleInfo, sinf = this.skin, ext = info[mod] && info[mod].ext;
return mod && !info[name = this.formatSkin(skin, mod)] && (pkg = (mdef = info[mod]).pkg || mod, nmod = {
skin: !0,
name: name,
group: mdef.group,
type: "css",
after: sinf.after,
path: (parent || pkg) + "/" + sinf.base + skin + "/" + mod + ".css",
ext: ext
}, mdef.base && (nmod.base = mdef.base), mdef.configFn && (nmod.configFn = mdef.configFn), this.addModule(nmod, name)), name;
},
/**
* Adds an alias module to the system
* @method addAlias
* @param {Array} use An array of modules that makes up this alias
* @param {String} name The name of the alias
* @example
* var loader = new Y.Loader({});
* loader.addAlias([ 'node', 'yql' ], 'davglass');
* loader.require(['davglass']);
* var out = loader.resolve(true);
*
* //out.js will contain Node and YQL modules
*/ addAlias: function(use, name) {
YUI.Env.aliases[name] = use, this.addModule({
name: name,
use: use
});
},
/**
* Add a new module group
* @method addGroup
* @param {Object} config An object containing the group configuration data
* @param {String} config.name required, the group name
* @param {String} config.base The base directory for this module group
* @param {String} config.root The root path to add to each combo resource path
* @param {Boolean} config.combine Should the request be combined
* @param {String} config.comboBase Combo service base path
* @param {Object} config.modules The group of modules
* @param {String} name the group name.
* @example
* var loader = new Y.Loader({});
* loader.addGroup({
* name: 'davglass',
* combine: true,
* comboBase: '/combo?',
* root: '',
* modules: {
* //Module List here
* }
* }, 'davglass');
*/ addGroup: function(o, name) {
var i, v, mods = o.modules;
if (name = name || o.name, o.name = name, this.groups[name] = o, o.patterns) for(i in o.patterns)o.patterns.hasOwnProperty(i) && (o.patterns[i].group = name, this.patterns[i] = o.patterns[i]);
if (mods) for(i in mods)mods.hasOwnProperty(i) && ("string" == typeof (v = mods[i]) && (v = {
name: i,
fullpath: v
}), v.group = name, this.addModule(v, i));
},
/**
* Add a new module to the component metadata.
* @method addModule
* @param {Object} config An object containing the module data.
* @param {String} config.name Required, the component name
* @param {String} config.type Required, the component type (js or css)
* @param {String} config.path Required, the path to the script from `base`
* @param {Array} config.requires Array of modules required by this component
* @param {Array} [config.optional] Array of optional modules for this component
* @param {Array} [config.supersedes] Array of the modules this component replaces
* @param {Array} [config.after] Array of modules the components which, if present, should be sorted above this one
* @param {Object} [config.after_map] Faster alternative to 'after' -- supply a hash instead of an array
* @param {Number} [config.rollup] The number of superseded modules required for automatic rollup
* @param {String} [config.fullpath] If `fullpath` is specified, this is used instead of the configured `base + path`
* @param {Boolean} [config.skinnable] Flag to determine if skin assets should automatically be pulled in
* @param {Object} [config.submodules] Hash of submodules
* @param {String} [config.group] The group the module belongs to -- this is set automatically when it is added as part of a group configuration.
* @param {Array} [config.lang] Array of BCP 47 language tags of languages for which this module has localized resource bundles, e.g., `["en-GB", "zh-Hans-CN"]`
* @param {Object} [config.condition] Specifies that the module should be loaded automatically if a condition is met. This is an object with up to four fields:
* @param {String} [config.condition.trigger] The name of a module that can trigger the auto-load
* @param {Function} [config.condition.test] A function that returns true when the module is to be loaded.
* @param {String} [config.condition.ua] The UA name of <a href="UA.html">Y.UA</a> object that returns true when the module is to be loaded. e.g., `"ie"`, `"nodejs"`.
* @param {String} [config.condition.when] Specifies the load order of the conditional module
* with regard to the position of the trigger module.
* This should be one of three values: `before`, `after`, or `instead`. The default is `after`.
* @param {Object} [config.testresults] A hash of test results from `Y.Features.all()`
* @param {Function} [config.configFn] A function to exectute when configuring this module
* @param {Object} config.configFn.mod The module config, modifying this object will modify it's config. Returning false will delete the module's config.
* @param {String} [name] The module name, required if not in the module data.
* @return {Object} the module definition or null if the object passed in did not provide all required attributes.
*/ addModule: function(o, name) {
name = name || o.name, "string" == typeof o && (o = {
name: name,
fullpath: o
});
var subs, i, l, t, sup, s, smod, plugins, plug, j, langs, packName, supName, flatSup, flatLang, lang, overrides, skinname, when, g, p, trigger, conditions = this.conditions;
if (this.moduleInfo[name] && this.moduleInfo[name].temp && //This catches temp modules loaded via a pattern
// The module will be added twice, once from the pattern and
// Once from the actual add call, this ensures that properties
// that were added to the module the first time around (group: gallery)
// are also added the second time around too.
(o = Y.merge(this.moduleInfo[name], o)), o.name = name, !o || !o.name) return null;
/*
Only allowing the cascade of requires information, since
optional and supersedes are far more fine grained than
a blanket requires is.
*/ if (!o.type && (//Always assume it's javascript unless the CSS pattern is matched.
o.type = "js", (p = o.path || o.fullpath) && this.REGEX_CSS.test(p) && (o.type = "css")), o.path || o.fullpath || (o.path = _path(name, name, o.type)), o.supersedes = o.supersedes || o.use, o.ext = "ext" in o ? o.ext : !this._internal, // Handle submodule logic
subs = o.submodules, this.moduleInfo[name] = o, o.requires = o.requires || [], this.requires) for(i = 0; i < this.requires.length; i++)o.requires.push(this.requires[i]);
if (o.group && this.groups && this.groups[o.group] && (g = this.groups[o.group]).requires) for(i = 0; i < g.requires.length; i++)o.requires.push(g.requires[i]);
if (o.defaults || (o.defaults = {
requires: o.requires ? [].concat(o.requires) : null,
supersedes: o.supersedes ? [].concat(o.supersedes) : null,
optional: o.optional ? [].concat(o.optional) : null
}), o.skinnable && o.ext && o.temp && (skinname = this._addSkin(this.skin.defaultSkin, name), o.requires.unshift(skinname)), o.requires.length && (o.requires = this.filterRequires(o.requires) || []), !o.langPack && o.lang) for(j = 0, langs = yArray(o.lang); j < langs.length; j++)lang = langs[j], packName = this.getLangPackName(lang, name), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName));
if (subs) {
for(i in sup = o.supersedes || [], l = 0, subs)if (subs.hasOwnProperty(i)) {
if ((s = subs[i]).path = s.path || _path(name, i, o.type), s.pkg = name, s.group = o.group, s.supersedes && (sup = sup.concat(s.supersedes)), smod = this.addModule(s, i), sup.push(i), smod.skinnable) {
if (o.skinnable = !0, (overrides = this.skin.overrides) && overrides[i]) for(j = 0; j < overrides[i].length; j++)skinname = this._addSkin(overrides[i][j], i, name), sup.push(skinname);
skinname = this._addSkin(this.skin.defaultSkin, i, name), sup.push(skinname);
}
// looks like we are expected to work out the metadata
// for the parent module language packs from what is
// specified in the child modules.
if (s.lang && s.lang.length) for(j = 0, langs = yArray(s.lang); j < langs.length; j++)lang = langs[j], packName = this.getLangPackName(lang, name), supName = this.getLangPackName(lang, i), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName)), supName in (flatSup = flatSup || yArray.hash(smod.supersedes)) || smod.supersedes.push(supName), o.lang = o.lang || [], lang in (flatLang = flatLang || yArray.hash(o.lang)) || o.lang.push(lang), // Add rollup file, need to add to supersedes list too
// default packages
packName = this.getLangPackName("", name), supName = this.getLangPackName("", i), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName)), supName in flatSup || smod.supersedes.push(supName);
l++;
}
//o.supersedes = YObject.keys(yArray.hash(sup));
o.supersedes = yArray.dedupe(sup), this.allowRollup && (o.rollup = l < 4 ? l : Math.min(l - 1, 4));
}
if (plugins = o.plugins) for(i in plugins)plugins.hasOwnProperty(i) && ((plug = plugins[i]).pkg = name, plug.path = plug.path || _path(name, i, o.type), plug.requires = plug.requires || [], plug.group = o.group, this.addModule(plug, i), o.skinnable && this._addSkin(this.skin.defaultSkin, i, name));
if (o.condition) for(t = o.condition.trigger, YUI.Env.aliases[t] && (t = YUI.Env.aliases[t]), Y.Lang.isArray(t) || (t = [
t
]), i = 0; i < t.length; i++)trigger = t[i], when = o.condition.when, conditions[trigger] = conditions[trigger] || {}, conditions[trigger][name] = o.condition, when && "after" !== when ? "instead" === when && (// replace the trigger
o.supersedes = o.supersedes || [], o.supersedes.push(trigger)) : (// after the trigger
o.after = o.after || [], o.after.push(trigger));
return o.supersedes && (o.supersedes = this.filterRequires(o.supersedes)), o.after && (o.after = this.filterRequires(o.after), o.after_map = yArray.hash(o.after)), o.configFn && !1 === o.configFn(o) && (delete this.moduleInfo[name], delete GLOBAL_ENV._renderedMods[name], o = null), o && (GLOBAL_ENV._renderedMods || (GLOBAL_ENV._renderedMods = {}), GLOBAL_ENV._renderedMods[name] = Y.mix(GLOBAL_ENV._renderedMods[name] || {}, o), GLOBAL_ENV._conditions = conditions), o;
},
/**
* Add a requirement for one or more module
* @method require
* @param {string[] | string*} what the modules to load.
*/ require: function(what) {
var a = "string" == typeof what ? yArray(arguments) : what;
this.dirty = !0, this.required = Y.merge(this.required, yArray.hash(this.filterRequires(a))), this._explodeRollups();
},
/**
* Grab all the items that were asked for, check to see if the Loader
* meta-data contains a "use" array. If it doesm remove the asked item and replace it with
* the content of the "use".
* This will make asking for: "dd"
* Actually ask for: "dd-ddm-base,dd-ddm,dd-ddm-drop,dd-drag,dd-proxy,dd-constrain,dd-drop,dd-scroll,dd-drop-plugin"
* @private
* @method _explodeRollups
*/ _explodeRollups: function() {
var m, m2, i, a, v, len, len2, r = this.required;
if (!this.allowRollup) {
for(i in r)if (r.hasOwnProperty(i) && (m = this.getModule(i)) && m.use) for(a = 0, len = m.use.length; a < len; a++)if ((m2 = this.getModule(m.use[a])) && m2.use) for(v = 0, len2 = m2.use.length; v < len2; v++)r[m2.use[v]] = !0;
else r[m.use[a]] = !0;
this.required = r;
}
},
/**
* Explodes the required array to remove aliases and replace them with real modules
* @method filterRequires
* @param {Array} r The original requires array
* @return {Array} The new array of exploded requirements
*/ filterRequires: function(r) {
if (r) {
Y.Lang.isArray(r) || (r = [
r
]), r = Y.Array(r);
var i, mod, o, m, c = [];
for(i = 0; i < r.length; i++)if ((mod = this.getModule(r[i])) && mod.use) for(o = 0; o < mod.use.length; o++)//Must walk the other modules in case a module is a rollup of rollups (datatype)
(m = this.getModule(mod.use[o])) && m.use && m.name !== mod.name ? c = Y.Array.dedupe([].concat(c, this.filterRequires(m.use))) : c.push(mod.use[o]);
else c.push(r[i]);
r = c;
}
return r;
},
/**
* Returns an object containing properties for all modules required
* in order to load the requested module
* @method getRequires
* @param {object} mod The module definition from moduleInfo.
* @return {array} the expanded requirement list.
*/ getRequires: function(mod) {
if (!mod) //console.log('returning no reqs for ' + mod.name);
return NO_REQUIREMENTS;
if (mod._parsed) //console.log('returning requires for ' + mod.name, mod.requires);
return mod.expanded || NO_REQUIREMENTS;
//TODO add modue cache here out of scope..
var i, m, j, add, packName, lang, cond, d, def, r, old_mod, o, skinmod, skindef, skinpar, skinname, hash, reparse, testresults = this.testresults, name = mod.name, adddef = ON_PAGE[name] && ON_PAGE[name].details, intl = mod.lang || mod.intl, info = this.moduleInfo, ftests = Y.Features && Y.Features.tests.load;
if (mod.temp && adddef && (old_mod = mod, (mod = this.addModule(adddef, name)).group = old_mod.group, mod.pkg = old_mod.pkg, delete mod.expanded), // console.log('cache: ' + mod.langCache + ' == ' + this.lang);
//If a skin or a lang is different, reparse..
reparse = !((!this.lang || mod.langCache === this.lang) && mod.skinCache === this.skin.defaultSkin), mod.expanded && !reparse) return mod.expanded;
for(d = [], hash = {}, r = this.filterRequires(mod.requires), mod.lang && (//If a module has a lang attribute, auto add the intl requirement.
d.unshift("intl"), r.unshift("intl"), intl = !0), o = this.filterRequires(mod.optional), mod._parsed = !0, mod.langCache = this.lang, mod.skinCache = this.skin.defaultSkin, i = 0; i < r.length; i++)if (!hash[r[i]] && (d.push(r[i]), hash[r[i]] = !0, m = this.getModule(r[i]))) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
if (// get the requirements from superseded modules, if any
r = this.filterRequires(mod.supersedes)) {
for(i = 0; i < r.length; i++)if (!hash[r[i]] && (mod.submodules && d.push(r[i]), hash[r[i]] = !0, m = this.getModule(r[i]))) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
}
if (o && this.loadOptional) {
for(i = 0; i < o.length; i++)if (!hash[o[i]] && (d.push(o[i]), hash[o[i]] = !0, m = info[o[i]])) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
}
if (cond = this.conditions[name]) {
if (//Set the module to not parsed since we have conditionals and this could change the dependency tree.
mod._parsed = !1, testresults && ftests) oeach(testresults, function(result, id) {
var condmod = ftests[id].name;
!hash[condmod] && ftests[id].trigger === name && result && ftests[id] && (hash[condmod] = !0, d.push(condmod));
});
else for(i in cond)if (cond.hasOwnProperty(i) && !hash[i] && (def = cond[i]) && (!def.ua && !def.test || def.ua && Y.UA[def.ua] || def.test && def.test(Y, r)) && (hash[i] = !0, d.push(i), m = this.getModule(i))) for(j = 0, add = this.getRequires(m); j < add.length; j++)d.push(add[j]);
}
// Create skin modules
if (mod.skinnable) {
for(i in skindef = this.skin.overrides, YUI.Env.aliases)YUI.Env.aliases.hasOwnProperty(i) && Y.Array.indexOf(YUI.Env.aliases[i], name) > -1 && (skinpar = i);
if (skindef && (skindef[name] || skinpar && skindef[skinpar])) for(skinname = name, skindef[skinpar] && (skinname = skinpar), i = 0; i < skindef[skinname].length; i++)skinmod = this._addSkin(skindef[skinname][i], name), this.isCSSLoaded(skinmod, this._boot) || d.push(skinmod);
else skinmod = this._addSkin(this.skin.defaultSkin, name), this.isCSSLoaded(skinmod, this._boot) || d.push(skinmod);
}
return mod._parsed = !1, intl && (mod.lang && !mod.langPack && Y.Intl && (lang = Y.Intl.lookupBestLang(this.lang || "", mod.lang), (packName = this.getLangPackName(lang, name)) && d.unshift(packName)), d.unshift(INTL)), mod.expanded_map = yArray.hash(d), mod.expanded = YObject.keys(mod.expanded_map), mod.expanded;
},
/**
* Check to see if named css module is already loaded on the page
* @method isCSSLoaded
* @param {String} name The name of the css file
* @return Boolean
*/ isCSSLoaded: function(name, skip) {
//TODO - Make this call a batching call with name being an array
if (!name || !YUI.Env.cssStampEl || !skip && this.ignoreRegistered) return !1;
var el = YUI.Env.cssStampEl, ret = !1, mod = YUI.Env._cssLoaded[name], style = el.currentStyle; //IE
return void 0 !== mod ? mod : (//Add the classname to the element
el.className = name, style || (style = Y.config.doc.defaultView.getComputedStyle(el, null)), style && "none" === style.display && (ret = !0), el.className = "", YUI.Env._cssLoaded[name] = ret, ret);
},
/**
* Returns a hash of module names the supplied module satisfies.
* @method getProvides
* @param {string} name The name of the module.
* @return {object} what this module provides.
*/ getProvides: function(name) {
var o, s, m = this.getModule(name);
return(// supmap = this.provides;
m ? (m && !m.provides && (o = {}, (s = m.supersedes) && yArray.each(s, function(v) {
Y.mix(o, this.getProvides(v));
}, this), o[name] = !0, m.provides = o), m.provides) : NOT_FOUND);
},
/**
* Calculates the dependency tree, the result is stored in the sorted
* property.
* @method calculate
* @param {object} o optional options object.
* @param {string} type optional argument to prune modules.
*/ calculate: function(o, type) {
(o || type || this.dirty) && (o && this._config(o), this._init || this._setup(), this._explode(), this.allowRollup ? this._rollup() : this._explodeRollups(), this._reduce(), this._sort());
},
/**
* Creates a "psuedo" package for languages provided in the lang array
* @method _addLangPack
* @private
* @param {String} lang The language to create
* @param {Object} m The module definition to create the language pack around
* @param {String} packName The name of the package (e.g: lang/datatype-date-en-US)
* @return {Object} The module definition
*/ _addLangPack: function(lang, m, packName) {
var conf, name = m.name;
return !this.moduleInfo[packName] && (conf = {
path: _path(m.pkg || name, packName, "js", !0),
intl: !0,
langPack: !0,
ext: m.ext,
group: m.group,
supersedes: []
}, m.root && (conf.root = m.root), m.base && (conf.base = m.base), m.configFn && (conf.configFn = m.configFn), this.addModule(conf, packName), lang && (Y.Env.lang = Y.Env.lang || {}, Y.Env.lang[lang] = Y.Env.lang[lang] || {}, Y.Env.lang[lang][name] = !0)), this.moduleInfo[packName];
},
/**
* Investigates the current YUI configuration on the page. By default,
* modules already detected will not be loaded again unless a force
* option is encountered. Called by calculate()
* @method _setup
* @private
*/ _setup: function() {
var name, i, j, m, l, packName, info = this.moduleInfo;
for(name in info)info.hasOwnProperty(name) && (m = info[name]) && (// remove dups
//m.requires = YObject.keys(yArray.hash(m.requires));
m.requires = yArray.dedupe(m.requires), m.lang && (// Setup root package if the module has lang defined,
// it needs to provide a root language pack
packName = this.getLangPackName("", name), this._addLangPack(null, m, packName)));
// expand the list to include superseded modules
for(j in //l = Y.merge(this.inserted);
l = {}, this.ignoreRegistered || Y.mix(l, GLOBAL_ENV.mods), this.ignore && Y.mix(l, yArray.hash(this.ignore)), l)l.hasOwnProperty(j) && Y.mix(l, this.getProvides(j));
// remove modules on the force list from the loaded list
if (this.force) for(i = 0; i < this.force.length; i++)this.force[i] in l && delete l[this.force[i]];
Y.mix(this.loaded, l), this._init = !0;
},
/**
* Builds a module name for a language pack
* @method getLangPackName
* @param {string} lang the language code.
* @param {string} mname the module to build it for.
* @return {string} the language pack module name.
*/ getLangPackName: function(lang, mname) {
return "lang/" + mname + (lang ? "_" + lang : "");
},
/**
* Inspects the required modules list looking for additional
* dependencies. Expands the required list to include all
* required modules. Called by calculate()
* @method _explode
* @private
*/ _explode: function() {
//TODO Move done out of scope
var m, reqs, name, expound, r = this.required, done = {};
for(name in // the setup phase is over, all modules have been created
this.dirty = !1, this._explodeRollups(), r = this.required)r.hasOwnProperty(name) && !done[name] && (done[name] = !0, (m = this.getModule(name)) && ((expound = m.expound) && (r[expound] = this.getModule(expound), reqs = this.getRequires(r[expound]), Y.mix(r, yArray.hash(reqs))), reqs = this.getRequires(m), Y.mix(r, yArray.hash(reqs))));
},
/**
* The default method used to test a module against a pattern
* @method _patternTest
* @private
* @param {String} mname The module being tested
* @param {String} pname The pattern to match
*/ _patternTest: function(mname, pname) {
return mname.indexOf(pname) > -1;
},
/**
* Get's the loader meta data for the requested module
* @method getModule
* @param {String} mname The module name to get
* @return {Object} The module metadata
*/ getModule: function(mname) {
//TODO: Remove name check - it's a quick hack to fix pattern WIP
if (!mname) return null;
var p, found, pname, m = this.moduleInfo[mname], patterns = this.patterns;
// check the patterns library to see if we should automatically add
// the module with defaults
if (!m || m && m.ext) {
for(pname in patterns)if (patterns.hasOwnProperty(pname) && ((p = patterns[pname]).test || (p.test = this._patternTest), p.test(mname, pname))) {
// use the metadata supplied for the pattern
// as the module definition.
found = p;
break;
}
}
return m ? found && m && found.configFn && !m.configFn && (m.configFn = found.configFn, m.configFn(m)) : found && (p.action ? p.action.call(this, mname, pname) : (// ext true or false?
m = this.addModule(Y.merge(found), mname), found.configFn && (m.configFn = found.configFn), m.temp = !0)), m;
},
// impl in rollup submodule
_rollup: function() {},
/**
* Remove superceded modules and loaded modules. Called by
* calculate() after we have the mega list of all dependencies
* @method _reduce
* @return {object} the reduced dependency hash.
* @private
*/ _reduce: function(r) {
r = r || this.required;
var i, j, s, m, type = this.loadType, ignore = !!this.ignore && yArray.hash(this.ignore);
for(i in r)if (r.hasOwnProperty(i) && (m = this.getModule(i), ((this.loaded[i] || ON_PAGE[i]) && !this.forceMap[i] && !this.ignoreRegistered || type && m && m.type !== type) && delete r[i], ignore && ignore[i] && delete r[i], // remove anything this module supersedes
s = m && m.supersedes)) for(j = 0; j < s.length; j++)s[j] in r && delete r[s[j]];
return r;
},
/**
* Handles the queue when a module has been loaded for all cases
* @method _finish
* @private
* @param {String} msg The message from Loader
* @param {Boolean} success A boolean denoting success or failure
*/ _finish: function(msg, success) {
_queue.running = !1;
var onEnd = this.onEnd;
onEnd && onEnd.call(this.context, {
msg: msg,
data: this.data,
success: success
}), this._continue();
},
/**
* The default Loader onSuccess handler, calls this.onSuccess with a payload
* @method _onSuccess
* @private
*/ _onSuccess: function() {
var fn, success, msg, i, mod, skipped = Y.merge(this.skipped), failed = [], rreg = this.requireRegistration;
for(i in skipped)skipped.hasOwnProperty(i) && delete this.inserted[i];
for(i in this.skipped = {}, this.inserted)this.inserted.hasOwnProperty(i) && ((mod = this.getModule(i)) && rreg && "js" === mod.type && !(i in YUI.Env.mods) ? failed.push(i) : Y.mix(this.loaded, this.getProvides(i)));
fn = this.onSuccess, msg = failed.length ? "notregistered" : "success", success = !failed.length, fn && fn.call(this.context, {
msg: msg,
data: this.data,
success: success,
failed: failed,
skipped: skipped
}), this._finish(msg, success);
},
/**
* The default Loader onProgress handler, calls this.onProgress with a payload
* @method _onProgress
* @private
*/ _onProgress: function(e) {
var i;
//set the internal cache to what just came in.
if (e.data && e.data.length) for(i = 0; i < e.data.length; i++)e.data[i] = this.getModule(e.data[i].name);
this.onProgress && this.onProgress.call(this.context, {
name: e.url,
data: e.data
});
},
/**
* The default Loader onFailure handler, calls this.onFailure with a payload
* @method _onFailure
* @private
*/ _onFailure: function(o) {
for(var f = this.onFailure, msg = [], i = 0, len = o.errors.length; i < len; i++)msg.push(o.errors[i].error);
msg = msg.join(","), f && f.call(this.context, {
msg: msg,
data: this.data,
success: !1
}), this._finish(msg, !1);
},
/**
* The default Loader onTimeout handler, calls this.onTimeout with a payload
* @method _onTimeout
* @param {Get.Transaction} transaction The Transaction object from `Y.Get`
* @private
*/ _onTimeout: function(transaction) {
var f = this.onTimeout;
f && f.call(this.context, {
msg: "timeout",
data: this.data,
success: !1,
transaction: transaction
});
},
/**
* Sorts the dependency tree. The last step of calculate()
* @method _sort
* @private
*/ _sort: function() {
// keep going until we make a pass without moving anything
for(// create an indexed list
var l, a, b, j, k, moved, doneKey, s = YObject.keys(this.required), // loaded = this.loaded,
//TODO Move this out of scope
done = {}, p = 0;;){
// start the loop after items that are already sorted
for(l = s.length, moved = !1, j = p; j < l; j++){
// check everything below current item and move if we
// find a requirement for the current item
for(// check the next module on the list to see if its
// dependencies have been met
a = s[j], k = j + 1; k < l; k++)if (!done[doneKey = a + s[k]] && this._requires(a, s[k])) {
// extract the dependency so we can move it up
b = s.splice(k, 1), // insert the dependency above the item that
// requires it
s.splice(j, 0, b[0]), // only swap two dependencies once to short circut
// circular dependencies
done[doneKey] = !0, // keep working
moved = !0;
break;
}
// jump out of loop if we moved something
if (moved) break;
p++;
}
// when we make it here and moved is false, we are
// finished sorting
if (!moved) break;
}
this.sorted = s;
},
/**
* Handles the actual insertion of script/link tags
* @method _insert
* @private
* @param {Object} source The YUI instance the request came from
* @param {Object} o The metadata to include
* @param {String} type JS or CSS
* @param {Boolean} [skipcalc=false] Do a Loader.calculate on the meta
*/ _insert: function(source, o, type, skipcalc) {
source && this._config(source);
// build the dependency list
// don't include type so we can process CSS and script in
// one pass when the type is not specified.
var deps, complete, modules = this.resolve(!skipcalc), self = this, comp = 0, actions = 0, mods = {};
if (self._refetch = [], type && //Filter out the opposite type and reset the array so the checks later work
(modules["js" === type ? "css" : "js"] = []), self.fetchCSS || (modules.css = []), modules.js.length && comp++, modules.css.length && comp++, //console.log('Resolved Modules: ', modules);
complete = function(d) {
actions++;
var fn, modName, resMods, errs = {}, i = 0, o = 0, u = "";
if (d && d.errors) for(i = 0; i < d.errors.length; i++)errs[u = d.errors[i].request ? d.errors[i].request.url : d.errors[i]] = u;
if (d && d.data && d.data.length && "success" === d.type) for(i = 0; i < d.data.length; i++)self.inserted[d.data[i].name] = !0, (d.data[i].lang || d.data[i].skinnable) && (delete self.inserted[d.data[i].name], self._refetch.push(d.data[i].name));
if (actions === comp) {
if (self._loading = null, self._refetch.length) {
//Get the deps for the new meta-data and reprocess
for(i = 0; i < self._refetch.length; i++)for(o = 0, deps = self.getRequires(self.getModule(self._refetch[i])); o < deps.length; o++)self.inserted[deps[o]] || //We wouldn't be to this point without the module being here
(mods[deps[o]] = deps[o]);
if ((mods = Y.Object.keys(mods)).length) {
if (self.require(mods), (resMods = self.resolve(!0)).cssMods.length) {
for(i = 0; i < resMods.cssMods.length; i++)modName = resMods.cssMods[i].name, delete YUI.Env._cssLoaded[modName], self.isCSSLoaded(modName) && (self.inserted[modName] = !0, delete self.required[modName]);
self.sorted = [], self._sort();
}
d = null, self._insert();
}
}
d && d.fn && (fn = d.fn, delete d.fn, fn.call(self, d));
}
}, this._loading = !0, !modules.js.length && !modules.css.length) {
actions = -1, complete({
fn: self._onSuccess
});
return;
}
modules.css.length && //Load CSS first
Y.Get.css(modules.css, {
data: modules.cssMods,
attributes: self.cssAttributes,
insertBefore: self.insertBefore,
charset: self.charset,
timeout: self.timeout,
context: self,
onProgress: function(e) {
self._onProgress.call(self, e);
},
onTimeout: function(d) {
self._onTimeout.call(self, d);
},
onSuccess: function(d) {
d.type = "success", d.fn = self._onSuccess, complete.call(self, d);
},
onFailure: function(d) {
d.type = "failure", d.fn = self._onFailure, complete.call(self, d);
}
}), modules.js.length && Y.Get.js(modules.js, {
data: modules.jsMods,
insertBefore: self.insertBefore,
attributes: self.jsAttributes,
charset: self.charset,
timeout: self.timeout,
autopurge: !1,
context: self,
async: self.async,
onProgress: function(e) {
self._onProgress.call(self, e);
},
onTimeout: function(d) {
self._onTimeout.call(self, d);
},
onSuccess: function(d) {
d.type = "success", d.fn = self._onSuccess, complete.call(self, d);
},
onFailure: function(d) {
d.type = "failure", d.fn = self._onFailure, complete.call(self, d);
}
});
},
/**
* Once a loader operation is completely finished, process any additional queued items.
* @method _continue
* @private
*/ _continue: function() {
!_queue.running && _queue.size() > 0 && (_queue.running = !0, _queue.next()());
},
/**
* inserts the requested modules and their dependencies.
* <code>type</code> can be "js" or "css". Both script and
* css are inserted if type is not provided.
* @method insert
* @param {object} o optional options object.
* @param {string} type the type of dependency to insert.
*/ insert: function(o, type, skipsort) {
var self = this, copy = Y.merge(this);
delete copy.require, delete copy.dirty, _queue.add(function() {
self._insert(copy, o, type, skipsort);
}), this._continue();
},
/**
* Executed every time a module is loaded, and if we are in a load
* cycle, we attempt to load the next script. Public so that it
* is possible to call this if using a method other than
* Y.register to determine when scripts are fully loaded
* @method loadNext
* @deprecated
* @param {string} mname optional the name of the module that has
* been loaded (which is usually why it is time to load the next
* one).
*/ loadNext: function() {},
/**
* Apply filter defined for this instance to a url/path
* @method _filter
* @param {string} u the string to filter.
* @param {string} name the name of the module, if we are processing
* a single module as opposed to a combined url.
* @return {string} the filtered string.
* @private
*/ _filter: function(u, name, group) {
var f = this.filter, hasFilter = name && name in this.filters, modFilter = hasFilter && this.filters[name], groupName = group || (this.moduleInfo[name] ? this.moduleInfo[name].group : null);
return groupName && this.groups[groupName] && this.groups[groupName].filter && (modFilter = this.groups[groupName].filter, hasFilter = !0), u && (hasFilter && (f = L.isString(modFilter) ? this.FILTER_DEFS[modFilter.toUpperCase()] || null : modFilter), f && (u = u.replace(RegExp(f.searchExp, "g"), f.replaceStr))), u;
},
/**
* Generates the full url for a module
* @method _url
* @param {string} path the path fragment.
* @param {String} name The name of the module
* @param {String} [base=self.base] The base url to use
* @return {string} the full url.
* @private
*/ _url: function(path, name, base) {
return this._filter((base || this.base || "") + path, name);
},
/**
* Returns an Object hash of file arrays built from `loader.sorted` or from an arbitrary list of sorted modules.
* @method resolve
* @param {Boolean} [calc=false] Perform a loader.calculate() before anything else
* @param {Array} [s=loader.sorted] An override for the loader.sorted array
* @return {Object} Object hash (js and css) of two arrays of file lists
* @example This method can be used as an off-line dep calculator
*
* var Y = YUI();
* var loader = new Y.Loader({
* filter: 'debug',
* base: '../../',
* root: 'build/',
* combine: true,
* require: ['node', 'dd', 'console']
* });
* var out = loader.resolve(true);
*
*/ resolve: function(calc, s) {
var len, i, m, url, group, groupName, j, frag, comboSource, comboSources, mods, comboBase, urls, tmpBase, baseLen, comboSep, maxURLLength, addSingle, u = [], resCombos = {}, self = this, inserted = self.ignoreRegistered ? {} : self.inserted, resolved = {
js: [],
jsMods: [],
css: [],
cssMods: []
}, type = self.loadType || "js";
for((self.skin.overrides || "sam" !== self.skin.defaultSkin || self.ignoreRegistered) && self._resetModules(), calc && self.calculate(), s = s || self.sorted, addSingle = function(m) {
m && (!1 === (group = m.group && self.groups[m.group] || NOT_FOUND).async && (m.async = group.async), url = m.fullpath ? self._filter(m.fullpath, s[i]) : self._url(m.path, s[i], group.base || m.base), (m.attributes || !1 === m.async) && (url = {
url: url,
async: m.async
}, m.attributes && (url.attributes = m.attributes)), resolved[m.type].push(url), resolved[m.type + "Mods"].push(m));
}, len = s.length, url = // the default combo base
comboBase = self.comboBase, comboSources = {}, i = 0; i < len; i++){
if (comboSource = comboBase, groupName = (m = self.getModule(s[i])) && m.group, group = self.groups[groupName], groupName && group) {
if (!group.combine || m.fullpath) {
//This is not a combo module, skip it and load it singly later.
addSingle(m);
continue;
}
m.combine = !0, group.comboBase && (comboSource = group.comboBase), "root" in group && L.isValue(group.root) && (m.root = group.root), m.comboSep = group.comboSep || self.comboSep, m.maxURLLength = group.maxURLLength || self.maxURLLength;
} else if (!self.combine) {
//This is not a combo module, skip it and load it singly later.
addSingle(m);
continue;
}
comboSources[comboSource] = comboSources[comboSource] || [], comboSources[comboSource].push(m);
}
for(j in comboSources)if (comboSources.hasOwnProperty(j) && (resCombos[j] = resCombos[j] || {
js: [],
jsMods: [],
css: [],
cssMods: []
}, url = j, len = (mods = comboSources[j]).length)) for(i = 0; i < len; i++)!inserted[mods[i]] && ((m = mods[i]) && (m.combine || !m.ext) ? (resCombos[j].comboSep = m.comboSep, resCombos[j].group = m.group, resCombos[j].maxURLLength = m.maxURLLength, frag = (L.isValue(m.root) ? m.root : self.root) + (m.path || m.fullpath), frag = self._filter(frag, m.name), resCombos[j][m.type].push(frag), resCombos[j][m.type + "Mods"].push(m)) : mods[i] && addSingle(mods[i]));
for(j in resCombos)if (resCombos.hasOwnProperty(j)) {
for(type in comboSep = resCombos[j].comboSep || self.comboSep, maxURLLength = resCombos[j].maxURLLength || self.maxURLLength, resCombos[j])if ("js" === type || "css" === type) {
if (urls = resCombos[j][type], mods = resCombos[j][type + "Mods"], len = urls.length, baseLen = (tmpBase = j + urls.join(comboSep)).length, maxURLLength <= j.length && (maxURLLength = 1024), len) {
if (baseLen > maxURLLength) {
for(s = 0, u = []; s < len; s++)u.push(urls[s]), (tmpBase = j + u.join(comboSep)).length > maxURLLength && (m = u.pop(), tmpBase = j + u.join(comboSep), resolved[type].push(self._filter(tmpBase, null, resCombos[j].group)), u = [], m && u.push(m));
u.length && (tmpBase = j + u.join(comboSep), resolved[type].push(self._filter(tmpBase, null, resCombos[j].group)));
} else resolved[type].push(self._filter(tmpBase, null, resCombos[j].group));
}
resolved[type + "Mods"] = resolved[type + "Mods"].concat(mods);
}
}
return resCombos = null, resolved;
},
/**
Shortcut to calculate, resolve and load all modules.
var loader = new Y.Loader({
ignoreRegistered: true,
modules: {
mod: {
path: 'mod.js'
}
},
requires: [ 'mod' ]
});
loader.load(function() {
console.log('All modules have loaded..');
});
@method load
@param {Callback} cb Executed after all load operations are complete
*/ load: function(cb) {
if (cb) {
var self = this, out = self.resolve(!0);
self.data = out, self.onEnd = function() {
cb.apply(self.context || self, arguments);
}, self.insert();
}
}
};
}, "3.12.0", {
requires: [
"get",
"features"
]
}), YUI.add("loader-rollup", function(Y, NAME) {
/**
* Optional automatic rollup logic for reducing http connections
* when not using a combo service.
* @module loader
* @submodule rollup
*/ /**
* Look for rollup packages to determine if all of the modules a
* rollup supersedes are required. If so, include the rollup to
* help reduce the total number of connections required. Called
* by calculate(). This is an optional feature, and requires the
* appropriate submodule to function.
* @method _rollup
* @for Loader
* @private
*/ Y.Loader.prototype._rollup = function() {
var i, j, m, s, roll, rolled, c, smod, r = this.required, info = this.moduleInfo;
// find and cache rollup modules
if (this.dirty || !this.rollups) for(i in this.rollups = {}, info)info.hasOwnProperty(i) && (m = this.getModule(i)) && m.rollup && (this.rollups[i] = m);
// make as many passes as needed to pick up rollup rollups
for(;;){
// go through the rollup candidates
for(i in rolled = !1, this.rollups)if (this.rollups.hasOwnProperty(i) && !r[i] && (!this.loaded[i] || this.forceMap[i])) {
// @TODO remove continue
if (s = (m = this.getModule(i)).supersedes || [], roll = !1, !m.rollup) continue;
// check the threshold
for(j = 0, c = 0; j < s.length; j++){
// if the superseded module is loaded, we can't
// load the rollup unless it has been forced.
if (smod = info[s[j]], this.loaded[s[j]] && !this.forceMap[s[j]]) {
roll = !1;
break;
// increment the counter if this module is required.
// if we are beyond the rollup threshold, we will
// use the rollup module
}
if (r[s[j]] && m.type === smod.type && (roll = ++c >= m.rollup)) break;
}
roll && (// add the rollup
r[i] = !0, rolled = !0, // expand the rollup's dependencies
this.getRequires(m));
}
// if we made it here w/o rolling up something, we are done
if (!rolled) break;
}
};
}, "3.12.0", {
requires: [
"loader-base"
]
}), YUI.add("loader-yui3", function(Y, NAME) {
/* This file is auto-generated by (yogi.js loader --mix --yes) */ /*jshint maxlen:900, eqeqeq: false */ /**
* YUI 3 module metadata
* @module loader
* @submodule loader-yui3
*/ YUI.Env[Y.version].modules = YUI.Env[Y.version].modules || {}, Y.mix(YUI.Env[Y.version].modules, {
"align-plugin": {
requires: [
"node-screen",
"node-pluginhost"
]
},
anim: {
use: [
"anim-base",
"anim-color",
"anim-curve",
"anim-easing",
"anim-node-plugin",
"anim-scroll",
"anim-xy"
]
},
"anim-base": {
requires: [
"base-base",
"node-style"
]
},
"anim-color": {
requires: [
"anim-base"
]
},
"anim-curve": {
requires: [
"anim-xy"
]
},
"anim-easing": {
requires: [
"anim-base"
]
},
"anim-node-plugin": {
requires: [
"node-pluginhost",
"anim-base"
]
},
"anim-scroll": {
requires: [
"anim-base"
]
},
"anim-shape": {
requires: [
"anim-base",
"anim-easing",
"anim-color",
"matrix"
]
},
"anim-shape-transform": {
use: [
"anim-shape"
]
},
"anim-xy": {
requires: [
"anim-base",
"node-screen"
]
},
app: {
use: [
"app-base",
"app-content",
"app-transitions",
"lazy-model-list",
"model",
"model-list",
"model-sync-rest",
"router",
"view",
"view-node-map"
]
},
"app-base": {
requires: [
"classnamemanager",
"pjax-base",
"router",
"view"
]
},
"app-content": {
requires: [
"app-base",
"pjax-content"
]
},
"app-transitions": {
requires: [
"app-base"
]
},
"app-transitions-css": {
type: "css"
},
"app-transitions-native": {
condition: {
name: "app-transitions-native",
test: function(Y) {
var doc = Y.config.doc, node = doc ? doc.documentElement : null;
return !!node && !!node.style && ("MozTransition" in node.style || "WebkitTransition" in node.style || "transition" in node.style);
},
trigger: "app-transitions"
},
requires: [
"app-transitions",
"app-transitions-css",
"parallel",
"transition"
]
},
"array-extras": {
requires: [
"yui-base"
]
},
"array-invoke": {
requires: [
"yui-base"
]
},
arraylist: {
requires: [
"yui-base"
]
},
"arraylist-add": {
requires: [
"arraylist"
]
},
"arraylist-filter": {
requires: [
"arraylist"
]
},
arraysort: {
requires: [
"yui-base"
]
},
"async-queue": {
requires: [
"event-custom"
]
},
attribute: {
use: [
"attribute-base",
"attribute-complex"
]
},
"attribute-base": {
requires: [
"attribute-core",
"attribute-observable",
"attribute-extras"
]
},
"attribute-complex": {
requires: [
"attribute-base"
]
},
"attribute-core": {
requires: [
"oop"
]
},
"attribute-events": {
use: [
"attribute-observable"
]
},
"attribute-extras": {
requires: [
"oop"
]
},
"attribute-observable": {
requires: [
"event-custom"
]
},
autocomplete: {
use: [
"autocomplete-base",
"autocomplete-sources",
"autocomplete-list",
"autocomplete-plugin"
]
},
"autocomplete-base": {
optional: [
"autocomplete-sources"
],
requires: [
"array-extras",
"base-build",
"escape",
"event-valuechange",
"node-base"
]
},
"autocomplete-filters": {
requires: [
"array-extras",
"text-wordbreak"
]
},
"autocomplete-filters-accentfold": {
requires: [
"array-extras",
"text-accentfold",
"text-wordbreak"
]
},
"autocomplete-highlighters": {
requires: [
"array-extras",
"highlight-base"
]
},
"autocomplete-highlighters-accentfold": {
requires: [
"array-extras",
"highlight-accentfold"
]
},
"autocomplete-list": {
after: [
"autocomplete-sources"
],
lang: [
"en",
"es",
"hu",
"it"
],
requires: [
"autocomplete-base",
"event-resize",
"node-screen",
"selector-css3",
"shim-plugin",
"widget",
"widget-position",
"widget-position-align"
],
skinnable: !0
},
"autocomplete-list-keys": {
condition: {
name: "autocomplete-list-keys",
test: function(Y) {
// Only add keyboard support to autocomplete-list if this doesn't appear to
// be an iOS or Android-based mobile device.
//
// There's currently no feasible way to actually detect whether a device has
// a hardware keyboard, so this sniff will have to do. It can easily be
// overridden by manually loading the autocomplete-list-keys module.
//
// Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
// doesn't fire the keyboard events used by AutoCompleteList, so there's
// no point loading the -keys module even when a bluetooth keyboard may be
// available.
return !(Y.UA.ios || Y.UA.android);
},
trigger: "autocomplete-list"
},
requires: [
"autocomplete-list",
"base-build"
]
},
"autocomplete-plugin": {
requires: [
"autocomplete-list",
"node-pluginhost"
]
},
"autocomplete-sources": {
optional: [
"io-base",
"json-parse",
"jsonp",
"yql"
],
requires: [
"autocomplete-base"
]
},
axes: {
use: [
"axis-numeric",
"axis-category",
"axis-time",
"axis-stacked"
]
},
"axes-base": {
use: [
"axis-numeric-base",
"axis-category-base",
"axis-time-base",
"axis-stacked-base"
]
},
axis: {
requires: [
"dom",
"widget",
"widget-position",
"widget-stack",
"graphics",
"axis-base"
]
},
"axis-base": {
requires: [
"classnamemanager",
"datatype-number",
"datatype-date",
"base",
"event-custom"
]
},
"axis-category": {
requires: [
"axis",
"axis-category-base"
]
},
"axis-category-base": {
requires: [
"axis-base"
]
},
"axis-numeric": {
requires: [
"axis",
"axis-numeric-base"
]
},
"axis-numeric-base": {
requires: [
"axis-base"
]
},
"axis-stacked": {
requires: [
"axis-numeric",
"axis-stacked-base"
]
},
"axis-stacked-base": {
requires: [
"axis-numeric-base"
]
},
"axis-time": {
requires: [
"axis",
"axis-time-base"
]
},
"axis-time-base": {
requires: [
"axis-base"
]
},
base: {
use: [
"base-base",
"base-pluginhost",
"base-build"
]
},
"base-base": {
requires: [
"attribute-base",
"base-core",
"base-observable"
]
},
"base-build": {
requires: [
"base-base"
]
},
"base-core": {
requires: [
"attribute-core"
]
},
"base-observable": {
requires: [
"attribute-observable"
]
},
"base-pluginhost": {
requires: [
"base-base",
"pluginhost"
]
},
button: {
requires: [
"button-core",
"cssbutton",
"widget"
]
},
"button-core": {
requires: [
"attribute-core",
"classnamemanager",
"node-base"
]
},
"button-group": {
requires: [
"button-plugin",
"cssbutton",
"widget"
]
},
"button-plugin": {
requires: [
"button-core",
"cssbutton",
"node-pluginhost"
]
},
cache: {
use: [
"cache-base",
"cache-offline",
"cache-plugin"
]
},
"cache-base": {
requires: [
"base"
]
},
"cache-offline": {
requires: [
"cache-base",
"json"
]
},
"cache-plugin": {
requires: [
"plugin",
"cache-base"
]
},
calendar: {
requires: [
"calendar-base",
"calendarnavigator"
],
skinnable: !0
},
"calendar-base": {
lang: [
"de",
"en",
"es",
"es-AR",
"fr",
"hu",
"it",
"ja",
"nb-NO",
"nl",
"pt-BR",
"ru",
"zh-Hans",
"zh-Hans-CN",
"zh-Hant",
"zh-Hant-HK",
"zh-HANT-TW"
],
requires: [
"widget",
"datatype-date",
"datatype-date-math",
"cssgrids"
],
skinnable: !0
},
calendarnavigator: {
requires: [
"plugin",
"classnamemanager",
"datatype-date",
"node"
],
skinnable: !0
},
charts: {
use: [
"charts-base"
]
},
"charts-base": {
requires: [
"dom",
"event-mouseenter",
"event-touch",
"graphics-group",
"axes",
"series-pie",
"series-line",
"series-marker",
"series-area",
"series-spline",
"series-column",
"series-bar",
"series-areaspline",
"series-combo",
"series-combospline",
"series-line-stacked",
"series-marker-stacked",
"series-area-stacked",
"series-spline-stacked",
"series-column-stacked",
"series-bar-stacked",
"series-areaspline-stacked",
"series-combo-stacked",
"series-combospline-stacked"
]
},
"charts-legend": {
requires: [
"charts-base"
]
},
classnamemanager: {
requires: [
"yui-base"
]
},
"clickable-rail": {
requires: [
"slider-base"
]
},
collection: {
use: [
"array-extras",
"arraylist",
"arraylist-add",
"arraylist-filter",
"array-invoke"
]
},
color: {
use: [
"color-base",
"color-hsl",
"color-harmony"
]
},
"color-base": {
requires: [
"yui-base"
]
},
"color-harmony": {
requires: [
"color-hsl"
]
},
"color-hsl": {
requires: [
"color-base"
]
},
"color-hsv": {
requires: [
"color-base"
]
},
console: {
lang: [
"en",
"es",
"hu",
"it",
"ja"
],
requires: [
"yui-log",
"widget"
],
skinnable: !0
},
"console-filters": {
requires: [
"plugin",
"console"
],
skinnable: !0
},
controller: {
use: [
"router"
]
},
cookie: {
requires: [
"yui-base"
]
},
"createlink-base": {
requires: [
"editor-base"
]
},
cssbase: {
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssreset-context",
"cssfonts-context",
"cssgrids-context"
],
type: "css"
},
"cssbase-context": {
after: [
"cssreset",
"cssfonts",
"cssgrids",
"cssreset-context",
"cssfonts-context",
"cssgrids-context"
],
type: "css"
},
cssbutton: {
type: "css"
},
cssfonts: {
type: "css"
},
"cssfonts-context": {
type: "css"
},
cssgrids: {
optional: [
"cssnormalize"
],
type: "css"
},
"cssgrids-base": {
optional: [
"cssnormalize"
],
type: "css"
},
"cssgrids-responsive": {
optional: [
"cssnormalize"
],
requires: [
"cssgrids",
"cssgrids-responsive-base"
],
type: "css"
},
"cssgrids-units": {
optional: [
"cssnormalize"
],
requires: [
"cssgrids-base"
],
type: "css"
},
cssnormalize: {
type: "css"
},
"cssnormalize-context": {
type: "css"
},
cssreset: {
type: "css"
},
"cssreset-context": {
type: "css"
},
dataschema: {
use: [
"dataschema-base",
"dataschema-json",
"dataschema-xml",
"dataschema-array",
"dataschema-text"
]
},
"dataschema-array": {
requires: [
"dataschema-base"
]
},
"dataschema-base": {
requires: [
"base"
]
},
"dataschema-json": {
requires: [
"dataschema-base",
"json"
]
},
"dataschema-text": {
requires: [
"dataschema-base"
]
},
"dataschema-xml": {
requires: [
"dataschema-base"
]
},
datasource: {
use: [
"datasource-local",
"datasource-io",
"datasource-get",
"datasource-function",
"datasource-cache",
"datasource-jsonschema",
"datasource-xmlschema",
"datasource-arrayschema",
"datasource-textschema",
"datasource-polling"
]
},
"datasource-arrayschema": {
requires: [
"datasource-local",
"plugin",
"dataschema-array"
]
},
"datasource-cache": {
requires: [
"datasource-local",
"plugin",
"cache-base"
]
},
"datasource-function": {
requires: [
"datasource-local"
]
},
"datasource-get": {
requires: [
"datasource-local",
"get"
]
},
"datasource-io": {
requires: [
"datasource-local",
"io-base"
]
},
"datasource-jsonschema": {
requires: [
"datasource-local",
"plugin",
"dataschema-json"
]
},
"datasource-local": {
requires: [
"base"
]
},
"datasource-polling": {
requires: [
"datasource-local"
]
},
"datasource-textschema": {
requires: [
"datasource-local",
"plugin",
"dataschema-text"
]
},
"datasource-xmlschema": {
requires: [
"datasource-local",
"plugin",
"datatype-xml",
"dataschema-xml"
]
},
datatable: {
use: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"datatable-base",
"datatable-column-widths",
"datatable-message",
"datatable-mutable",
"datatable-sort",
"datatable-datasource"
]
},
"datatable-base": {
requires: [
"datatable-core",
"datatable-table",
"datatable-head",
"datatable-body",
"base-build",
"widget"
],
skinnable: !0
},
"datatable-body": {
requires: [
"datatable-core",
"view",
"classnamemanager"
]
},
"datatable-column-widths": {
requires: [
"datatable-base"
]
},
"datatable-core": {
requires: [
"escape",
"model-list",
"node-event-delegate"
]
},
"datatable-datasource": {
requires: [
"datatable-base",
"plugin",
"datasource-local"
]
},
"datatable-foot": {
requires: [
"datatable-core",
"view"
]
},
"datatable-formatters": {
requires: [
"datatable-body",
"datatype-number-format",
"datatype-date-format",
"escape"
]
},
"datatable-head": {
requires: [
"datatable-core",
"view",
"classnamemanager"
]
},
"datatable-message": {
lang: [
"en",
"fr",
"es",
"hu",
"it"
],
requires: [
"datatable-base"
],
skinnable: !0
},
"datatable-mutable": {
requires: [
"datatable-base"
]
},
"datatable-paginator": {
lang: [
"en"
],
requires: [
"model",
"view",
"paginator-core",
"datatable-foot",
"datatable-paginator-templates"
],
skinnable: !0
},
"datatable-paginator-templates": {
requires: [
"template"
]
},
"datatable-scroll": {
requires: [
"datatable-base",
"datatable-column-widths",
"dom-screen"
],
skinnable: !0
},
"datatable-sort": {
lang: [
"en",
"fr",
"es",
"hu"
],
requires: [
"datatable-base"
],
skinnable: !0
},
"datatable-table": {
requires: [
"datatable-core",
"datatable-head",
"datatable-body",
"view",
"classnamemanager"
]
},
datatype: {
use: [
"datatype-date",
"datatype-number",
"datatype-xml"
]
},
"datatype-date": {
use: [
"datatype-date-parse",
"datatype-date-format",
"datatype-date-math"
]
},
"datatype-date-format": {
lang: [
"ar",
"ar-JO",
"ca",
"ca-ES",
"da",
"da-DK",
"de",
"de-AT",
"de-DE",
"el",
"el-GR",
"en",
"en-AU",
"en-CA",
"en-GB",
"en-IE",
"en-IN",
"en-JO",
"en-MY",
"en-NZ",
"en-PH",
"en-SG",
"en-US",
"es",
"es-AR",
"es-BO",
"es-CL",
"es-CO",
"es-EC",
"es-ES",
"es-MX",
"es-PE",
"es-PY",
"es-US",
"es-UY",
"es-VE",
"fi",
"fi-FI",
"fr",
"fr-BE",
"fr-CA",
"fr-FR",
"hi",
"hi-IN",
"hu",
"id",
"id-ID",
"it",
"it-IT",
"ja",
"ja-JP",
"ko",
"ko-KR",
"ms",
"ms-MY",
"nb",
"nb-NO",
"nl",
"nl-BE",
"nl-NL",
"pl",
"pl-PL",
"pt",
"pt-BR",
"ro",
"ro-RO",
"ru",
"ru-RU",
"sv",
"sv-SE",
"th",
"th-TH",
"tr",
"tr-TR",
"vi",
"vi-VN",
"zh-Hans",
"zh-Hans-CN",
"zh-Hant",
"zh-Hant-HK",
"zh-Hant-TW"
]
},
"datatype-date-math": {
requires: [
"yui-base"
]
},
"datatype-date-parse": {},
"datatype-number": {
use: [
"datatype-number-parse",
"datatype-number-format"
]
},
"datatype-number-format": {},
"datatype-number-parse": {},
"datatype-xml": {
use: [
"datatype-xml-parse",
"datatype-xml-format"
]
},
"datatype-xml-format": {},
"datatype-xml-parse": {},
dd: {
use: [
"dd-ddm-base",
"dd-ddm",
"dd-ddm-drop",
"dd-drag",
"dd-proxy",
"dd-constrain",
"dd-drop",
"dd-scroll",
"dd-delegate"
]
},
"dd-constrain": {
requires: [
"dd-drag"
]
},
"dd-ddm": {
requires: [
"dd-ddm-base",
"event-resize"
]
},
"dd-ddm-base": {
requires: [
"node",
"base",
"yui-throttle",
"classnamemanager"
]
},
"dd-ddm-drop": {
requires: [
"dd-ddm"
]
},
"dd-delegate": {
requires: [
"dd-drag",
"dd-drop-plugin",
"event-mouseenter"
]
},
"dd-drag": {
requires: [
"dd-ddm-base"
]
},
"dd-drop": {
requires: [
"dd-drag",
"dd-ddm-drop"
]
},
"dd-drop-plugin": {
requires: [
"dd-drop"
]
},
"dd-gestures": {
condition: {
name: "dd-gestures",
trigger: "dd-drag",
ua: "touchEnabled"
},
requires: [
"dd-drag",
"event-synthetic",
"event-gestures"
]
},
"dd-plugin": {
optional: [
"dd-constrain",
"dd-proxy"
],
requires: [
"dd-drag"
]
},
"dd-proxy": {
requires: [
"dd-drag"
]
},
"dd-scroll": {
requires: [
"dd-drag"
]
},
dial: {
lang: [
"en",
"es",
"hu"
],
requires: [
"widget",
"dd-drag",
"event-mouseenter",
"event-move",
"event-key",
"transition",
"intl"
],
skinnable: !0
},
dom: {
use: [
"dom-base",
"dom-screen",
"dom-style",
"selector-native",
"selector"
]
},
"dom-base": {
requires: [
"dom-core"
]
},
"dom-core": {
requires: [
"oop",
"features"
]
},
"dom-deprecated": {
requires: [
"dom-base"
]
},
"dom-screen": {
requires: [
"dom-base",
"dom-style"
]
},
"dom-style": {
requires: [
"dom-base",
"color-base"
]
},
"dom-style-ie": {
condition: {
name: "dom-style-ie",
test: function(Y) {
var testFeature = Y.Features.test, addFeature = Y.Features.add, WINDOW = Y.config.win, DOCUMENT = Y.config.doc, ret = !1;
return addFeature("style", "computedStyle", {
test: function() {
return WINDOW && "getComputedStyle" in WINDOW;
}
}), addFeature("style", "opacity", {
test: function() {
return DOCUMENT && "opacity" in DOCUMENT.documentElement.style;
}
}), !testFeature("style", "opacity") && !testFeature("style", "computedStyle");
},
trigger: "dom-style"
},
requires: [
"dom-style"
]
},
dump: {
requires: [
"yui-base"
]
},
editor: {
use: [
"frame",
"editor-selection",
"exec-command",
"editor-base",
"editor-para",
"editor-br",
"editor-bidi",
"editor-tab",
"createlink-base"
]
},
"editor-base": {
requires: [
"base",
"frame",
"node",
"exec-command",
"editor-selection"
]
},
"editor-bidi": {
requires: [
"editor-base"
]
},
"editor-br": {
requires: [
"editor-base"
]
},
"editor-lists": {
requires: [
"editor-base"
]
},
"editor-para": {
requires: [
"editor-para-base"
]
},
"editor-para-base": {
requires: [
"editor-base"
]
},
"editor-para-ie": {
condition: {
name: "editor-para-ie",
trigger: "editor-para",
ua: "ie",
when: "instead"
},
requires: [
"editor-para-base"
]
},
"editor-selection": {
requires: [
"node"
]
},
"editor-tab": {
requires: [
"editor-base"
]
},
escape: {
requires: [
"yui-base"
]
},
event: {
after: [
"node-base"
],
use: [
"event-base",
"event-delegate",
"event-synthetic",
"event-mousewheel",
"event-mouseenter",
"event-key",
"event-focus",
"event-resize",
"event-hover",
"event-outside",
"event-touch",
"event-move",
"event-flick",
"event-valuechange",
"event-tap"
]
},
"event-base": {
after: [
"node-base"
],
requires: [
"event-custom-base"
]
},
"event-base-ie": {
after: [
"event-base"
],
condition: {
name: "event-base-ie",
test: function(Y) {
var imp = Y.config.doc && Y.config.doc.implementation;
return imp && !imp.hasFeature("Events", "2.0");
},
trigger: "node-base"
},
requires: [
"node-base"
]
},
"event-contextmenu": {
requires: [
"event-synthetic",
"dom-screen"
]
},
"event-custom": {
use: [
"event-custom-base",
"event-custom-complex"
]
},
"event-custom-base": {
requires: [
"oop"
]
},
"event-custom-complex": {
requires: [
"event-custom-base"
]
},
"event-delegate": {
requires: [
"node-base"
]
},
"event-flick": {
requires: [
"node-base",
"event-touch",
"event-synthetic"
]
},
"event-focus": {
requires: [
"event-synthetic"
]
},
"event-gestures": {
use: [
"event-flick",
"event-move"
]
},
"event-hover": {
requires: [
"event-mouseenter"
]
},
"event-key": {
requires: [
"event-synthetic"
]
},
"event-mouseenter": {
requires: [
"event-synthetic"
]
},
"event-mousewheel": {
requires: [
"node-base"
]
},
"event-move": {
requires: [
"node-base",
"event-touch",
"event-synthetic"
]
},
"event-outside": {
requires: [
"event-synthetic"
]
},
"event-resize": {
requires: [
"node-base",
"event-synthetic"
]
},
"event-simulate": {
requires: [
"event-base"
]
},
"event-synthetic": {
requires: [
"node-base",
"event-custom-complex"
]
},
"event-tap": {
requires: [
"node-base",
"event-base",
"event-touch",
"event-synthetic"
]
},
"event-touch": {
requires: [
"node-base"
]
},
"event-valuechange": {
requires: [
"event-focus",
"event-synthetic"
]
},
"exec-command": {
requires: [
"frame"
]
},
features: {
requires: [
"yui-base"
]
},
file: {
requires: [
"file-flash",
"file-html5"
]
},
"file-flash": {
requires: [
"base"
]
},
"file-html5": {
requires: [
"base"
]
},
frame: {
requires: [
"base",
"node",
"selector-css3",
"yui-throttle"
]
},
"gesture-simulate": {
requires: [
"async-queue",
"event-simulate",
"node-screen"
]
},
get: {
requires: [
"yui-base"
]
},
graphics: {
requires: [
"node",
"event-custom",
"pluginhost",
"matrix",
"classnamemanager"
]
},
"graphics-canvas": {
condition: {
name: "graphics-canvas",
test: function(Y) {
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
},
trigger: "graphics"
},
requires: [
"graphics"
]
},
"graphics-canvas-default": {
condition: {
name: "graphics-canvas-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
},
trigger: "graphics"
}
},
"graphics-group": {
requires: [
"graphics"
]
},
"graphics-svg": {
condition: {
name: "graphics-svg",
test: function(Y) {
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (useSVG || !canvas);
},
trigger: "graphics"
},
requires: [
"graphics"
]
},
"graphics-svg-default": {
condition: {
name: "graphics-svg-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (useSVG || !canvas);
},
trigger: "graphics"
}
},
"graphics-vml": {
condition: {
name: "graphics-vml",
test: function(Y) {
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
},
trigger: "graphics"
},
requires: [
"graphics"
]
},
"graphics-vml-default": {
condition: {
name: "graphics-vml-default",
test: function(Y) {
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
},
trigger: "graphics"
}
},
handlebars: {
use: [
"handlebars-compiler"
]
},
"handlebars-base": {
requires: []
},
"handlebars-compiler": {
requires: [
"handlebars-base"
]
},
highlight: {
use: [
"highlight-base",
"highlight-accentfold"
]
},
"highlight-accentfold": {
requires: [
"highlight-base",
"text-accentfold"
]
},
"highlight-base": {
requires: [
"array-extras",
"classnamemanager",
"escape",
"text-wordbreak"
]
},
history: {
use: [
"history-base",
"history-hash",
"history-hash-ie",
"history-html5"
]
},
"history-base": {
requires: [
"event-custom-complex"
]
},
"history-hash": {
after: [
"history-html5"
],
requires: [
"event-synthetic",
"history-base",
"yui-later"
]
},
"history-hash-ie": {
condition: {
name: "history-hash-ie",
test: function(Y) {
var docMode = Y.config.doc && Y.config.doc.documentMode;
return Y.UA.ie && (!("onhashchange" in Y.config.win) || !docMode || docMode < 8);
},
trigger: "history-hash"
},
requires: [
"history-hash",
"node-base"
]
},
"history-html5": {
optional: [
"json"
],
requires: [
"event-base",
"history-base",
"node-base"
]
},
imageloader: {
requires: [
"base-base",
"node-style",
"node-screen"
]
},
intl: {
requires: [
"intl-base",
"event-custom"
]
},
"intl-base": {
requires: [
"yui-base"
]
},
io: {
use: [
"io-base",
"io-xdr",
"io-form",
"io-upload-iframe",
"io-queue"
]
},
"io-base": {
requires: [
"event-custom-base",
"querystring-stringify-simple"
]
},
"io-form": {
requires: [
"io-base",
"node-base"
]
},
"io-nodejs": {
condition: {
name: "io-nodejs",
trigger: "io-base",
ua: "nodejs"
},
requires: [
"io-base"
]
},
"io-queue": {
requires: [
"io-base",
"queue-promote"
]
},
"io-upload-iframe": {
requires: [
"io-base",
"node-base"
]
},
"io-xdr": {
requires: [
"io-base",
"datatype-xml-parse"
]
},
json: {
use: [
"json-parse",
"json-stringify"
]
},
"json-parse": {
requires: [
"yui-base"
]
},
"json-parse-shim": {
condition: {
name: "json-parse-shim",
test: function(Y) {
var _JSON = Y.config.global.JSON, Native = "[object JSON]" === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONParse && !!Native;
// Double check basic functionality. This is mainly to catch early broken
// implementations of the JSON API in Firefox 3.1 beta1 and beta2
if (nativeSupport) try {
nativeSupport = Native.parse('{"ok":false}', function(k, v) {
return "ok" === k || v;
}).ok;
} catch (e) {
nativeSupport = !1;
}
return !nativeSupport;
},
trigger: "json-parse"
},
requires: [
"json-parse"
]
},
"json-stringify": {
requires: [
"yui-base"
]
},
"json-stringify-shim": {
condition: {
name: "json-stringify-shim",
test: function(Y) {
var _JSON = Y.config.global.JSON, Native = "[object JSON]" === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONStringify && !!Native;
// Double check basic native functionality. This is primarily to catch broken
// early JSON API implementations in Firefox 3.1 beta1 and beta2.
if (nativeSupport) try {
nativeSupport = "0" === Native.stringify(0);
} catch (e) {
nativeSupport = !1;
}
return !nativeSupport;
},
trigger: "json-stringify"
},
requires: [
"json-stringify"
]
},
jsonp: {
requires: [
"get",
"oop"
]
},
"jsonp-url": {
requires: [
"jsonp"
]
},
"lazy-model-list": {
requires: [
"model-list"
]
},
loader: {
use: [
"loader-base",
"loader-rollup",
"loader-yui3"
]
},
"loader-base": {
requires: [
"get",
"features"
]
},
"loader-rollup": {
requires: [
"loader-base"
]
},
"loader-yui3": {
requires: [
"loader-base"
]
},
matrix: {
requires: [
"yui-base"
]
},
model: {
requires: [
"base-build",
"escape",
"json-parse"
]
},
"model-list": {
requires: [
"array-extras",
"array-invoke",
"arraylist",
"base-build",
"escape",
"json-parse",
"model"
]
},
"model-sync-rest": {
requires: [
"model",
"io-base",
"json-stringify"
]
},
node: {
use: [
"node-base",
"node-event-delegate",
"node-pluginhost",
"node-screen",
"node-style"
]
},
"node-base": {
requires: [
"event-base",
"node-core",
"dom-base",
"dom-style"
]
},
"node-core": {
requires: [
"dom-core",
"selector"
]
},
"node-deprecated": {
requires: [
"node-base"
]
},
"node-event-delegate": {
requires: [
"node-base",
"event-delegate"
]
},
"node-event-html5": {
requires: [
"node-base"
]
},
"node-event-simulate": {
requires: [
"node-base",
"event-simulate",
"gesture-simulate"
]
},
"node-flick": {
requires: [
"classnamemanager",
"transition",
"event-flick",
"plugin"
],
skinnable: !0
},
"node-focusmanager": {
requires: [
"attribute",
"node",
"plugin",
"node-event-simulate",
"event-key",
"event-focus"
]
},
"node-load": {
requires: [
"node-base",
"io-base"
]
},
"node-menunav": {
requires: [
"node",
"classnamemanager",
"plugin",
"node-focusmanager"
],
skinnable: !0
},
"node-pluginhost": {
requires: [
"node-base",
"pluginhost"
]
},
"node-screen": {
requires: [
"dom-screen",
"node-base"
]
},
"node-scroll-info": {
requires: [
"array-extras",
"base-build",
"event-resize",
"node-pluginhost",
"plugin",
"selector"
]
},
"node-style": {
requires: [
"dom-style",
"node-base"
]
},
oop: {
requires: [
"yui-base"
]
},
overlay: {
requires: [
"widget",
"widget-stdmod",
"widget-position",
"widget-position-align",
"widget-stack",
"widget-position-constrain"
],
skinnable: !0
},
paginator: {
requires: [
"paginator-core"
]
},
"paginator-core": {
requires: [
"base"
]
},
"paginator-url": {
requires: [
"paginator"
]
},
panel: {
requires: [
"widget",
"widget-autohide",
"widget-buttons",
"widget-modality",
"widget-position",
"widget-position-align",
"widget-position-constrain",
"widget-stack",
"widget-stdmod"
],
skinnable: !0
},
parallel: {
requires: [
"yui-base"
]
},
pjax: {
requires: [
"pjax-base",
"pjax-content"
]
},
"pjax-base": {
requires: [
"classnamemanager",
"node-event-delegate",
"router"
]
},
"pjax-content": {
requires: [
"io-base",
"node-base",
"router"
]
},
"pjax-plugin": {
requires: [
"node-pluginhost",
"pjax",
"plugin"
]
},
plugin: {
requires: [
"base-base"
]
},
pluginhost: {
use: [
"pluginhost-base",
"pluginhost-config"
]
},
"pluginhost-base": {
requires: [
"yui-base"
]
},
"pluginhost-config": {
requires: [
"pluginhost-base"
]
},
promise: {
requires: [
"timers"
]
},
querystring: {
use: [
"querystring-parse",
"querystring-stringify"
]
},
"querystring-parse": {
requires: [
"yui-base",
"array-extras"
]
},
"querystring-parse-simple": {
requires: [
"yui-base"
]
},
"querystring-stringify": {
requires: [
"yui-base"
]
},
"querystring-stringify-simple": {
requires: [
"yui-base"
]
},
"queue-promote": {
requires: [
"yui-base"
]
},
"range-slider": {
requires: [
"slider-base",
"slider-value-range",
"clickable-rail"
]
},
recordset: {
use: [
"recordset-base",
"recordset-sort",
"recordset-filter",
"recordset-indexer"
]
},
"recordset-base": {
requires: [
"base",
"arraylist"
]
},
"recordset-filter": {
requires: [
"recordset-base",
"array-extras",
"plugin"
]
},
"recordset-indexer": {
requires: [
"recordset-base",
"plugin"
]
},
"recordset-sort": {
requires: [
"arraysort",
"recordset-base",
"plugin"
]
},
resize: {
use: [
"resize-base",
"resize-proxy",
"resize-constrain"
]
},
"resize-base": {
requires: [
"base",
"widget",
"event",
"oop",
"dd-drag",
"dd-delegate",
"dd-drop"
],
skinnable: !0
},
"resize-constrain": {
requires: [
"plugin",
"resize-base"
]
},
"resize-plugin": {
optional: [
"resize-constrain"
],
requires: [
"resize-base",
"plugin"
]
},
"resize-proxy": {
requires: [
"plugin",
"resize-base"
]
},
router: {
optional: [
"querystring-parse"
],
requires: [
"array-extras",
"base-build",
"history"
]
},
scrollview: {
requires: [
"scrollview-base",
"scrollview-scrollbars"
]
},
"scrollview-base": {
requires: [
"widget",
"event-gestures",
"event-mousewheel",
"transition"
],
skinnable: !0
},
"scrollview-base-ie": {
condition: {
name: "scrollview-base-ie",
trigger: "scrollview-base",
ua: "ie"
},
requires: [
"scrollview-base"
]
},
"scrollview-list": {
requires: [
"plugin",
"classnamemanager"
],
skinnable: !0
},
"scrollview-paginator": {
requires: [
"plugin",
"classnamemanager"
]
},
"scrollview-scrollbars": {
requires: [
"classnamemanager",
"transition",
"plugin"
],
skinnable: !0
},
selector: {
requires: [
"selector-native"
]
},
"selector-css2": {
condition: {
name: "selector-css2",
test: function(Y) {
var DOCUMENT = Y.config.doc;
return DOCUMENT && !("querySelectorAll" in DOCUMENT);
},
trigger: "selector"
},
requires: [
"selector-native"
]
},
"selector-css3": {
requires: [
"selector-native",
"selector-css2"
]
},
"selector-native": {
requires: [
"dom-base"
]
},
"series-area": {
requires: [
"series-cartesian",
"series-fill-util"
]
},
"series-area-stacked": {
requires: [
"series-stacked",
"series-area"
]
},
"series-areaspline": {
requires: [
"series-area",
"series-curve-util"
]
},
"series-areaspline-stacked": {
requires: [
"series-stacked",
"series-areaspline"
]
},
"series-bar": {
requires: [
"series-marker",
"series-histogram-base"
]
},
"series-bar-stacked": {
requires: [
"series-stacked",
"series-bar"
]
},
"series-base": {
requires: [
"graphics",
"axis-base"
]
},
"series-candlestick": {
requires: [
"series-range"
]
},
"series-cartesian": {
requires: [
"series-base"
]
},
"series-column": {
requires: [
"series-marker",
"series-histogram-base"
]
},
"series-column-stacked": {
requires: [
"series-stacked",
"series-column"
]
},
"series-combo": {
requires: [
"series-cartesian",
"series-line-util",
"series-plot-util",
"series-fill-util"
]
},
"series-combo-stacked": {
requires: [
"series-stacked",
"series-combo"
]
},
"series-combospline": {
requires: [
"series-combo",
"series-curve-util"
]
},
"series-combospline-stacked": {
requires: [
"series-combo-stacked",
"series-curve-util"
]
},
"series-curve-util": {},
"series-fill-util": {},
"series-histogram-base": {
requires: [
"series-cartesian",
"series-plot-util"
]
},
"series-line": {
requires: [
"series-cartesian",
"series-line-util"
]
},
"series-line-stacked": {
requires: [
"series-stacked",
"series-line"
]
},
"series-line-util": {},
"series-marker": {
requires: [
"series-cartesian",
"series-plot-util"
]
},
"series-marker-stacked": {
requires: [
"series-stacked",
"series-marker"
]
},
"series-ohlc": {
requires: [
"series-range"
]
},
"series-pie": {
requires: [
"series-base",
"series-plot-util"
]
},
"series-plot-util": {},
"series-range": {
requires: [
"series-cartesian"
]
},
"series-spline": {
requires: [
"series-line",
"series-curve-util"
]
},
"series-spline-stacked": {
requires: [
"series-stacked",
"series-spline"
]
},
"series-stacked": {
requires: [
"axis-stacked"
]
},
"shim-plugin": {
requires: [
"node-style",
"node-pluginhost"
]
},
slider: {
use: [
"slider-base",
"slider-value-range",
"clickable-rail",
"range-slider"
]
},
"slider-base": {
requires: [
"widget",
"dd-constrain",
"event-key"
],
skinnable: !0
},
"slider-value-range": {
requires: [
"slider-base"
]
},
sortable: {
requires: [
"dd-delegate",
"dd-drop-plugin",
"dd-proxy"
]
},
"sortable-scroll": {
requires: [
"dd-scroll",
"sortable"
]
},
stylesheet: {
requires: [
"yui-base"
]
},
substitute: {
optional: [
"dump"
],
requires: [
"yui-base"
]
},
swf: {
requires: [
"event-custom",
"node",
"swfdetect",
"escape"
]
},
swfdetect: {
requires: [
"yui-base"
]
},
tabview: {
requires: [
"widget",
"widget-parent",
"widget-child",
"tabview-base",
"node-pluginhost",
"node-focusmanager"
],
skinnable: !0
},
"tabview-base": {
requires: [
"node-event-delegate",
"classnamemanager"
]
},
"tabview-plugin": {
requires: [
"tabview-base"
]
},
template: {
use: [
"template-base",
"template-micro"
]
},
"template-base": {
requires: [
"yui-base"
]
},
"template-micro": {
requires: [
"escape"
]
},
test: {
requires: [
"event-simulate",
"event-custom",
"json-stringify"
]
},
"test-console": {
requires: [
"console-filters",
"test",
"array-extras"
],
skinnable: !0
},
text: {
use: [
"text-accentfold",
"text-wordbreak"
]
},
"text-accentfold": {
requires: [
"array-extras",
"text-data-accentfold"
]
},
"text-data-accentfold": {
requires: [
"yui-base"
]
},
"text-data-wordbreak": {
requires: [
"yui-base"
]
},
"text-wordbreak": {
requires: [
"array-extras",
"text-data-wordbreak"
]
},
timers: {
requires: [
"yui-base"
]
},
transition: {
requires: [
"node-style"
]
},
"transition-timer": {
condition: {
name: "transition-timer",
test: function(Y) {
var DOCUMENT = Y.config.doc, node = DOCUMENT ? DOCUMENT.documentElement : null, ret = !0;
return node && node.style && (ret = !("MozTransition" in node.style || "WebkitTransition" in node.style || "transition" in node.style)), ret;
},
trigger: "transition"
},
requires: [
"transition"
]
},
tree: {
requires: [
"base-build",
"tree-node"
]
},
"tree-labelable": {
requires: [
"tree"
]
},
"tree-lazy": {
requires: [
"base-pluginhost",
"plugin",
"tree"
]
},
"tree-node": {},
"tree-openable": {
requires: [
"tree"
]
},
"tree-selectable": {
requires: [
"tree"
]
},
"tree-sortable": {
requires: [
"tree"
]
},
uploader: {
requires: [
"uploader-html5",
"uploader-flash"
]
},
"uploader-flash": {
requires: [
"swf",
"widget",
"base",
"cssbutton",
"node",
"event-custom",
"file-flash",
"uploader-queue"
]
},
"uploader-html5": {
requires: [
"widget",
"node-event-simulate",
"file-html5",
"uploader-queue"
]
},
"uploader-queue": {
requires: [
"base"
]
},
view: {
requires: [
"base-build",
"node-event-delegate"
]
},
"view-node-map": {
requires: [
"view"
]
},
widget: {
use: [
"widget-base",
"widget-htmlparser",
"widget-skin",
"widget-uievents"
]
},
"widget-anim": {
requires: [
"anim-base",
"plugin",
"widget"
]
},
"widget-autohide": {
requires: [
"base-build",
"event-key",
"event-outside",
"widget"
]
},
"widget-base": {
requires: [
"attribute",
"base-base",
"base-pluginhost",
"classnamemanager",
"event-focus",
"node-base",
"node-style"
],
skinnable: !0
},
"widget-base-ie": {
condition: {
name: "widget-base-ie",
trigger: "widget-base",
ua: "ie"
},
requires: [
"widget-base"
]
},
"widget-buttons": {
requires: [
"button-plugin",
"cssbutton",
"widget-stdmod"
]
},
"widget-child": {
requires: [
"base-build",
"widget"
]
},
"widget-htmlparser": {
requires: [
"widget-base"
]
},
"widget-locale": {
requires: [
"widget-base"
]
},
"widget-modality": {
requires: [
"base-build",
"event-outside",
"widget"
],
skinnable: !0
},
"widget-parent": {
requires: [
"arraylist",
"base-build",
"widget"
]
},
"widget-position": {
requires: [
"base-build",
"node-screen",
"widget"
]
},
"widget-position-align": {
requires: [
"widget-position"
]
},
"widget-position-constrain": {
requires: [
"widget-position"
]
},
"widget-skin": {
requires: [
"widget-base"
]
},
"widget-stack": {
requires: [
"base-build",
"widget"
],
skinnable: !0
},
"widget-stdmod": {
requires: [
"base-build",
"widget"
]
},
"widget-uievents": {
requires: [
"node-event-delegate",
"widget-base"
]
},
yql: {
requires: [
"oop"
]
},
"yql-jsonp": {
condition: {
name: "yql-jsonp",
test: function(Y) {
/* Only load the JSONP module when not in nodejs or winjs
TODO Make the winjs module a CORS module
*/ return !Y.UA.nodejs && !Y.UA.winjs;
},
trigger: "yql",
when: "after"
},
requires: [
"jsonp",
"jsonp-url"
]
},
"yql-nodejs": {
condition: {
name: "yql-nodejs",
trigger: "yql",
ua: "nodejs",
when: "after"
}
},
"yql-winjs": {
condition: {
name: "yql-winjs",
trigger: "yql",
ua: "winjs",
when: "after"
}
},
yui: {},
"yui-base": {},
"yui-later": {
requires: [
"yui-base"
]
},
"yui-log": {
requires: [
"yui-base"
]
},
"yui-throttle": {
requires: [
"yui-base"
]
}
}), YUI.Env[Y.version].md5 = "fd7c67956df50e445f40d1668dd1dc80";
}, "3.12.0", {
requires: [
"loader-base"
]
}), YUI.add("yui", function(Y, NAME) {}, "3.12.0", {
use: [
"yui-base",
"get",
"features",
"intl-base",
"yui-log",
"yui-later",
"loader-base",
"loader-rollup",
"loader-yui3"
]
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_1/input.js | JavaScript | (function ({ d: d }) {
console.log((a = "foo"), arguments[0].d);
})({ d: "Bar" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_1/output.js | JavaScript | !(function ({ d: d }) {
console.log((a = "foo"), arguments[0].d);
})({ d: "Bar" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_1/output.mangleOnly.js | JavaScript | (function({ d: o }) {
console.log((a = "foo"), arguments[0].d);
})({
d: "Bar"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_1/output.terser.js | JavaScript | !(function ({ d: d }) {
console.log((a = "foo"), arguments[0].d);
})({ d: "Bar" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_2/input.js | JavaScript | (function (a, { d: d }) {
console.log((a = "foo"), arguments[0]);
})("baz", { d: "Bar" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_2/output.js | JavaScript | !function(a, { d: d }) {
console.log(a = "foo", arguments[0]);
}("baz", {
d: "Bar"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_2/output.mangleOnly.js | JavaScript | (function(o, { d: n }) {
console.log((o = "foo"), arguments[0]);
})("baz", {
d: "Bar"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_2/output.terser.js | JavaScript | !(function (a, { d: d }) {
console.log((a = "foo"), arguments[0]);
})("baz", { d: "Bar" });
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_3/input.js | JavaScript | (function ({ d: d }, a) {
console.log((a = "foo"), arguments[0].d);
})({ d: "Bar" }, "baz");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_3/output.js | JavaScript | !function({ d: d }, a) {
console.log(a = "foo", arguments[0].d);
}({
d: "Bar"
}, "baz");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_3/output.mangleOnly.js | JavaScript | (function({ d: o }, d) {
console.log((d = "foo"), arguments[0].d);
})({
d: "Bar"
}, "baz");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_and_destructuring_3/output.terser.js | JavaScript | !(function ({ d: d }, a) {
console.log((a = "foo"), arguments[0].d);
})({ d: "Bar" }, "baz");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_1/input.js | JavaScript | (function (a, b) {
console.log(arguments[0], a, arguments[1], arguments[3], b, arguments[2]);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_1/output.js | JavaScript | (function (a, b, argument_2, argument_3) {
console.log(a, a, b, argument_3, b, argument_2);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_1/output.mangleOnly.js | JavaScript | (function(o, l) {
console.log(arguments[0], o, arguments[1], arguments[3], l, arguments[2]);
})("bar", 42, false);
(function(o, l) {
(()=>{
console.log(arguments[0], o, arguments[1], arguments[3], l, arguments[2]);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_1/output.terser.js | JavaScript | (function (a, b, argument_2, argument_3) {
console.log(a, a, b, argument_3, b, argument_2);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_2/input.js | JavaScript | (function (a, b) {
console.log(arguments[0], a, arguments[1], arguments[3], b, arguments[2]);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_2/output.js | JavaScript | (function (a, b) {
console.log(a, a, b, arguments[3], b, arguments[2]);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_2/output.mangleOnly.js | JavaScript | (function(o, l) {
console.log(arguments[0], o, arguments[1], arguments[3], l, arguments[2]);
})("bar", 42, false);
(function(o, l) {
(()=>{
console.log(arguments[0], o, arguments[1], arguments[3], l, arguments[2]);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/arguments_in_arrow_func_2/output.terser.js | JavaScript | (function (a, b) {
console.log(a, a, b, arguments[3], b, arguments[2]);
})("bar", 42, false);
(function (a, b) {
(() => {
console.log(
arguments[0],
a,
arguments[1],
arguments[3],
b,
arguments[2]
);
})(10, 20, 30, 40);
})("bar", 42, false);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/duplicate_parameter_with_arguments/input.js | JavaScript | (function (a, a) {
console.log((a = "foo"), arguments[0]);
})("baz", "Bar");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/duplicate_parameter_with_arguments/output.js | JavaScript | !(function (a, a) {
console.log((a = "foo"), arguments[0]);
})("baz", "Bar");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/duplicate_parameter_with_arguments/output.mangleOnly.js | JavaScript | (function(o, o) {
console.log((o = "foo"), arguments[0]);
})("baz", "Bar");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/duplicate_parameter_with_arguments/output.terser.js | JavaScript | !(function (a, a) {
console.log((a = "foo"), arguments[0]);
})("baz", "Bar");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/issue_687/input.js | JavaScript | function shouldBePure() {
return arguments.length;
}
shouldBePure();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/issue_687/output.mangleOnly.js | JavaScript | function n() {
return arguments.length;
}
n();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified/input.js | JavaScript | (function (a, b) {
var c = arguments[0];
var d = arguments[1];
var a = "foo";
b++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(a, b, c, d, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified/output.js | JavaScript | (function (a, b) {
var c = a;
var d = b;
var a = "foo";
b++;
a = "moo";
b *= 2;
console.log(a, b, c, d, a, b);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified/output.mangleOnly.js | JavaScript | (function(o, a) {
var r = arguments[0];
var n = arguments[1];
var o = "foo";
a++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(o, a, r, n, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified/output.terser.js | JavaScript | (function (a, b) {
var c = a;
var d = b;
var a = "foo";
b++;
a = "moo";
b *= 2;
console.log(a, b, c, d, a, b);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified_strict/input.js | JavaScript | "use strict";
(function (a, b) {
var c = arguments[0];
var d = arguments[1];
var a = "foo";
b++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(a, b, c, d, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified_strict/output.js | JavaScript | "use strict";
(function (a, b) {
var c = arguments[0];
var d = arguments[1];
var a = "foo";
b++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(a, b, c, d, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified_strict/output.mangleOnly.js | JavaScript | "use strict";
(function(o, r) {
var a = arguments[0];
var c = arguments[1];
var o = "foo";
r++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(o, r, a, c, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/modified_strict/output.terser.js | JavaScript | "use strict";
(function (a, b) {
var c = arguments[0];
var d = arguments[1];
var a = "foo";
b++;
arguments[0] = "moo";
arguments[1] *= 2;
console.log(a, b, c, d, arguments[0], arguments[1]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index/input.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function () {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (a, b) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index/output.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function () {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index/output.mangleOnly.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function() {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(o, n) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(arguments) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function() {
var arguments;
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index/output.terser.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function () {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs/input.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function () {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (a, b) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs/output.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function (argument_0, argument_1) {
console.log(argument_1, argument_1, arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs/output.mangleOnly.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function() {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(o, n) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(arguments) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function() {
var arguments;
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs/output.terser.js | JavaScript | var arguments = [];
console.log(arguments[0]);
(function (argument_0, argument_1) {
console.log(argument_1, argument_1, arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
(function (arguments) {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function () {
var arguments;
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs_strict/input.js | JavaScript | "use strict";
(function () {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (a, b) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs_strict/output.js | JavaScript | "use strict";
(function (argument_0, argument_1) {
console.log(argument_1, argument_1, arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs_strict/output.mangleOnly.js | JavaScript | "use strict";
(function() {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(o, n) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_keep_fargs_strict/output.terser.js | JavaScript | "use strict";
(function (argument_0, argument_1) {
console.log(argument_1, argument_1, arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_strict/input.js | JavaScript | "use strict";
(function () {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function (a, b) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_strict/output.js | JavaScript | "use strict";
(function () {
console.log(arguments[1], arguments[1], arguments.foo);
})("bar", 42);
(function (a, b) {
console.log(b, b, arguments.foo);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_minifier/tests/terser/compress/arguments/replace_index_strict/output.mangleOnly.js | JavaScript | "use strict";
(function() {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
(function(o, n) {
console.log(arguments[1], arguments["1"], arguments["foo"]);
})("bar", 42);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.