From c136ebc3a02c5818747db7a31f15a84732df3c26 Mon Sep 17 00:00:00 2001 From: deathrow Date: Thu, 19 Jan 2023 13:24:07 -0500 Subject: [PATCH] Update JS --- _includes/head.html | 7 + assets/js/bootstrap.min.js | 1758 ++++ assets/js/d3.min.js | 15924 +++++++++++++++++++++++++++++++++++ assets/js/jquery.min.js | 5315 ++++++++++++ assets/js/main.js | 89 + 5 files changed, 23093 insertions(+) create mode 100644 assets/js/bootstrap.min.js create mode 100644 assets/js/d3.min.js create mode 100644 assets/js/jquery.min.js create mode 100644 assets/js/main.js diff --git a/_includes/head.html b/_includes/head.html index 5629b98..d7d6983 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -20,4 +20,11 @@ + + + + + + + \ No newline at end of file diff --git a/assets/js/bootstrap.min.js b/assets/js/bootstrap.min.js new file mode 100644 index 0000000..2dd5553 --- /dev/null +++ b/assets/js/bootstrap.min.js @@ -0,0 +1,1758 @@ +/*! + * Bootstrap v3.3.7 (http://getbootstrap.com) + * Copyright 2011-2016 Twitter, Inc. + * Licensed under the MIT license + */ +if ("undefined" == typeof jQuery) + throw new Error("Bootstrap's JavaScript requires jQuery"); + ++ function (a) { + "use strict"; + var b = a + .fn + .jquery + .split(" ")[0] + .split("."); + if (b[0] < 2 && b[1] < 9 || 1 == b[0] && 9 == b[1] && b[2] < 1 || b[0] > 3) + throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than v" + + "ersion 4") + }(jQuery), + function (a) { + "use strict"; + function b() { + var a = document.createElement("bootstrap"), + b = { + WebkitTransition: "webkitTransitionEnd", + MozTransition: "transitionend", + OTransition: "oTransitionEnd otransitionend", + transition: "transitionend" + }; + for (var c in b) + if (void 0 !== a.style[c]) + return {end: b[c]}; + return !1 + } + a.fn.emulateTransitionEnd = function (b) { + var c = !1, + d = this; + a(this).one("bsTransitionEnd", function () { + c = !0 + }); + var e = function () { + c || a(d).trigger(a.support.transition.end) + }; + return setTimeout(e, b), + this + }, + a(function () { + a.support.transition = b(), + a.support.transition && (a.event.special.bsTransitionEnd = { + bindType: a.support.transition.end, + delegateType: a.support.transition.end, + handle: function (b) { + if (a(b.target).is(this)) + return b.handleObj.handler.apply(this, arguments) + } + }) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var c = a(this), + e = c.data("bs.alert"); + e || c.data("bs.alert", e = new d(this)), + "string" == typeof b && e[b].call(c) + }) + } + var c = '[data-dismiss="alert"]', + d = function (b) { + a(b).on("click", c, this.close) + }; + d.VERSION = "3.3.7", + d.TRANSITION_DURATION = 150, + d.prototype.close = function (b) { + function c() { + g + .detach() + .trigger("closed.bs.alert") + .remove() + } + var e = a(this), + f = e.attr("data-target"); + f || (f = e.attr("href"), f = f && f.replace(/.*(?=#[^\s]*$)/, "")); + var g = a("#" === f + ? [] + : f); + b && b.preventDefault(), + g.length || (g = e.closest(".alert")), + g.trigger(b = a.Event("close.bs.alert")), + b.isDefaultPrevented() || (g.removeClass("in"), a.support.transition && g.hasClass("fade") + ? g.one("bsTransitionEnd", c).emulateTransitionEnd(d.TRANSITION_DURATION) + : c()) + }; + var e = a.fn.alert; + a.fn.alert = b, + a.fn.alert.Constructor = d, + a.fn.alert.noConflict = function () { + return a.fn.alert = e, + this + }, + a(document).on("click.bs.alert.data-api", c, d.prototype.close) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.button"), + f = "object" == typeof b && b; + e || d.data("bs.button", e = new c(this, f)), + "toggle" == b + ? e.toggle() + : b && e.setState(b) + }) + } + var c = function (b, d) { + this.$element = a(b), + this.options = a.extend({}, c.DEFAULTS, d), + this.isLoading = !1 + }; + c.VERSION = "3.3.7", + c.DEFAULTS = { + loadingText: "loading..." + }, + c.prototype.setState = function (b) { + var c = "disabled", + d = this.$element, + e = d.is("input") + ? "val" + : "html", + f = d.data(); + b += "Text", + null == f.resetText && d.data("resetText", d[e]()), + setTimeout(a.proxy(function () { + d[e](null == f[b] + ? this.options[b] + : f[b]), + "loadingText" == b + ? (this.isLoading = !0, d.addClass(c).attr(c, c).prop(c, !0)) + : this.isLoading && (this.isLoading = !1, d.removeClass(c).removeAttr(c).prop(c, !1)) + }, this), 0) + }, + c.prototype.toggle = function () { + var a = !0, + b = this + .$element + .closest('[data-toggle="buttons"]'); + if (b.length) { + var c = this + .$element + .find("input"); + "radio" == c.prop("type") + ? (c.prop("checked") && (a = !1), b.find(".active").removeClass("active"), this.$element.addClass("active")) + : "checkbox" == c.prop("type") && (c.prop("checked") !== this.$element.hasClass("active") && (a = !1), this.$element.toggleClass("active")), + c.prop("checked", this.$element.hasClass("active")), + a && c.trigger("change") + } else + this + .$element + .attr("aria-pressed", !this.$element.hasClass("active")), + this + .$element + .toggleClass("active") + }; + var d = a.fn.button; + a.fn.button = b, + a.fn.button.Constructor = c, + a.fn.button.noConflict = function () { + return a.fn.button = d, + this + }, + a(document).on("click.bs.button.data-api", '[data-toggle^="button"]', function (c) { + var d = a(c.target).closest(".btn"); + b.call(d, "toggle"), + a(c.target).is('input[type="radio"], input[type="checkbox"]') || (c.preventDefault(), d.is("input,button") + ? d.trigger("focus") + : d.find("input:visible,button:visible").first().trigger("focus")) + }) + .on("focus.bs.button.data-api blur.bs.button.data-api", '[data-toggle^="button"]', function (b) { + a(b.target) + .closest(".btn") + .toggleClass("focus", /^focus(in)?$/.test(b.type)) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.carousel"), + f = a.extend({}, c.DEFAULTS, d.data(), "object" == typeof b && b), + g = "string" == typeof b + ? b + : f.slide; + e || d.data("bs.carousel", e = new c(this, f)), + "number" == typeof b + ? e.to(b) + : g + ? e[g]() + : f.interval && e + .pause() + .cycle() + }) + } + var c = function (b, c) { + this.$element = a(b), + this.$indicators = this + .$element + .find(".carousel-indicators"), + this.options = c, + this.paused = null, + this.sliding = null, + this.interval = null, + this.$active = null, + this.$items = null, + this.options.keyboard && this + .$element + .on("keydown.bs.carousel", a.proxy(this.keydown, this)), + "hover" == this.options.pause && !("ontouchstart" in document.documentElement) && this + .$element + .on("mouseenter.bs.carousel", a.proxy(this.pause, this)) + .on("mouseleave.bs.carousel", a.proxy(this.cycle, this)) + }; + c.VERSION = "3.3.7", + c.TRANSITION_DURATION = 600, + c.DEFAULTS = { + interval: 5e3, + pause: "hover", + wrap: !0, + keyboard: !0 + }, + c.prototype.keydown = function (a) { + if (!/input|textarea/i.test(a.target.tagName)) { + switch (a.which) { + case 37: + this.prev(); + break; + case 39: + this.next(); + break; + default: + return + } + a.preventDefault() + } + }, + c.prototype.cycle = function (b) { + return b || (this.paused = !1), + this.interval && clearInterval(this.interval), + this.options.interval && !this.paused && (this.interval = setInterval(a.proxy(this.next, this), this.options.interval)), + this + }, + c.prototype.getItemIndex = function (a) { + return this.$items = a + .parent() + .children(".item"), + this + .$items + .index(a || this.$active) + }, + c.prototype.getItemForDirection = function (a, b) { + var c = this.getItemIndex(b), + d = "prev" == a && 0 === c || "next" == a && c == this.$items.length - 1; + if (d && !this.options.wrap) + return b; + var e = "prev" == a + ? -1 + : 1, + f = (c + e) % this.$items.length; + return this + .$items + .eq(f) + }, + c.prototype.to = function (a) { + var b = this, + c = this.getItemIndex(this.$active = this.$element.find(".item.active")); + if (!(a > this.$items.length - 1 || a < 0)) + return this.sliding + ? this.$element.one("slid.bs.carousel", function () { + b.to(a) + }) + : c == a + ? this.pause().cycle() + : this.slide(a > c + ? "next" + : "prev", this.$items.eq(a)) + }, + c.prototype.pause = function (b) { + return b || (this.paused = !0), + this + .$element + .find(".next, .prev") + .length && a.support.transition && (this.$element.trigger(a.support.transition.end), this.cycle(!0)), + this.interval = clearInterval(this.interval), + this + }, + c.prototype.next = function () { + if (!this.sliding) + return this.slide("next") + }, + c.prototype.prev = function () { + if (!this.sliding) + return this.slide("prev") + }, + c.prototype.slide = function (b, d) { + var e = this + .$element + .find(".item.active"), + f = d || this.getItemForDirection(b, e), + g = this.interval, + h = "next" == b + ? "left" + : "right", + i = this; + if (f.hasClass("active")) + return this.sliding = !1; + var j = f[0], + k = a.Event("slide.bs.carousel", { + relatedTarget: j, + direction: h + }); + if (this.$element.trigger(k), !k.isDefaultPrevented()) { + if (this.sliding = !0, g && this.pause(), this.$indicators.length) { + this + .$indicators + .find(".active") + .removeClass("active"); + var l = a(this.$indicators.children()[this.getItemIndex(f)]); + l && l.addClass("active") + } + var m = a.Event("slid.bs.carousel", { + relatedTarget: j, + direction: h + }); + return a.support.transition && this + .$element + .hasClass("slide") + ? (f.addClass(b), f[0].offsetWidth, e.addClass(h), f.addClass(h), e.one("bsTransitionEnd", function () { + f + .removeClass([b, h].join(" ")) + .addClass("active"), + e.removeClass(["active", h].join(" ")), + i.sliding = !1, + setTimeout(function () { + i + .$element + .trigger(m) + }, 0) + }).emulateTransitionEnd(c.TRANSITION_DURATION)) + : (e.removeClass("active"), f.addClass("active"), this.sliding = !1, this.$element.trigger(m)), + g && this.cycle(), + this + } + }; + var d = a.fn.carousel; + a.fn.carousel = b, + a.fn.carousel.Constructor = c, + a.fn.carousel.noConflict = function () { + return a.fn.carousel = d, + this + }; + var e = function (c) { + var d, + e = a(this), + f = a(e.attr("data-target") || (d = e.attr("href")) && d.replace(/.*(?=#[^\s]+$)/, "")); + if (f.hasClass("carousel")) { + var g = a.extend({}, f.data(), e.data()), + h = e.attr("data-slide-to"); + h && (g.interval = !1), + b.call(f, g), + h && f + .data("bs.carousel") + .to(h), + c.preventDefault() + } + }; + a(document) + .on("click.bs.carousel.data-api", "[data-slide]", e) + .on("click.bs.carousel.data-api", "[data-slide-to]", e), + a(window).on("load", function () { + a('[data-ride="carousel"]') + .each(function () { + var c = a(this); + b.call(c, c.data()) + }) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + var c, + d = b.attr("data-target") || (c = b.attr("href")) && c.replace(/.*(?=#[^\s]+$)/, ""); + return a(d) + } + function c(b) { + return this.each(function () { + var c = a(this), + e = c.data("bs.collapse"), + f = a.extend({}, d.DEFAULTS, c.data(), "object" == typeof b && b); + !e && f.toggle && /show|hide/.test(b) && (f.toggle = !1), + e || c.data("bs.collapse", e = new d(this, f)), + "string" == typeof b && e[b]() + }) + } + var d = function (b, c) { + this.$element = a(b), + this.options = a.extend({}, d.DEFAULTS, c), + this.$trigger = a('[data-toggle="collapse"][href="#' + b.id + '"],[data-toggle="collapse"][data-target="#' + b.id + '"]'), + this.transitioning = null, + this.options.parent + ? this.$parent = this.getParent() + : this.addAriaAndCollapsedClass(this.$element, this.$trigger), + this.options.toggle && this.toggle() + }; + d.VERSION = "3.3.7", + d.TRANSITION_DURATION = 350, + d.DEFAULTS = { + toggle: !0 + }, + d.prototype.dimension = function () { + var a = this + .$element + .hasClass("width"); + return a + ? "width" + : "height" + }, + d.prototype.show = function () { + if (!this.transitioning && !this.$element.hasClass("in")) { + var b, + e = this.$parent && this + .$parent + .children(".panel") + .children(".in, .collapsing"); + if (!(e && e.length && (b = e.data("bs.collapse"), b && b.transitioning))) { + var f = a.Event("show.bs.collapse"); + if (this.$element.trigger(f), !f.isDefaultPrevented()) { + e && e.length && (c.call(e, "hide"), b || e.data("bs.collapse", null)); + var g = this.dimension(); + this + .$element + .removeClass("collapse") + .addClass("collapsing")[g](0) + .attr("aria-expanded", !0), + this + .$trigger + .removeClass("collapsed") + .attr("aria-expanded", !0), + this.transitioning = 1; + var h = function () { + this + .$element + .removeClass("collapsing") + .addClass("collapse in")[g](""), + this.transitioning = 0, + this + .$element + .trigger("shown.bs.collapse") + }; + if (!a.support.transition) + return h.call(this); + var i = a.camelCase(["scroll", g].join("-")); + this + .$element + .one("bsTransitionEnd", a.proxy(h, this)) + .emulateTransitionEnd(d.TRANSITION_DURATION)[g](this.$element[0][i]) + } + } + } + }, + d.prototype.hide = function () { + if (!this.transitioning && this.$element.hasClass("in")) { + var b = a.Event("hide.bs.collapse"); + if (this.$element.trigger(b), !b.isDefaultPrevented()) { + var c = this.dimension(); + this.$element[c](this.$element[c]())[0].offsetHeight, + this + .$element + .addClass("collapsing") + .removeClass("collapse in") + .attr("aria-expanded", !1), + this + .$trigger + .addClass("collapsed") + .attr("aria-expanded", !1), + this.transitioning = 1; + var e = function () { + this.transitioning = 0, + this + .$element + .removeClass("collapsing") + .addClass("collapse") + .trigger("hidden.bs.collapse") + }; + return a.support.transition + ? void this + .$element[c](0) + .one("bsTransitionEnd", a.proxy(e, this)) + .emulateTransitionEnd(d.TRANSITION_DURATION) + : e.call(this) + } + } + }, + d.prototype.toggle = function () { + this[this + .$element + .hasClass("in") + ? "hide" + : "show"]() + }, + d.prototype.getParent = function () { + return a(this.options.parent) + .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]') + .each(a.proxy(function (c, d) { + var e = a(d); + this.addAriaAndCollapsedClass(b(e), e) + }, this)) + .end() + }, + d.prototype.addAriaAndCollapsedClass = function (a, b) { + var c = a.hasClass("in"); + a.attr("aria-expanded", c), + b + .toggleClass("collapsed", !c) + .attr("aria-expanded", c) + }; + var e = a.fn.collapse; + a.fn.collapse = c, + a.fn.collapse.Constructor = d, + a.fn.collapse.noConflict = function () { + return a.fn.collapse = e, + this + }, + a(document).on("click.bs.collapse.data-api", '[data-toggle="collapse"]', function (d) { + var e = a(this); + e.attr("data-target") || d.preventDefault(); + var f = b(e), + g = f.data("bs.collapse"), + h = g + ? "toggle" + : e.data(); + c.call(f, h) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + var c = b.attr("data-target"); + c || (c = b.attr("href"), c = c && /#[A-Za-z]/.test(c) && c.replace(/.*(?=#[^\s]*$)/, "")); + var d = c && a(c); + return d && d.length + ? d + : b.parent() + } + function c(c) { + c && 3 === c.which || (a(e).remove(), a(f).each(function () { + var d = a(this), + e = b(d), + f = { + relatedTarget: this + }; + e.hasClass("open") && (c && "click" == c.type && /input|textarea/i.test(c.target.tagName) && a.contains(e[0], c.target) || (e.trigger(c = a.Event("hide.bs.dropdown", f)), c.isDefaultPrevented() || (d.attr("aria-expanded", "false"), e.removeClass("open").trigger(a.Event("hidden.bs.dropdown", f))))) + })) + } + function d(b) { + return this.each(function () { + var c = a(this), + d = c.data("bs.dropdown"); + d || c.data("bs.dropdown", d = new g(this)), + "string" == typeof b && d[b].call(c) + }) + } + var e = ".dropdown-backdrop", + f = '[data-toggle="dropdown"]', + g = function (b) { + a(b).on("click.bs.dropdown", this.toggle) + }; + g.VERSION = "3.3.7", + g.prototype.toggle = function (d) { + var e = a(this); + if (!e.is(".disabled, :disabled")) { + var f = b(e), + g = f.hasClass("open"); + if (c(), !g) { + "ontouchstart" in document.documentElement && !f + .closest(".navbar-nav") + .length && a(document.createElement("div")) + .addClass("dropdown-backdrop") + .insertAfter(a(this)) + .on("click", c); + var h = { + relatedTarget: this + }; + if (f.trigger(d = a.Event("show.bs.dropdown", h)), d.isDefaultPrevented()) + return; + e + .trigger("focus") + .attr("aria-expanded", "true"), + f + .toggleClass("open") + .trigger(a.Event("shown.bs.dropdown", h)) + } + return !1 + } + }, + g.prototype.keydown = function (c) { + if (/(38|40|27|32)/.test(c.which) && !/input|textarea/i.test(c.target.tagName)) { + var d = a(this); + if (c.preventDefault(), c.stopPropagation(), !d.is(".disabled, :disabled")) { + var e = b(d), + g = e.hasClass("open"); + if (!g && 27 != c.which || g && 27 == c.which) + return 27 == c.which && e.find(f).trigger("focus"), + d.trigger("click"); + var h = " li:not(.disabled):visible a", + i = e.find(".dropdown-menu" + h); + if (i.length) { + var j = i.index(c.target); + 38 == c.which && j > 0 && j--, + 40 == c.which && j < i.length - 1 && j++, ~ j || (j = 0), + i + .eq(j) + .trigger("focus") + } + } + } + }; + var h = a.fn.dropdown; + a.fn.dropdown = d, + a.fn.dropdown.Constructor = g, + a.fn.dropdown.noConflict = function () { + return a.fn.dropdown = h, + this + }, + a(document) + .on("click.bs.dropdown.data-api", c) + .on("click.bs.dropdown.data-api", ".dropdown form", function (a) { + a.stopPropagation() + }) + .on("click.bs.dropdown.data-api", f, g.prototype.toggle) + .on("keydown.bs.dropdown.data-api", f, g.prototype.keydown) + .on("keydown.bs.dropdown.data-api", ".dropdown-menu", g.prototype.keydown) +}(jQuery), + function (a) { + "use strict"; + function b(b, d) { + return this.each(function () { + var e = a(this), + f = e.data("bs.modal"), + g = a.extend({}, c.DEFAULTS, e.data(), "object" == typeof b && b); + f || e.data("bs.modal", f = new c(this, g)), + "string" == typeof b + ? f[b](d) + : g.show && f.show(d) + }) + } + var c = function (b, c) { + this.options = c, + this.$body = a(document.body), + this.$element = a(b), + this.$dialog = this + .$element + .find(".modal-dialog"), + this.$backdrop = null, + this.isShown = null, + this.originalBodyPad = null, + this.scrollbarWidth = 0, + this.ignoreBackdropClick = !1, + this.options.remote && this + .$element + .find(".modal-content") + .load(this.options.remote, a.proxy(function () { + this + .$element + .trigger("loaded.bs.modal") + }, this)) + }; + c.VERSION = "3.3.7", + c.TRANSITION_DURATION = 300, + c.BACKDROP_TRANSITION_DURATION = 150, + c.DEFAULTS = { + backdrop: !0, + keyboard: !0, + show: !0 + }, + c.prototype.toggle = function (a) { + return this.isShown + ? this.hide() + : this.show(a) + }, + c.prototype.show = function (b) { + var d = this, + e = a.Event("show.bs.modal", {relatedTarget: b}); + this + .$element + .trigger(e), + this.isShown || e.isDefaultPrevented() || (this.isShown = !0, this.checkScrollbar(), this.setScrollbar(), this.$body.addClass("modal-open"), this.escape(), this.resize(), this.$element.on("click.dismiss.bs.modal", '[data-dismiss="modal"]', a.proxy(this.hide, this)), this.$dialog.on("mousedown.dismiss.bs.modal", function () { + d + .$element + .one("mouseup.dismiss.bs.modal", function (b) { + a(b.target).is(d.$element) && (d.ignoreBackdropClick = !0) + }) + }), this.backdrop(function () { + var e = a.support.transition && d + .$element + .hasClass("fade"); + d + .$element + .parent() + .length || d + .$element + .appendTo(d.$body), + d + .$element + .show() + .scrollTop(0), + d.adjustDialog(), + e && d.$element[0].offsetWidth, + d + .$element + .addClass("in"), + d.enforceFocus(); + var f = a.Event("shown.bs.modal", {relatedTarget: b}); + e + ? d + .$dialog + .one("bsTransitionEnd", function () { + d + .$element + .trigger("focus") + .trigger(f) + }) + .emulateTransitionEnd(c.TRANSITION_DURATION) + : d + .$element + .trigger("focus") + .trigger(f) + })) + }, + c.prototype.hide = function (b) { + b && b.preventDefault(), + b = a.Event("hide.bs.modal"), + this + .$element + .trigger(b), + this.isShown && !b.isDefaultPrevented() && (this.isShown = !1, this.escape(), this.resize(), a(document).off("focusin.bs.modal"), this.$element.removeClass("in").off("click.dismiss.bs.modal").off("mouseup.dismiss.bs.modal"), this.$dialog.off("mousedown.dismiss.bs.modal"), a.support.transition && this.$element.hasClass("fade") + ? this.$element.one("bsTransitionEnd", a.proxy(this.hideModal, this)).emulateTransitionEnd(c.TRANSITION_DURATION) + : this.hideModal()) + }, + c.prototype.enforceFocus = function () { + a(document) + .off("focusin.bs.modal") + .on("focusin.bs.modal", a.proxy(function (a) { + document === a.target || this.$element[0] === a.target || this + .$element + .has(a.target) + .length || this + .$element + .trigger("focus") + }, this)) + }, + c.prototype.escape = function () { + this.isShown && this.options.keyboard + ? this + .$element + .on("keydown.dismiss.bs.modal", a.proxy(function (a) { + 27 == a.which && this.hide() + }, this)) + : this.isShown || this + .$element + .off("keydown.dismiss.bs.modal") + }, + c.prototype.resize = function () { + this.isShown + ? a(window).on("resize.bs.modal", a.proxy(this.handleUpdate, this)) + : a(window).off("resize.bs.modal") + }, + c.prototype.hideModal = function () { + var a = this; + this + .$element + .hide(), + this.backdrop(function () { + a + .$body + .removeClass("modal-open"), + a.resetAdjustments(), + a.resetScrollbar(), + a + .$element + .trigger("hidden.bs.modal") + }) + }, + c.prototype.removeBackdrop = function () { + this.$backdrop && this + .$backdrop + .remove(), + this.$backdrop = null + }, + c.prototype.backdrop = function (b) { + var d = this, + e = this + .$element + .hasClass("fade") + ? "fade" + : ""; + if (this.isShown && this.options.backdrop) { + var f = a.support.transition && e; + if (this.$backdrop = a(document.createElement("div")).addClass("modal-backdrop " + e).appendTo(this.$body), this.$element.on("click.dismiss.bs.modal", a.proxy(function (a) { + return this.ignoreBackdropClick + ? void(this.ignoreBackdropClick = !1) + : void(a.target === a.currentTarget && ("static" == this.options.backdrop + ? this.$element[0].focus() + : this.hide())) + }, this)), f && this.$backdrop[0].offsetWidth, this.$backdrop.addClass("in"), !b) + return; + f + ? this + .$backdrop + .one("bsTransitionEnd", b) + .emulateTransitionEnd(c.BACKDROP_TRANSITION_DURATION) + : b() + } else if (!this.isShown && this.$backdrop) { + this + .$backdrop + .removeClass("in"); + var g = function () { + d.removeBackdrop(), + b && b() + }; + a.support.transition && this + .$element + .hasClass("fade") + ? this + .$backdrop + .one("bsTransitionEnd", g) + .emulateTransitionEnd(c.BACKDROP_TRANSITION_DURATION) + : g() + } else + b && b() + }, + c.prototype.handleUpdate = function () { + this.adjustDialog() + }, + c.prototype.adjustDialog = function () { + var a = this.$element[0].scrollHeight > document.documentElement.clientHeight; + this + .$element + .css({ + paddingLeft: !this.bodyIsOverflowing && a + ? this.scrollbarWidth + : "", + paddingRight: this.bodyIsOverflowing && !a + ? this.scrollbarWidth + : "" + }) + }, + c.prototype.resetAdjustments = function () { + this + .$element + .css({paddingLeft: "", paddingRight: ""}) + }, + c.prototype.checkScrollbar = function () { + var a = window.innerWidth; + if (!a) { + var b = document + .documentElement + .getBoundingClientRect(); + a = b.right - Math.abs(b.left) + } + this.bodyIsOverflowing = document.body.clientWidth < a, + this.scrollbarWidth = this.measureScrollbar() + }, + c.prototype.setScrollbar = function () { + var a = parseInt(this.$body.css("padding-right") || 0, 10); + this.originalBodyPad = document.body.style.paddingRight || "", + this.bodyIsOverflowing && this + .$body + .css("padding-right", a + this.scrollbarWidth) + }, + c.prototype.resetScrollbar = function () { + this + .$body + .css("padding-right", this.originalBodyPad) + }, + c.prototype.measureScrollbar = function () { + var a = document.createElement("div"); + a.className = "modal-scrollbar-measure", + this + .$body + .append(a); + var b = a.offsetWidth - a.clientWidth; + return this + .$body[0] + .removeChild(a), + b + }; + var d = a.fn.modal; + a.fn.modal = b, + a.fn.modal.Constructor = c, + a.fn.modal.noConflict = function () { + return a.fn.modal = d, + this + }, + a(document).on("click.bs.modal.data-api", '[data-toggle="modal"]', function (c) { + var d = a(this), + e = d.attr("href"), + f = a(d.attr("data-target") || e && e.replace(/.*(?=#[^\s]+$)/, "")), + g = f.data("bs.modal") + ? "toggle" + : a.extend({ + remote: !/#/.test(e) && e + }, f.data(), d.data()); + d.is("a") && c.preventDefault(), + f.one("show.bs.modal", function (a) { + a.isDefaultPrevented() || f.one("hidden.bs.modal", function () { + d.is(":visible") && d.trigger("focus") + }) + }), + b.call(f, g, this) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.tooltip"), + f = "object" == typeof b && b; + !e && /destroy|hide/.test(b) || (e || d.data("bs.tooltip", e = new c(this, f)), "string" == typeof b && e[b]()) + }) + } + var c = function (a, b) { + this.type = null, + this.options = null, + this.enabled = null, + this.timeout = null, + this.hoverState = null, + this.$element = null, + this.inState = null, + this.init("tooltip", a, b) + }; + c.VERSION = "3.3.7", + c.TRANSITION_DURATION = 150, + c.DEFAULTS = { + animation: !0, + placement: "top", + selector: !1, + template: '', + trigger: "hover focus", + title: "", + delay: 0, + html: !1, + container: !1, + viewport: { + selector: "body", + padding: 0 + } + }, + c.prototype.init = function (b, c, d) { + if (this.enabled = !0, this.type = b, this.$element = a(c), this.options = this.getOptions(d), this.$viewport = this.options.viewport && a(a.isFunction(this.options.viewport) + ? this.options.viewport.call(this, this.$element) + : this.options.viewport.selector || this.options.viewport), this.inState = { + click: !1, + hover: !1, + focus: !1 + }, this.$element[0]instanceof document.constructor && !this.options.selector) + throw new Error("`selector` option must be specified when initializing " + this.type + " on the window.document object!"); + for (var e = this.options.trigger.split(" "), f = e.length; f--;) { + var g = e[f]; + if ("click" == g) + this.$element.on("click." + this.type, this.options.selector, a.proxy(this.toggle, this)); + else if ("manual" != g) { + var h = "hover" == g + ? "mouseenter" + : "focusin", + i = "hover" == g + ? "mouseleave" + : "focusout"; + this + .$element + .on(h + "." + this.type, this.options.selector, a.proxy(this.enter, this)), + this + .$element + .on(i + "." + this.type, this.options.selector, a.proxy(this.leave, this)) + } + } + this.options.selector + ? this._options = a.extend({}, this.options, { + trigger: "manual", + selector: "" + }) + : this.fixTitle() + }, + c.prototype.getDefaults = function () { + return c.DEFAULTS + }, + c.prototype.getOptions = function (b) { + return b = a.extend({}, this.getDefaults(), this.$element.data(), b), + b.delay && "number" == typeof b.delay && (b.delay = { + show: b.delay, + hide: b.delay + }), + b + }, + c.prototype.getDelegateOptions = function () { + var b = {}, + c = this.getDefaults(); + return this._options && a.each(this._options, function (a, d) { + c[a] != d && (b[a] = d) + }), + b + }, + c.prototype.enter = function (b) { + var c = b instanceof this.constructor + ? b + : a(b.currentTarget).data("bs." + this.type); + return c || (c = new this.constructor(b.currentTarget, this.getDelegateOptions()), a(b.currentTarget).data("bs." + this.type, c)), + b instanceof a.Event && (c.inState["focusin" == b.type + ? "focus" + : "hover"] = !0), + c + .tip() + .hasClass("in") || "in" == c.hoverState + ? void(c.hoverState = "in") + : (clearTimeout(c.timeout), c.hoverState = "in", c.options.delay && c.options.delay.show + ? void(c.timeout = setTimeout(function () { + "in" == c.hoverState && c.show() + }, c.options.delay.show)) + : c.show()) + }, + c.prototype.isInStateTrue = function () { + for (var a in this.inState) + if (this.inState[a]) + return !0; + return !1 + }, + c.prototype.leave = function (b) { + var c = b instanceof this.constructor + ? b + : a(b.currentTarget).data("bs." + this.type); + if (c || (c = new this.constructor(b.currentTarget, this.getDelegateOptions()), a(b.currentTarget).data("bs." + this.type, c)), b instanceof a.Event && (c.inState["focusout" == b.type + ? "focus" + : "hover"] = !1), !c.isInStateTrue()) + return clearTimeout(c.timeout), + c.hoverState = "out", + c.options.delay && c.options.delay.hide + ? void(c.timeout = setTimeout(function () { + "out" == c.hoverState && c.hide() + }, c.options.delay.hide)) + : c.hide() + }, + c.prototype.show = function () { + var b = a.Event("show.bs." + this.type); + if (this.hasContent() && this.enabled) { + this + .$element + .trigger(b); + var d = a.contains(this.$element[0].ownerDocument.documentElement, this.$element[0]); + if (b.isDefaultPrevented() || !d) + return; + var e = this, + f = this.tip(), + g = this.getUID(this.type); + this.setContent(), + f.attr("id", g), + this + .$element + .attr("aria-describedby", g), + this.options.animation && f.addClass("fade"); + var h = "function" == typeof this.options.placement + ? this + .options + .placement + .call(this, f[0], this.$element[0]) + : this.options.placement, + i = /\s?auto?\s?/i, + j = i.test(h); + j && (h = h.replace(i, "") || "top"), + f + .detach() + .css({top: 0, left: 0, display: "block"}) + .addClass(h) + .data("bs." + this.type, this), + this.options.container + ? f.appendTo(this.options.container) + : f.insertAfter(this.$element), + this + .$element + .trigger("inserted.bs." + this.type); + var k = this.getPosition(), + l = f[0].offsetWidth, + m = f[0].offsetHeight; + if (j) { + var n = h, + o = this.getPosition(this.$viewport); + h = "bottom" == h && k.bottom + m > o.bottom + ? "top" + : "top" == h && k.top - m < o.top + ? "bottom" + : "right" == h && k.right + l > o.width + ? "left" + : "left" == h && k.left - l < o.left + ? "right" + : h, + f + .removeClass(n) + .addClass(h) + } + var p = this.getCalculatedOffset(h, k, l, m); + this.applyPlacement(p, h); + var q = function () { + var a = e.hoverState; + e + .$element + .trigger("shown.bs." + e.type), + e.hoverState = null, + "out" == a && e.leave(e) + }; + a.support.transition && this + .$tip + .hasClass("fade") + ? f + .one("bsTransitionEnd", q) + .emulateTransitionEnd(c.TRANSITION_DURATION) + : q() + } + }, + c.prototype.applyPlacement = function (b, c) { + var d = this.tip(), + e = d[0].offsetWidth, + f = d[0].offsetHeight, + g = parseInt(d.css("margin-top"), 10), + h = parseInt(d.css("margin-left"), 10); + isNaN(g) && (g = 0), + isNaN(h) && (h = 0), + b.top += g, + b.left += h, + a + .offset + .setOffset(d[0], a.extend({ + using: function (a) { + d.css({ + top: Math.round(a.top), + left: Math.round(a.left) + }) + } + }, b), 0), + d.addClass("in"); + var i = d[0].offsetWidth, + j = d[0].offsetHeight; + "top" == c && j != f && (b.top = b.top + f - j); + var k = this.getViewportAdjustedDelta(c, b, i, j); + k.left + ? b.left += k.left + : b.top += k.top; + var l = /top|bottom/.test(c), + m = l + ? 2 * k.left - e + i + : 2 * k.top - f + j, + n = l + ? "offsetWidth" + : "offsetHeight"; + d.offset(b), + this.replaceArrow(m, d[0][n], l) + }, + c.prototype.replaceArrow = function (a, b, c) { + this + .arrow() + .css(c + ? "left" + : "top", 50 * (1 - a / b) + "%") + .css(c + ? "top" + : "left", "") + }, + c.prototype.setContent = function () { + var a = this.tip(), + b = this.getTitle(); + a.find(".tooltip-inner")[this.options.html + ? "html" + : "text"](b), + a.removeClass("fade in top bottom left right") + }, + c.prototype.hide = function (b) { + function d() { + "in" != e.hoverState && f.detach(), + e.$element && e + .$element + .removeAttr("aria-describedby") + .trigger("hidden.bs." + e.type), + b && b() + } + var e = this, + f = a(this.$tip), + g = a.Event("hide.bs." + this.type); + if (this.$element.trigger(g), !g.isDefaultPrevented()) + return f.removeClass("in"), + a.support.transition && f.hasClass("fade") + ? f.one("bsTransitionEnd", d).emulateTransitionEnd(c.TRANSITION_DURATION) + : d(), + this.hoverState = null, + this + }, + c.prototype.fixTitle = function () { + var a = this.$element; + (a.attr("title") || "string" != typeof a.attr("data-original-title")) && a.attr("data-original-title", a.attr("title") || "").attr("title", "") + }, + c.prototype.hasContent = function () { + return this.getTitle() + }, + c.prototype.getPosition = function (b) { + b = b || this.$element; + var c = b[0], + d = "BODY" == c.tagName, + e = c.getBoundingClientRect(); + null == e.width && (e = a.extend({}, e, { + width: e.right - e.left, + height: e.bottom - e.top + })); + var f = window.SVGElement && c instanceof window.SVGElement, + g = d + ? { + top: 0, + left: 0 + } + : f + ? null + : b.offset(), + h = { + scroll: d + ? document.documentElement.scrollTop || document.body.scrollTop + : b.scrollTop() + }, + i = d + ? { + width: a(window).width(), + height: a(window).height() + } + : null; + return a.extend({}, e, h, i, g) + }, + c.prototype.getCalculatedOffset = function (a, b, c, d) { + return "bottom" == a + ? { + top: b.top + b.height, + left: b.left + b.width / 2 - c / 2 + } + : "top" == a + ? { + top: b.top - d, + left: b.left + b.width / 2 - c / 2 + } + : "left" == a + ? { + top: b.top + b.height / 2 - d / 2, + left: b.left - c + } + : { + top: b.top + b.height / 2 - d / 2, + left: b.left + b.width + } + }, + c.prototype.getViewportAdjustedDelta = function (a, b, c, d) { + var e = { + top: 0, + left: 0 + }; + if (!this.$viewport) + return e; + var f = this.options.viewport && this.options.viewport.padding || 0, + g = this.getPosition(this.$viewport); + if (/right|left/.test(a)) { + var h = b.top - f - g.scroll, + i = b.top + f - g.scroll + d; + h < g.top + ? e.top = g.top - h + : i > g.top + g.height && (e.top = g.top + g.height - i) + } else { + var j = b.left - f, + k = b.left + f + c; + j < g.left + ? e.left = g.left - j + : k > g.right && (e.left = g.left + g.width - k) + } + return e + }, + c.prototype.getTitle = function () { + var a, + b = this.$element, + c = this.options; + return a = b.attr("data-original-title") || ("function" == typeof c.title + ? c.title.call(b[0]) + : c.title) + }, + c.prototype.getUID = function (a) { + do + a += ~~ (1e6 * Math.random()); + while (document.getElementById(a)); + return a + }, + c.prototype.tip = function () { + if (!this.$tip && (this.$tip = a(this.options.template), 1 != this.$tip.length)) + throw new Error(this.type + " `template` option must consist of exactly 1 top-level element!"); + return this.$tip + }, + c.prototype.arrow = function () { + return this.$arrow = this.$arrow || this + .tip() + .find(".tooltip-arrow") + }, + c.prototype.enable = function () { + this.enabled = !0 + }, + c.prototype.disable = function () { + this.enabled = !1 + }, + c.prototype.toggleEnabled = function () { + this.enabled = !this.enabled + }, + c.prototype.toggle = function (b) { + var c = this; + b && (c = a(b.currentTarget).data("bs." + this.type), c || (c = new this.constructor(b.currentTarget, this.getDelegateOptions()), a(b.currentTarget).data("bs." + this.type, c))), + b + ? (c.inState.click = !c.inState.click, c.isInStateTrue() + ? c.enter(c) + : c.leave(c)) + : c + .tip() + .hasClass("in") + ? c.leave(c) + : c.enter(c) + }, + c.prototype.destroy = function () { + var a = this; + clearTimeout(this.timeout), + this.hide(function () { + a + .$element + .off("." + a.type) + .removeData("bs." + a.type), + a.$tip && a + .$tip + .detach(), + a.$tip = null, + a.$arrow = null, + a.$viewport = null, + a.$element = null + }) + }; + var d = a.fn.tooltip; + a.fn.tooltip = b, + a.fn.tooltip.Constructor = c, + a.fn.tooltip.noConflict = function () { + return a.fn.tooltip = d, + this + } +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.popover"), + f = "object" == typeof b && b; + !e && /destroy|hide/.test(b) || (e || d.data("bs.popover", e = new c(this, f)), "string" == typeof b && e[b]()) + }) + } + var c = function (a, b) { + this.init("popover", a, b) + }; + if (!a.fn.tooltip) + throw new Error("Popover requires tooltip.js"); + c.VERSION = "3.3.7", + c.DEFAULTS = a.extend({}, a.fn.tooltip.Constructor.DEFAULTS, { + placement: "right", + trigger: "click", + content: "", + template: '' + }), + c.prototype = a.extend({}, a.fn.tooltip.Constructor.prototype), + c.prototype.constructor = c, + c.prototype.getDefaults = function () { + return c.DEFAULTS + }, + c.prototype.setContent = function () { + var a = this.tip(), + b = this.getTitle(), + c = this.getContent(); + a.find(".popover-title")[this.options.html + ? "html" + : "text"](b), + a + .find(".popover-content") + .children() + .detach() + .end()[this.options.html + ? "string" == typeof c + ? "html" + : "append" + : "text"](c), + a.removeClass("fade top bottom left right in"), + a + .find(".popover-title") + .html() || a + .find(".popover-title") + .hide() + }, + c.prototype.hasContent = function () { + return this.getTitle() || this.getContent() + }, + c.prototype.getContent = function () { + var a = this.$element, + b = this.options; + return a.attr("data-content") || ("function" == typeof b.content + ? b.content.call(a[0]) + : b.content) + }, + c.prototype.arrow = function () { + return this.$arrow = this.$arrow || this + .tip() + .find(".arrow") + }; + var d = a.fn.popover; + a.fn.popover = b, + a.fn.popover.Constructor = c, + a.fn.popover.noConflict = function () { + return a.fn.popover = d, + this + } +}(jQuery), + function (a) { + "use strict"; + function b(c, d) { + this.$body = a(document.body), + this.$scrollElement = a(a(c).is(document.body) + ? window + : c), + this.options = a.extend({}, b.DEFAULTS, d), + this.selector = (this.options.target || "") + " .nav li > a", + this.offsets = [], + this.targets = [], + this.activeTarget = null, + this.scrollHeight = 0, + this + .$scrollElement + .on("scroll.bs.scrollspy", a.proxy(this.process, this)), + this.refresh(), + this.process() + } + function c(c) { + return this.each(function () { + var d = a(this), + e = d.data("bs.scrollspy"), + f = "object" == typeof c && c; + e || d.data("bs.scrollspy", e = new b(this, f)), + "string" == typeof c && e[c]() + }) + } + b.VERSION = "3.3.7", + b.DEFAULTS = { + offset: 10 + }, + b.prototype.getScrollHeight = function () { + return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight) + }, + b.prototype.refresh = function () { + var b = this, + c = "offset", + d = 0; + this.offsets = [], + this.targets = [], + this.scrollHeight = this.getScrollHeight(), + a.isWindow(this.$scrollElement[0]) || (c = "position", d = this.$scrollElement.scrollTop()), + this + .$body + .find(this.selector) + .map(function () { + var b = a(this), + e = b.data("target") || b.attr("href"), + f = /^#./.test(e) && a(e); + return f && f.length && f.is(":visible") && [ + [ + f[c]().top + d, + e + ] + ] || null + }) + .sort(function (a, b) { + return a[0] - b[0] + }) + .each(function () { + b + .offsets + .push(this[0]), + b + .targets + .push(this[1]) + }) + }, + b.prototype.process = function () { + var a, + b = this + .$scrollElement + .scrollTop() + this.options.offset, + c = this.getScrollHeight(), + d = this.options.offset + c - this + .$scrollElement + .height(), + e = this.offsets, + f = this.targets, + g = this.activeTarget; + if (this.scrollHeight != c && this.refresh(), b >= d) + return g != (a = f[f.length - 1]) && this.activate(a); + if (g && b < e[0]) + return this.activeTarget = null, + this.clear(); + for (a = e.length; a--;) + g != f[a] && b >= e[a] && (void 0 === e[a + 1] || b < e[a + 1]) && this.activate(f[a]) + }, + b.prototype.activate = function (b) { + this.activeTarget = b, + this.clear(); + var c = this.selector + '[data-target="' + b + '"],' + this.selector + '[href="' + b + '"]', + d = a(c) + .parents("li") + .addClass("active"); + d + .parent(".dropdown-menu") + .length && (d = d.closest("li.dropdown").addClass("active")), + d.trigger("activate.bs.scrollspy") + }, + b.prototype.clear = function () { + a(this.selector) + .parentsUntil(this.options.target, ".active") + .removeClass("active") + }; + var d = a.fn.scrollspy; + a.fn.scrollspy = c, + a.fn.scrollspy.Constructor = b, + a.fn.scrollspy.noConflict = function () { + return a.fn.scrollspy = d, + this + }, + a(window).on("load.bs.scrollspy.data-api", function () { + a('[data-spy="scroll"]') + .each(function () { + var b = a(this); + c.call(b, b.data()) + }) + }) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.tab"); + e || d.data("bs.tab", e = new c(this)), + "string" == typeof b && e[b]() + }) + } + var c = function (b) { + this.element = a(b) + }; + c.VERSION = "3.3.7", + c.TRANSITION_DURATION = 150, + c.prototype.show = function () { + var b = this.element, + c = b.closest("ul:not(.dropdown-menu)"), + d = b.data("target"); + if (d || (d = b.attr("href"), d = d && d.replace(/.*(?=#[^\s]*$)/, "")), !b.parent("li").hasClass("active")) { + var e = c.find(".active:last a"), + f = a.Event("hide.bs.tab", {relatedTarget: b[0]}), + g = a.Event("show.bs.tab", {relatedTarget: e[0]}); + if (e.trigger(f), b.trigger(g), !g.isDefaultPrevented() && !f.isDefaultPrevented()) { + var h = a(d); + this.activate(b.closest("li"), c), + this.activate(h, h.parent(), function () { + e.trigger({type: "hidden.bs.tab", relatedTarget: b[0]}), + b.trigger({type: "shown.bs.tab", relatedTarget: e[0]}) + }) + } + } + }, + c.prototype.activate = function (b, d, e) { + function f() { + g + .removeClass("active") + .find("> .dropdown-menu > .active") + .removeClass("active") + .end() + .find('[data-toggle="tab"]') + .attr("aria-expanded", !1), + b + .addClass("active") + .find('[data-toggle="tab"]') + .attr("aria-expanded", !0), + h + ? (b[0].offsetWidth, b.addClass("in")) + : b.removeClass("fade"), + b + .parent(".dropdown-menu") + .length && b + .closest("li.dropdown") + .addClass("active") + .end() + .find('[data-toggle="tab"]') + .attr("aria-expanded", !0), + e && e() + } + var g = d.find("> .active"), + h = e && a.support.transition && (g.length && g.hasClass("fade") || !!d.find("> .fade").length); + g.length && h + ? g + .one("bsTransitionEnd", f) + .emulateTransitionEnd(c.TRANSITION_DURATION) + : f(), + g.removeClass("in") + }; + var d = a.fn.tab; + a.fn.tab = b, + a.fn.tab.Constructor = c, + a.fn.tab.noConflict = function () { + return a.fn.tab = d, + this + }; + var e = function (c) { + c.preventDefault(), + b.call(a(this), "show") + }; + a(document) + .on("click.bs.tab.data-api", '[data-toggle="tab"]', e) + .on("click.bs.tab.data-api", '[data-toggle="pill"]', e) +}(jQuery), + function (a) { + "use strict"; + function b(b) { + return this.each(function () { + var d = a(this), + e = d.data("bs.affix"), + f = "object" == typeof b && b; + e || d.data("bs.affix", e = new c(this, f)), + "string" == typeof b && e[b]() + }) + } + var c = function (b, d) { + this.options = a.extend({}, c.DEFAULTS, d), + this.$target = a(this.options.target) + .on("scroll.bs.affix.data-api", a.proxy(this.checkPosition, this)) + .on("click.bs.affix.data-api", a.proxy(this.checkPositionWithEventLoop, this)), + this.$element = a(b), + this.affixed = null, + this.unpin = null, + this.pinnedOffset = null, + this.checkPosition() + }; + c.VERSION = "3.3.7", + c.RESET = "affix affix-top affix-bottom", + c.DEFAULTS = { + offset: 0, + target: window + }, + c.prototype.getState = function (a, b, c, d) { + var e = this + .$target + .scrollTop(), + f = this + .$element + .offset(), + g = this + .$target + .height(); + if (null != c && "top" == this.affixed) + return e < c && "top"; + if ("bottom" == this.affixed) + return null != c + ? !(e + this.unpin <= f.top) && "bottom" + : !(e + g <= a - d) && "bottom"; + var h = null == this.affixed, + i = h + ? e + : f.top, + j = h + ? g + : b; + return null != c && e <= c + ? "top" + : null != d && i + j >= a - d && "bottom" + }, + c.prototype.getPinnedOffset = function () { + if (this.pinnedOffset) + return this.pinnedOffset; + this + .$element + .removeClass(c.RESET) + .addClass("affix"); + var a = this + .$target + .scrollTop(), + b = this + .$element + .offset(); + return this.pinnedOffset = b.top - a + }, + c.prototype.checkPositionWithEventLoop = function () { + setTimeout(a.proxy(this.checkPosition, this), 1) + }, + c.prototype.checkPosition = function () { + if (this.$element.is(":visible")) { + var b = this + .$element + .height(), + d = this.options.offset, + e = d.top, + f = d.bottom, + g = Math.max(a(document).height(), a(document.body).height()); + "object" != typeof d && (f = e = d), + "function" == typeof e && (e = d.top(this.$element)), + "function" == typeof f && (f = d.bottom(this.$element)); + var h = this.getState(g, b, e, f); + if (this.affixed != h) { + null != this.unpin && this + .$element + .css("top", ""); + var i = "affix" + (h + ? "-" + h + : ""), + j = a.Event(i + ".bs.affix"); + if (this.$element.trigger(j), j.isDefaultPrevented()) + return; + this.affixed = h, + this.unpin = "bottom" == h + ? this.getPinnedOffset() + : null, + this + .$element + .removeClass(c.RESET) + .addClass(i) + .trigger(i.replace("affix", "affixed") + ".bs.affix") + } + "bottom" == h && this + .$element + .offset({ + top: g - b - f + }) + } + }; + var d = a.fn.affix; + a.fn.affix = b, + a.fn.affix.Constructor = c, + a.fn.affix.noConflict = function () { + return a.fn.affix = d, + this + }, + a(window).on("load", function () { + a('[data-spy="affix"]') + .each(function () { + var c = a(this), + d = c.data(); + d.offset = d.offset || {}, + null != d.offsetBottom && (d.offset.bottom = d.offsetBottom), + null != d.offsetTop && (d.offset.top = d.offsetTop), + b.call(c, d) + }) + }) +}(jQuery); \ No newline at end of file diff --git a/assets/js/d3.min.js b/assets/js/d3.min.js new file mode 100644 index 0000000..e47efc6 --- /dev/null +++ b/assets/js/d3.min.js @@ -0,0 +1,15924 @@ +// https://d3js.org Version 4.3.0. Copyright 2016 Mike Bostock. +(function (t, n) { + "object" == typeof exports && "undefined" != typeof module + ? n(exports) + : "function" == typeof define && define.amd + ? define(["exports"], n) + : n(t.d3 = t.d3 || {}) +})(this, function (t) { + "use strict"; + function n(t) { + return function (n, e) { + return Ms(t(n), e) + } + } + function e(t, n, e) { + var r = Math.abs(n - t) / Math.max(0, e), + i = Math.pow(10, Math.floor(Math.log(r) / Math.LN10)), + o = r / i; + return o >= Fs + ? i *= 10 + : o >= Is + ? i *= 5 + : o >= Ys && (i *= 2), + n < t + ? -i + : i + } + function r(t) { + return t.length + } + function i() {} + function o(t, n) { + var e = new i; + if (t instanceof i) + t.each(function (t, n) { + e.set(n, t) + }); + else if (Array.isArray(t)) { + var r, + o = -1, + u = t.length; + if (null == n) + for (; ++o < u;) + e.set(o, t[o]); + else + for (; ++o < u;) + e.set(n(r = t[o], o, t), r) + } else if (t) + for (var a in t) + e.set(a, t[a]); + return e + } + function u() { + return {} + } + function a(t, n, e) { + t[n] = e + } + function c() { + return o() + } + function s(t, n, e) { + t.set(n, e) + } + function f() {} + function l(t, n) { + var e = new f; + if (t instanceof f) + t.each(function (t) { + e.add(t) + }); + else if (t) { + var r = -1, + i = t.length; + if (null == n) + for (; ++r < i;) + e.add(t[r]); + else + for (; ++r < i;) + e.add(n(t[r], r, t)) + } + return e + } + function h(t) { + return + t + } + function p(t) { + return t * t + } + function d(t) { + return t * (2 - t) + } + function v(t) { + return ((t *= 2) <= 1 + ? t * t + : --t * (2 - t) + 1) / 2 + } + function _(t) { + return t * t * t + } + function y(t) { + return-- t * t * t + 1 + } + function g(t) { + return ((t *= 2) <= 1 + ? t * t * t + : (t -= 2) * t * t + 2) / 2 + } + function m(t) { + return 1 - Math.cos(t * Tf) + } + function x(t) { + return Math.sin(t * Tf) + } + function b(t) { + return (1 - Math.cos(Mf * t)) / 2 + } + function w(t) { + return Math.pow(2, 10 * t - 10) + } + function M(t) { + return 1 - Math.pow(2, -10 * t) + } + function T(t) { + return ((t *= 2) <= 1 + ? Math.pow(2, 10 * t - 10) + : 2 - Math.pow(2, 10 - 10 * t)) / 2 + } + function N(t) { + return 1 - Math.sqrt(1 - t * t) + } + function k(t) { + return Math.sqrt(1 - --t * t) + } + function S(t) { + return ((t *= 2) <= 1 + ? 1 - Math.sqrt(1 - t * t) + : Math.sqrt(1 - (t -= 2) * t) + 1) / 2 + } + function A(t) { + return 1 - E(1 - t) + } + function E(t) { + return (t =+ t) < Nf + ? Lf * t * t + : t < Sf + ? Lf * (t -= kf) * t + Af + : t < Cf + ? Lf * (t -= Ef) * t + zf + : Lf * (t -= Pf) * t + qf + } + function C(t) { + return ((t *= 2) <= 1 + ? 1 - E(1 - t) + : E(t - 1) + 1) / 2 + } + function z(t, n) { + return t[0] - n[0] || t[1] - n[1] + } + function P(t) { + for (var n = t.length, e = [ + 0, 1 + ], r = 2, i = 2; i < n; ++i) { + for (; r > 1 && Wf(t[e[r - 2]], t[e[r - 1]], t[i]) <= 0;) + --r; + e[r++] = i + } + return e.slice(0, r) + } + function q() { + this._x0 = this._y0 = this._x1 = this._y1 = null, + this._ = [] + } + function L() { + return new q + } + function R(t, n, e, r) { + if (isNaN(n) || isNaN(e)) + return t; + var i, + o, + u, + a, + c, + s, + f, + l, + h, + p = t._root, + d = { + data: r + }, + v = t._x0, + _ = t._y0, + y = t._x1, + g = t._y1; + if (!p) + return t._root = d, + t; + for (; p.length;) + if ((s = n >= (o = (v + y) / 2)) + ? v = o + : y = o, (f = e >= (u = (_ + g) / 2)) + ? _ = u + : g = u, i = p, !(p = p[l = f << 1 | s])) + return i[l] = d, + t; + if (a =+ t._x.call(null, p.data), c =+ t._y.call(null, p.data), n === a && e === c) + return d.next = p, + i + ? i[l] = d + : t._root = d, + t; + do + i = i + ? i[l] = new Array(4) + : t._root = new Array(4), + (s = n >= (o = (v + y) / 2)) + ? v = o + : y = o, + (f = e >= (u = (_ + g) / 2)) + ? _ = u + : g = u; + while ((l = f << 1 | s) === (h = (c >= u) << 1 | a >= o)); + return i[h] = p, + i[l] = d, + t + } + function U(t) { + var n, + e, + r, + i, + o = t.length, + u = new Array(o), + a = new Array(o), + c = 1 / 0, + s = 1 / 0, + f = -(1 / 0), + l = -(1 / 0); + for (e = 0; e < o; ++e) + isNaN(r =+ this._x.call(null, n = t[e])) || isNaN(i =+ this._y.call(null, n)) || (u[e] = r, a[e] = i, r < c && (c = r), r > f && (f = r), i < s && (s = i), i > l && (l = i)); + for (f < c && (c = this._x0, f = this._x1), l < s && (s = this._y0, l = this._y1), this.cover(c, s).cover(f, l), e = 0; e < o; ++e) + R(this, u[e], a[e], t[e]); + return this + } + function D(t) { + for (var n = 0, e = t.length; n < e; ++n) + this.remove(t[n]); + return this + } + function O(t) { + return t[0] + } + function F(t) { + return t[1] + } + function I(t, n, e) { + var r = new Y(null == n + ? O + : n, null == e + ? F + : e, NaN, NaN, NaN, NaN); + return null == t + ? r + : r.addAll(t) + } + function Y(t, n, e, r, i, o) { + this._x = t, + this._y = n, + this._x0 = e, + this._y0 = r, + this._x1 = i, + this._y1 = o, + this._root = void 0 + } + function B(t) { + for (var n = { + data: t.data + }, e = n; t = t.next;) + e = e.next = { + data: t.data + }; + return n + } + function j(t) { + if (!(t >= 1)) + throw new Error; + this._size = t, + this._call = this._error = null, + this._tasks = [], + this._data = [], + this._waiting = this._active = this._ended = this._start = 0 + } + function H(t) { + if (!t._start) + try { + X(t) + } catch (n) { + if (t._tasks[t._ended + t._active - 1]) + W(t, n); + else if (!t._data) + throw n + } + } + function X(t) { + for (; t._start = t._waiting && t._active < t._size;) { + var n = t._ended + t._active, + e = t._tasks[n], + r = e.length - 1, + i = e[r]; + e[r] = V(t, n), + --t._waiting, + ++t._active, + e = i.apply(null, e), + t._tasks[n] && (t._tasks[n] = e || _l) + } + } + function V(t, n) { + return function (e, r) { + t._tasks[n] && (--t._active, ++t._ended, t._tasks[n] = null, null == t._error && (null != e + ? W(t, e) + : (t._data[n] = r, t._waiting + ? H(t) + : $(t)))) + } + } + function W(t, n) { + var e, + r = t._tasks.length; + for (t._error = n, t._data = void 0, t._waiting = NaN; --r >= 0;) + if ((e = t._tasks[r]) && (t._tasks[r] = null, e.abort)) + try { + e.abort() + } catch (t) {} + t._active = NaN, + $(t) + } + function $(t) { + if (!t._active && t._call) { + var n = t._data; + t._data = void 0, + t._call(t._error, n) + } + } + function Z(t) { + return new j(arguments.length ?+ t : 1 / 0) + } + function G(t) { + return t.innerRadius + } + function J(t) { + return t.outerRadius + } + function Q(t) { + return t.startAngle + } + function K(t) { + return t.endAngle + } + function tt(t) { + return t && t.padAngle + } + function nt(t) { + return t >= 1 + ? xl + : t <= -1 + ? -xl + : Math.asin(t) + } + function et(t, n, e, r, i, o, u, a) { + var c = e - t, + s = r - n, + f = u - i, + l = a - o, + h = (f * (n - o) - l * (t - i)) / (l * c - f * s); + return [ + t + h * c, + n + h * s + ] + } + function rt(t, n, e, r, i, o, u) { + var a = t - e, + c = n - r, + s = (u + ? o + : -o) / Math.sqrt(a * a + c * c), + f = s * c, + l = -s * a, + h = t + f, + p = n + l, + d = e + f, + v = r + l, + _ = (h + d) / 2, + y = (p + v) / 2, + g = d - h, + m = v - p, + x = g * g + m * m, + b = i - o, + w = h * v - d * p, + M = (m < 0 + ? -1 + : 1) * Math.sqrt(Math.max(0, b * b * x - w * w)), + T = (w * m - g * M) / x, + N = (-w * g - m * M) / x, + k = (w * m + g * M) / x, + S = (-w * g + m * M) / x, + A = T - _, + E = N - y, + C = k - _, + z = S - y; + return A * A + E * E > C * C + z * z && (T = k, N = S), { + cx: T, + cy: N, + x01: -f, + y01: -l, + x11: *(i / b - 1), + y11: *(i / b - 1) + } + } + function it(t) { + this._context = t + } + function ot(t) { + return t[0] + } + function ut(t) { + return t[1] + } + function at(t) { + this._curve = t + } + function ct(t) { + function n(n) { + return new at(t(n)) + } + return n._curve = t, + n + } + function st(t) { + var n = t.curve; + return t.angle = t.x, + delete t.x, + t.radius = t.y, + delete t.y, + t.curve = function (t) { + return arguments.length + ? n(ct(t)) + : n()._curve + }, + t + } + function ft(t, n, e) { + t + ._context + .bezierCurveTo((2 * t._x0 + t._x1) / 3, (2 * t._y0 + t._y1) / 3, (t._x0 + 2 * t._x1) / 3, (t._y0 + 2 * t._y1) / 3, (t._x0 + 4 * t._x1 + n) / 6, (t._y0 + 4 * t._y1 + e) / 6) + } + function lt(t) { + this._context = t + } + function ht(t) { + this._context = t + } + function pt(t) { + this._context = t + } + function dt(t, n) { + this._basis = new lt(t), + this._beta = n + } + function vt(t, n, e) { + t + ._context + .bezierCurveTo(t._x1 + t._k * (t._x2 - t._x0), t._y1 + t._k * (t._y2 - t._y0), t._x2 + t._k * (t._x1 - n), t._y2 + t._k * (t._y1 - e), t._x2, t._y2) + } + function _t(t, n) { + this._context = t, + this._k = (1 - n) / 6 + } + function yt(t, n) { + this._context = t, + this._k = (1 - n) / 6 + } + function gt(t, n) { + this._context = t, + this._k = (1 - n) / 6 + } + function mt(t, n, e) { + var r = t._x1, + i = t._y1, + o = t._x2, + u = t._y2; + if (t._l01_a > gl) { + var a = 2 * t._l01_2a + 3 * t._l01_a * t._l12_a + t._l12_2a, + c = 3 * t._l01_a * (t._l01_a + t._l12_a); + r = (r * a - t._x0 * t._l12_2a + t._x2 * t._l01_2a) / c, + i = (i * a - t._y0 * t._l12_2a + t._y2 * t._l01_2a) / c + } + if (t._l23_a > gl) { + var s = 2 * t._l23_2a + 3 * t._l23_a * t._l12_a + t._l12_2a, + f = 3 * t._l23_a * (t._l23_a + t._l12_a); + o = (o * s + t._x1 * t._l23_2a - n * t._l12_2a) / f, + u = (u * s + t._y1 * t._l23_2a - e * t._l12_2a) / f + } + t + ._context + .bezierCurveTo(r, i, o, u, t._x2, t._y2) + } + function xt(t, n) { + this._context = t, + this._alpha = n + } + function bt(t, n) { + this._context = t, + this._alpha = n + } + function wt(t, n) { + this._context = t, + this._alpha = n + } + function Mt(t) { + this._context = t + } + function Tt(t) { + return t < 0 + ? -1 + : 1 + } + function Nt(t, n, e) { + var r = t._x1 - t._x0, + i = n - t._x1, + o = (t._y1 - t._y0) / (r || i < 0 && -0), + u = (e - t._y1) / (i || r < 0 && -0), + a = (o * i + u * r) / (r + i); + return (Tt(o) + Tt(u)) * Math.min(Math.abs(o), Math.abs(u), .5 * Math.abs(a)) || 0 + } + function kt(t, n) { + var e = t._x1 - t._x0; + return e + ? (3 * (t._y1 - t._y0) / e - n) / 2 + : n + } + function St(t, n, e) { + var r = t._x0, + i = t._y0, + o = t._x1, + u = t._y1, + a = (o - r) / 3; + t + ._context + .bezierCurveTo(r + a, i + a * n, o - a, u - a * e, o, u) + } + function At(t) { + this._context = t + } + function Et(t) { + this._context = new Ct(t) + } + function Ct(t) { + this._context = t + } + function zt(t) { + return new At(t) + } + function Pt(t) { + return new Et(t) + } + function qt(t) { + this._context = t + } + function Lt(t) { + var n, + e, + r = t.length - 1, + i = new Array(r), + o = new Array(r), + u = new Array(r); + for (i[0] = 0, o[0] = 2, u[0] = t[0] + 2 * t[1], n = 1; n < r - 1; ++n) + i[n] = 1, + o[n] = 4, + u[n] = 4 * t[n] + 2 * t[n + 1]; + for (i[r - 1] = 2, o[r - 1] = 7, u[r - 1] = 8 * t[r - 1] + t[r], n = 1; n < r; ++n) + e = i[n] / o[n - 1], + o[n] -= e, + u[n] -= e * u[n - 1]; + for (i[r - 1] = u[r - 1] / o[r - 1], n = r - 2; n >= 0; --n) + i[n] = (u[n] - i[n + 1]) / o[n]; + for (o[r - 1] = (t[r] + i[r - 1]) / 2, n = 0; n < r - 1; ++n) + o[n] = 2 * t[n + 1] - i[n + 1]; + return [i, o] + } + function Rt(t, n) { + this._context = t, + this._t = n + } + function Ut(t) { + return new Rt(t, 0) + } + function Dt(t) { + return new Rt(t, 1) + } + function Ot(t, n) { + return t[n] + } + function Ft(t) { + for (var n, e = 0, r = -1, i = t.length; ++r < i;) + (n =+ t[r][1]) && (e += n); + return e + } + function It(t, n) { + var e = Object.create(t.prototype); + for (var r in n) + e[r] = n[r]; + return e + } + function Yt() {} + function Bt(t) { + var n; + return t = (t + "") + .trim() + .toLowerCase(), + (n = kh.exec(t)) + ? (n = parseInt(n[1], 16), new Wt(n >> 8 & 15 | n >> 4 & 240, n >> 4 & 15 | 240 & n, (15 & n) << 4 | 15 & n, 1)) + : (n = Sh.exec(t)) + ? jt(parseInt(n[1], 16)) + : (n = Ah.exec(t)) + ? new Wt(n[1], n[2], n[3], 1) + : (n = Eh.exec(t)) + ? new Wt(255 * n[1] / 100, 255 * n[2] / 100, 255 * n[3] / 100, 1) + : (n = Ch.exec(t)) + ? Ht(n[1], n[2], n[3], n[4]) + : (n = zh.exec(t)) + ? Ht(255 * n[1] / 100, 255 * n[2] / 100, 255 * n[3] / 100, n[4]) + : (n = Ph.exec(t)) + ? $t(n[1], n[2] / 100, n[3] / 100, 1) + : (n = qh.exec(t)) + ? $t(n[1], n[2] / 100, n[3] / 100, n[4]) + : Lh.hasOwnProperty(t) + ? jt(Lh[t]) + : "transparent" === t + ? new Wt(NaN, NaN, NaN, 0) + : null + } + function jt(t) { + return new Wt(t >> 16 & 255, t >> 8 & 255, 255 & t, 1) + } + function Ht(t, n, e, r) { + return r <= 0 && (t = n = e = NaN), + new Wt(t, n, e, r) + } + function Xt(t) { + return t instanceof Yt || (t = Bt(t)), + t + ? (t = t.rgb(), new Wt(t.r, t.g, t.b, t.opacity)) + : new Wt + } + function Vt(t, n, e, r) { + return 1 === arguments.length + ? Xt(t) + : new Wt(t, n, e, null == r + ? 1 + : r) + } + function Wt(t, n, e, r) { + this.r =+ t, + this.g =+ n, + this.b =+ e, + this.opacity =+ r + } + function $t(t, n, e, r) { + return r <= 0 + ? t = n = e = NaN + : e <= 0 || e >= 1 + ? t = n = NaN + : n <= 0 && (t = NaN), + new Jt(t, n, e, r) + } + function Zt(t) { + if (t instanceof Jt) + return new Jt(t.h, t.s, t.l, t.opacity); + if (t instanceof Yt || (t = Bt(t)), !t) + return new Jt; + if (t instanceof Jt) + return t; + t = t.rgb(); + var n = t.r / 255, + e = t.g / 255, + r = t.b / 255, + i = Math.min(n, e, r), + o = Math.max(n, e, r), + u = NaN, + a = o - i, + c = (o + i) / 2; + return a + ? (u = n === o + ? (e - r) / a + 6 * (e < r) + : e === o + ? (r - n) / a + 2 + : (n - e) / a + 4, a /= c < .5 + ? o + i + : 2 - o - i, u *= 60) + : a = c > 0 && c < 1 + ? 0 + : u, + new Jt(u, a, c, t.opacity) + } + function Gt(t, n, e, r) { + return 1 === arguments.length + ? Zt(t) + : new Jt(t, n, e, null == r + ? 1 + : r) + } + function Jt(t, n, e, r) { + this.h =+ t, + this.s =+ n, + this.l =+ e, + this.opacity =+ r + } + function Qt(t, n, e) { + return 255 * (t < 60 + ? n + (e - n) * t / 60 + : t < 180 + ? e + : t < 240 + ? n + (e - n) * (240 - t) / 60 + : n) + } + function Kt(t) { + if (t instanceof nn) + return new nn(t.l, t.a, t.b, t.opacity); + if (t instanceof sn) { + var n = t.h * Rh; + return new nn(t.l, Math.cos(n) * t.c, Math.sin(n) * t.c, t.opacity) + } + t instanceof Wt || (t = Xt(t)); + var e = un(t.r), + r = un(t.g), + i = un(t.b), + o = en((.4124564 * e + .3575761 * r + .1804375 * i) / Oh), + u = en((.2126729 * e + .7151522 * r + .072175 * i) / Fh), + a = en((.0193339 * e + .119192 * r + .9503041 * i) / Ih); + return new nn(116 * u - 16, 500 * (o - u), 200 * (u - a), t.opacity) + } + function tn(t, n, e, r) { + return 1 === arguments.length + ? Kt(t) + : new nn(t, n, e, null == r + ? 1 + : r) + } + function nn(t, n, e, r) { + this.l =+ t, + this.a =+ n, + this.b =+ e, + this.opacity =+ r + } + function en(t) { + return t > Hh + ? Math.pow(t, 1 / 3) + : t / jh + Yh + } + function rn(t) { + return t > Bh + ? t * t * t + : jh * (t - Yh) + } + function on(t) { + return 255 * (t <= .0031308 + ? 12.92 * t + : 1.055 * Math.pow(t, 1 / 2.4) - .055) + } + function un(t) { + return (t /= 255) <= .04045 + ? t / 12.92 + : Math.pow((t + .055) / 1.055, 2.4) + } + function an(t) { + if (t instanceof sn) + return new sn(t.h, t.c, t.l, t.opacity); + t instanceof nn || (t = Kt(t)); + var n = Math.atan2(t.b, t.a) * Uh; + return new sn(n < 0 + ? n + 360 + : n, Math.sqrt(t.a * t.a + t.b * t.b), t.l, t.opacity) + } + function cn(t, n, e, r) { + return 1 === arguments.length + ? an(t) + : new sn(t, n, e, null == r + ? 1 + : r) + } + function sn(t, n, e, r) { + this.h =+ t, + this.c =+ n, + this.l =+ e, + this.opacity =+ r + } + function fn(t) { + if (t instanceof hn) + return new hn(t.h, t.s, t.l, t.opacity); + t instanceof Wt || (t = Xt(t)); + var n = t.r / 255, + e = t.g / 255, + r = t.b / 255, + i = (Qh * r + Gh * n - Jh * e) / (Qh + Gh - Jh), + o = r - i, + u = (Zh * (e - i) - Wh * o) / $h, + a = Math.sqrt(u * u + o * o) / (Zh * i * (1 - i)), + c = a + ? Math.atan2(u, o) * Uh - 120 + : NaN; + return new hn(c < 0 + ? c + 360 + : c, a, i, t.opacity) + } + function ln(t, n, e, r) { + return 1 === arguments.length + ? fn(t) + : new hn(t, n, e, null == r + ? 1 + : r) + } + function hn(t, n, e, r) { + this.h =+ t, + this.s =+ n, + this.l =+ e, + this.opacity =+ r + } + function pn(t, n, e, r, i) { + var o = t * t, + u = o * t; + return ((1 - 3 * t + 3 * o - u) * n + (4 - 6 * o + 3 * u) * e + (1 + 3 * t + 3 * o - 3 * u) * r + u * i) / 6 + } + function dn(t, n) { + return function (e) { + return t + e * n + } + } + function vn(t, n, e) { + return t = Math.pow(t, e), + n = Math.pow(n, e) - t, + e = 1 / e, + function (r) { + return Math.pow(t + r * n, e) + } + } + function _n(t, n) { + var e = n - t; + return e + ? dn(t, e > 180 || e < -180 + ? e - 360 * Math.round(e / 360) + : e) + : op(isNaN(t) + ? n + : t) + } + function yn(t) { + return 1 === (t =+ t) + ? gn + : function (n, e) { + return e - n + ? vn(n, e, t) + : op(isNaN(n) + ? e + : n) + } + } + function gn(t, n) { + var e = n - t; + return e + ? dn(t, e) + : op(isNaN(t) + ? n + : t) + } + function mn(t) { + return function (n) { + var e, + r, + i = n.length, + o = new Array(i), + u = new Array(i), + a = new Array(i); + for (e = 0; e < i; ++e) + r = Vt(n[e]), + o[e] = r.r || 0, + u[e] = r.g || 0, + a[e] = r.b || 0; + return o = t(o), + u = t(u), + a = t(a), + r.opacity = 1, + function (t) { + return r.r = o(t), + r.g = u(t), + r.b = a(t), + r + "" + } + } + } + function xn(t) { + return function () { + return t + } + } + function bn(t) { + return function (n) { + return t(n) + "" + } + } + function wn(t) { + return "none" === t + ? mp + : (Kh || (Kh = document.createElement("DIV"), tp = document.documentElement, np = document.defaultView), Kh.style.transform = t, t = np.getComputedStyle(tp.appendChild(Kh), null).getPropertyValue("transform"), tp.removeChild(Kh), t = t.slice(7, -1).split(","), xp(+ t[0], + t[1], + t[2], + t[3], + t[4], + t[5])) + } + function Mn(t) { + return null == t + ? mp + : (ep || (ep = document.createElementNS("http://www.w3.org/2000/svg", "g")), ep.setAttribute("transform", t), (t = ep.transform.baseVal.consolidate()) + ? (t = t.matrix, xp(t.a, t.b, t.c, t.d, t.e, t.f)) + : mp) + } + function Tn(t, n, e, r) { + function i(t) { + return t.length + ? t.pop() + " " + : "" + } + function o(t, r, i, o, u, a) { + if (t !== i || r !== o) { + var c = u.push("translate(", null, n, null, e); + a.push({ + i: c - 4, + x: lp(t, i) + }, { + i: c - 2, + x: lp(r, o) + }) + } else + (i || o) && u.push("translate(" + i + n + o + e) + } + function u(t, n, e, o) { + t !== n + ? (t - n > 180 + ? n += 360 + : n - t > 180 && (t += 360), o.push({ + i: e.push(i(e) + "rotate(", null, r) - 2, + x: lp(t, n) + })) + : n && e.push(i(e) + "rotate(" + n + r) + } + function a(t, n, e, o) { + t !== n + ? o.push({ + i: e.push(i(e) + "skewX(", null, r) - 2, + x: lp(t, n) + }) + : n && e.push(i(e) + "skewX(" + n + r) + } + function c(t, n, e, r, o, u) { + if (t !== e || n !== r) { + var a = o.push(i(o) + "scale(", null, ",", null, ")"); + u.push({ + i: a - 4, + x: lp(t, e) + }, { + i: a - 2, + x: lp(n, r) + }) + } else + 1 === e && 1 === r || o.push(i(o) + "scale(" + e + "," + r + ")") + } + return function (n, e) { + var r = [], + i = []; + return n = t(n), + e = t(e), + o(n.translateX, n.translateY, e.translateX, e.translateY, r, i), + u(n.rotate, e.rotate, r, i), + a(n.skewX, e.skewX, r, i), + c(n.scaleX, n.scaleY, e.scaleX, e.scaleY, r, i), + n = e = null, + function (t) { + for (var n, e = -1, o = i.length; ++e < o;) + r[(n = i[e]).i] = n.x(t); + return r.join("") + } + } + } + function Nn(t) { + return ((t = Math.exp(t)) + 1 / t) / 2 + } + function kn(t) { + return ((t = Math.exp(t)) - 1 / t) / 2 + } + function Sn(t) { + return ((t = Math.exp(2 * t)) - 1) / (t + 1) + } + function An(t) { + return function (n, e) { + var r = t((n = Gt(n)).h, (e = Gt(e)).h), + i = gn(n.s, e.s), + o = gn(n.l, e.l), + u = gn(n.opacity, e.opacity); + return function (t) { + return n.h = r(t), + n.s = i(t), + n.l = o(t), + n.opacity = u(t), + n + "" + } + } + } + function En(t, n) { + var e = gn((t = tn(t)).l, (n = tn(n)).l), + r = gn(t.a, n.a), + i = gn(t.b, n.b), + o = gn(t.opacity, n.opacity); + return function (n) { + return t.l = e(n), + t.a = r(n), + t.b = i(n), + t.opacity = o(n), + t + "" + } + } + function Cn(t) { + return function (n, e) { + var r = t((n = cn(n)).h, (e = cn(e)).h), + i = gn(n.c, e.c), + o = gn(n.l, e.l), + u = gn(n.opacity, e.opacity); + return function (t) { + return n.h = r(t), + n.c = i(t), + n.l = o(t), + n.opacity = u(t), + n + "" + } + } + } + function zn(t) { + return function n(e) { + function r(n, r) { + var i = t((n = ln(n)).h, (r = ln(r)).h), + o = gn(n.s, r.s), + u = gn(n.l, r.l), + a = gn(n.opacity, r.opacity); + return function (t) { + return n.h = i(t), + n.s = o(t), + n.l = u(Math.pow(t, e)), + n.opacity = a(t), + n + "" + } + } + return e =+ e, + r.gamma = n, + r + }(1) + } + function Pn() { + for (var t, n = 0, e = arguments.length, r = {}; n < e; ++n) { + if (!(t = arguments[n] + "") || t in r) + throw new Error("illegal type: " + t); + r[t] = [] + } + return new qn(r) + } + function qn(t) { + this._ = t + } + function Ln(t, n) { + return t + .trim() + .split(/^|\s+/) + .map(function (t) { + var e = "", + r = t.indexOf("."); + if (r >= 0 && (e = t.slice(r + 1), t = t.slice(0, r)), t && !n.hasOwnProperty(t)) + throw new Error("unknown type: " + t); + return {type: t, name: e} + }) + } + function Rn(t, n) { + for (var e, r = 0, i = t.length; r < i; ++r) + if ((e = t[r]).name === n) + return e.value + } + function Un(t, n, e) { + for (var r = 0, i = t.length; r < i; ++r) + if (t[r].name === n) { + t[r] = Rp, + t = t + .slice(0, r) + .concat(t.slice(r + 1)); + break + } + return null != e && t.push({name: n, value: e}), + t + } + function Dn(t) { + return new Function("d", "return {" + t.map(function (t, n) { + return JSON.stringify(t) + ": d[" + n + "]" + }).join(",") + "}") + } + function On(t, n) { + var e = Dn(t); + return function (r, i) { + return n(e(r), i, t) + } + } + function Fn(t) { + var n = Object.create(null), + e = []; + return t.forEach(function (t) { + for (var r in t) + r in n || e.push(n[r] = r) + }), + e + } + function In(t) { + return function (n, e) { + t(null == n + ? e + : null) + } + } + function Yn(t) { + var n = t.responseType; + return n && "text" !== n + ? t.response + : t.responseText + } + function Bn(t, n) { + return function (e) { + return t(e.responseText, n) + } + } + function jn() { + return sd || (hd(Hn), sd = ld.now() + fd) + } + function Hn() { + sd = 0 + } + function Xn() { + this._call = this._time = this._next = null + } + function Vn(t, n, e) { + var r = new Xn; + return r.restart(t, n, e), + r + } + function Wn() { + jn(), + ++id; + for (var t, n = Up; n;) + (t = sd - n._time) >= 0 && n._call.call(null, t), + n = n._next; + + --id + } + function $n() { + sd = (cd = ld.now()) + fd, + id = od = 0; + try { + Wn() + } finally { + id = 0, + Gn(), + sd = 0 + } + } + function Zn() { + var t = ld.now(), + n = t - cd; + n > ad && (fd -= n, cd = t) + } + function Gn() { + for (var t, n, e = Up, r = 1 / 0; e;) + e._call + ? (r > e._time && (r = e._time), t = e, e = e._next) + : (n = e._next, e._next = null, e = t + ? t._next = n + : Up = n); + Dp = t, + Jn(r) + } + function Jn(t) { + if (!id) { + od && (od = clearTimeout(od)); + var n = t - sd; + n > 24 + ? (t < 1 / 0 && (od = setTimeout($n, n)), ud && (ud = clearInterval(ud))) + : (ud || (ud = setInterval(Zn, ad)), id = 1, hd($n)) + } + } + function Qn(t, n, e, r) { + function i(n) { + return t(n = new Date(+ n)), + n + } + return i.floor = i, + i.ceil = function (e) { + return t(e = new Date(e - 1)), + n(e, 1), + t(e), + e + }, + i.round = function (t) { + var n = i(t), + e = i.ceil(t); + return t - n < e - t + ? n + : e + }, + i.offset = function (t, e) { + return n(t = new Date(+ t), null == e + ? 1 + : Math.floor(e)), + t + }, + i.range = function (e, r, o) { + var u = []; + if (e = i.ceil(e), o = null == o + ? 1 + : Math.floor(o), !(e < r && o > 0)) + return u; + do + u.push(new Date(+ e)); + while (n(e, o), t(e), e < r); + return u + }, + i.filter = function (e) { + return Qn(function (n) { + if (n >= n) + for (; t(n), !e(n);) + n.setTime(n - 1) + }, function (t, r) { + if (t >= t) + for (; --r >= 0;) + for (; n(t, 1), !e(t);) ; + } + ) + }, + e && (i.count = function (n, r) { + return vd.setTime(+ n), + _d.setTime(+ r), + t(vd), + t(_d), + Math.floor(e(vd, _d)) + }, + i.every = function (t) { + return t = Math.floor(t), + isFinite(t) && t > 0 + ? t > 1 + ? i.filter(r + ? function (n) { + return r(n) % t === 0 + } + : function (n) { + return i.count(0, n) % t === 0 + }) + : i + : null + }), + i + } + function Kn(t) { + return Qn(function (n) { + n.setDate(n.getDate() - (n.getDay() + 7 - t) % 7), + n.setHours(0, 0, 0, 0) + }, function (t, n) { + t.setDate(t.getDate() + 7 * n) + }, function (t, n) { + return (n - t - (n.getTimezoneOffset() - t.getTimezoneOffset()) * xd) / Md + }) + } + function te(t) { + return Qn(function (n) { + n.setUTCDate(n.getUTCDate() - (n.getUTCDay() + 7 - t) % 7), + n.setUTCHours(0, 0, 0, 0) + }, function (t, n) { + t.setUTCDate(t.getUTCDate() + 7 * n) + }, function (t, n) { + return (n - t) / Md + }) + } + function ne(t) { + if (!(n = Av.exec(t))) + throw new Error("invalid format: " + t); + var n, + e = n[1] || " ", + r = n[2] || ">", + i = n[3] || "-", + o = n[4] || "", + u = !!n[5], + a = n[6] &&+ n[6], + c = !!n[7], + s = n[8] &&+ n[8].slice(1), + f = n[9] || ""; + "n" === f + ? (c = !0, f = "g") + : Sv[f] || (f = ""), + (u || "0" === e && "=" === r) && (u = !0, e = "0", r = "="), + this.fill = e, + this.align = r, + this.sign = i, + this.symbol = o, + this.zero = u, + this.width = a, + this.comma = c, + this.precision = s, + this.type = f + } + function ee(t) { + return t + } + function re(n) { + return Cv = Pv(n), + t.format = Cv.format, + t.formatPrefix = Cv.formatPrefix, + Cv + } + function ie(t) { + if (0 <= t.y && t.y < 100) { + var n = new Date(-1, t.m, t.d, t.H, t.M, t.S, t.L); + return n.setFullYear(t.y), + n + } + return new Date(t.y, t.m, t.d, t.H, t.M, t.S, t.L) + } + function oe(t) { + if (0 <= t.y && t.y < 100) { + var n = new Date(Date.UTC(-1, t.m, t.d, t.H, t.M, t.S, t.L)); + return n.setUTCFullYear(t.y), + n + } + return new Date(Date.UTC(t.y, t.m, t.d, t.H, t.M, t.S, t.L)) + } + function ue(t) { + return { + y: t, + m: 0, + d: 1, + H: 0, + M: 0, + S: 0, + L: 0 + } + } + function ae(t) { + function n(t, n) { + return function (e) { + var r, + i, + o, + u = [], + a = -1, + c = 0, + s = t.length; + for (e instanceof Date || (e = new Date(+ e)); ++a < s;) + 37 === t.charCodeAt(a) && (u.push(t.slice(c, a)), null != (i = Dv[r = t.charAt(++a)]) + ? r = t.charAt(++a) + : i = "e" === r + ? " " + : "0", (o = n[r]) && (r = o(e, i)), u.push(r), c = a + 1); + return u.push(t.slice(c, a)), + u.join("") + } + } + function e(t, n) { + return function (e) { + var i = ue(1900), + o = r(i, t, e += "", 0); + if (o != e.length) + return null; + if ("p" in i && (i.H = i.H % 12 + 12 * i.p), "W" in i || "U" in i) { + "w" in i || (i.w = "W" in i + ? 1 + : 0); + var u = "Z" in i + ? oe(ue(i.y)).getUTCDay() + : n(ue(i.y)).getDay(); + i.m = 0, + i.d = "W" in i + ? (i.w + 6) % 7 + 7 * i.W - (u + 5) % 7 + : i.w + 7 * i.U - (u + 6) % 7 + } + return "Z" in i + ? (i.H += i.Z / 100 | 0, i.M += i.Z % 100, oe(i)) + : n(i) + } + } + function r(t, n, e, r) { + for (var i, o, u = 0, a = n.length, c = e.length; u < a;) { + if (r >= c) + return -1; + if (i = n.charCodeAt(u++), 37 === i) { + if (i = n.charAt(u++), o = B[i in Dv + ? n.charAt(u++) + : i], !o || (r = o(t, e, r)) < 0) + return -1 + } else if (i != e.charCodeAt(r++)) + return -1 + } + return r + } + function i(t, n, e) { + var r = C.exec(n.slice(e)); + return r + ? (t.p = z[r[0].toLowerCase()], e + r[0].length) + : -1 + } + function o(t, n, e) { + var r = L.exec(n.slice(e)); + return r + ? (t.w = R[r[0].toLowerCase()], e + r[0].length) + : -1 + } + function u(t, n, e) { + var r = P.exec(n.slice(e)); + return r + ? (t.w = q[r[0].toLowerCase()], e + r[0].length) + : -1 + } + function a(t, n, e) { + var r = O.exec(n.slice(e)); + return r + ? (t.m = F[r[0].toLowerCase()], e + r[0].length) + : -1 + } + function c(t, n, e) { + var r = U.exec(n.slice(e)); + return r + ? (t.m = D[r[0].toLowerCase()], e + r[0].length) + : -1 + } + function s(t, n, e) { + return r(t, w, n, e) + } + function f(t, n, e) { + return r(t, M, n, e) + } + function l(t, n, e) { + return r(t, T, n, e) + } + function h(t) { + return S[t.getDay()] + } + function p(t) { + return k[t.getDay()] + } + function d(t) { + return E[t.getMonth()] + } + function v(t) { + return A[t.getMonth()] + } + function _(t) { + return N[+ (t.getHours() >= 12)] + } + function y(t) { + return S[t.getUTCDay()] + } + function g(t) { + return k[t.getUTCDay()] + } + function m(t) { + return E[t.getUTCMonth()] + } + function x(t) { + return A[t.getUTCMonth()] + } + function b(t) { + return N[+ (t.getUTCHours() >= 12)] + } + var w = t.dateTime, + M = t.date, + T = t.time, + N = t.periods, + k = t.days, + S = t.shortDays, + A = t.months, + E = t.shortMonths, + C = fe(N), + z = le(N), + P = fe(k), + q = le(k), + L = fe(S), + R = le(S), + U = fe(A), + D = le(A), + O = fe(E), + F = le(E), + I = { + a: h, + A: p, + b: d, + B: v, + c: null, + d: ke, + e: ke, + H: Se, + I: Ae, + j: Ee, + L: Ce, + m: ze, + M: Pe, + p: _, + S: qe, + U: Le, + w: Re, + W: Ue, + x: null, + X: null, + y: De, + Y: Oe, + Z: Fe, + "%": tr + }, + Y = { + a: y, + A: g, + b: m, + B: x, + c: null, + d: Ie, + e: Ie, + H: Ye, + I: Be, + j: je, + L: He, + m: Xe, + M: Ve, + p: b, + S: We, + U: $e, + w: Ze, + W: Ge, + x: null, + X: null, + y: Je, + Y: Qe, + Z: Ke, + "%": tr + }, + B = { + a: o, + A: u, + b: a, + B: c, + c: s, + d: me, + e: me, + H: be, + I: be, + j: xe, + L: Te, + m: ge, + M: we, + p: i, + S: Me, + U: pe, + w: he, + W: de, + x: f, + X: l, + y: _e, + Y: ve, + Z: ye, + "%": Ne + }; + return I.x = n(M, I), + I.X = n(T, I), + I.c = n(w, I), + Y.x = n(M, Y), + Y.X = n(T, Y), + Y.c = n(w, Y), { + format: function (t) { + var e = n(t += "", I); + return e.toString = function () { + return t + }, + e + }, + parse: function (t) { + var n = e(t += "", ie); + return n.toString = function () { + return t + }, + n + }, + utcFormat: function (t) { + var e = n(t += "", Y); + return e.toString = function () { + return t + }, + e + }, + utcParse: function (t) { + var n = e(t, oe); + return n.toString = function () { + return t + }, + n + } + } + } + function ce(t, n, e) { + var r = t < 0 + ? "-" + : "", + i = (r + ? -t + : t) + "", + o = i.length; + return r + (o < e + ? new Array(e - o + 1).join(n) + i + : i) + } + function se(t) { + return t.replace(Iv, "\\$&") + } + function fe(t) { + return new RegExp("^(?:" + t.map(se).join("|") + ")", "i") + } + function le(t) { + for (var n = {}, e = -1, r = t.length; ++e < r;) + n[t[e].toLowerCase()] = e; + return n + } + function he(t, n, e) { + var r = Ov.exec(n.slice(e, e + 1)); + return r + ? (t.w =+ r[0], e + r[0].length) + : -1 + } + function pe(t, n, e) { + var r = Ov.exec(n.slice(e)); + return r + ? (t.U =+ r[0], e + r[0].length) + : -1 + } + function de(t, n, e) { + var r = Ov.exec(n.slice(e)); + return r + ? (t.W =+ r[0], e + r[0].length) + : -1 + } + function ve(t, n, e) { + var r = Ov.exec(n.slice(e, e + 4)); + return r + ? (t.y =+ r[0], e + r[0].length) + : -1 + } + function _e(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.y =+ r[0] + (+ r[0] > 68 + ? 1900 + : 2e3), e + r[0].length) + : -1 + } + function ye(t, n, e) { + var r = /^(Z)|([+-]\d\d)(?:\:?(\d\d))?/.exec(n.slice(e, e + 6)); + return r + ? (t.Z = r[1] + ? 0 + : -(r[2] + (r[3] || "00")), e + r[0].length) + : -1 + } + function ge(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.m = r[0] - 1, e + r[0].length) + : -1 + } + function me(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.d =+ r[0], e + r[0].length) + : -1 + } + function xe(t, n, e) { + var r = Ov.exec(n.slice(e, e + 3)); + return r + ? (t.m = 0, t.d =+ r[0], e + r[0].length) + : -1 + } + function be(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.H =+ r[0], e + r[0].length) + : -1 + } + function we(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.M =+ r[0], e + r[0].length) + : -1 + } + function Me(t, n, e) { + var r = Ov.exec(n.slice(e, e + 2)); + return r + ? (t.S =+ r[0], e + r[0].length) + : -1 + } + function Te(t, n, e) { + var r = Ov.exec(n.slice(e, e + 3)); + return r + ? (t.L =+ r[0], e + r[0].length) + : -1 + } + function Ne(t, n, e) { + var r = Fv.exec(n.slice(e, e + 1)); + return r + ? e + r[0].length + : -1 + } + function ke(t, n) { + return ce(t.getDate(), n, 2) + } + function Se(t, n) { + return ce(t.getHours(), n, 2) + } + function Ae(t, n) { + return ce(t.getHours() % 12 || 12, n, 2) + } + function Ee(t, n) { + return ce(1 + Cd.count($d(t), t), n, 3) + } + function Ce(t, n) { + return ce(t.getMilliseconds(), n, 3) + } + function ze(t, n) { + return ce(t.getMonth() + 1, n, 2) + } + function Pe(t, n) { + return ce(t.getMinutes(), n, 2) + } + function qe(t, n) { + return ce(t.getSeconds(), n, 2) + } + function Le(t, n) { + return ce(Pd.count($d(t), t), n, 2) + } + function Re(t) { + return t.getDay() + } + function Ue(t, n) { + return ce(qd.count($d(t), t), n, 2) + } + function De(t, n) { + return ce(t.getFullYear() % 100, n, 2) + } + function Oe(t, n) { + return ce(t.getFullYear() % 1e4, n, 4) + } + function Fe(t) { + var n = t.getTimezoneOffset(); + return (n > 0 + ? "-" + : (n *= -1, "+")) + ce(n / 60 | 0, "0", 2) + ce(n % 60, "0", 2) + } + function Ie(t, n) { + return ce(t.getUTCDate(), n, 2) + } + function Ye(t, n) { + return ce(t.getUTCHours(), n, 2) + } + function Be(t, n) { + return ce(t.getUTCHours() % 12 || 12, n, 2) + } + function je(t, n) { + return ce(1 + tv.count(gv(t), t), n, 3) + } + function He(t, n) { + return ce(t.getUTCMilliseconds(), n, 3) + } + function Xe(t, n) { + return ce(t.getUTCMonth() + 1, n, 2) + } + function Ve(t, n) { + return ce(t.getUTCMinutes(), n, 2) + } + function We(t, n) { + return ce(t.getUTCSeconds(), n, 2) + } + function $e(t, n) { + return ce(ev.count(gv(t), t), n, 2) + } + function Ze(t) { + return t.getUTCDay() + } + function Ge(t, n) { + return ce(rv.count(gv(t), t), n, 2) + } + function Je(t, n) { + return ce(t.getUTCFullYear() % 100, n, 2) + } + function Qe(t, n) { + return ce(t.getUTCFullYear() % 1e4, n, 4) + } + function Ke() { + return "+0000" + } + function tr() { + return "%" + } + function nr(n) { + return qv = ae(n), + t.timeFormat = qv.format, + t.timeParse = qv.parse, + t.utcFormat = qv.utcFormat, + t.utcParse = qv.utcParse, + qv + } + function er(t) { + return t.toISOString() + } + function rr(t) { + var n = new Date(t); + return isNaN(n) + ? null + : n + } + function ir(t) { + function n(n) { + var o = n + "", + u = e.get(o); + if (!u) { + if (i !== Wv) + return i; + e.set(o, u = r.push(n)) + } + return t[(u - 1) % t.length] + } + var e = o(), + r = [], + i = Wv; + return t = null == t + ? [] + : Vv.call(t), + n.domain = function (t) { + if (!arguments.length) + return r.slice(); + r = [], + e = o(); + for (var i, u, a = -1, c = t.length; ++a < c;) + e.has(u = (i = t[a]) + "") || e.set(u, r.push(i)); + return n + }, + n.range = function (e) { + return arguments.length + ? (t = Vv.call(e), n) + : t.slice() + }, + n.unknown = function (t) { + return arguments.length + ? (i = t, n) + : i + }, + n.copy = function () { + return ir() + .domain(r) + .range(t) + .unknown(i) + }, + n + } + function or() { + function t() { + var t = i().length, + r = u[1] < u[0], + l = u[r - 0], + h = u[1 - r]; + n = (h - l) / Math.max(1, t - c + 2 * s), + a && (n = Math.floor(n)), + l += (h - l - n * (t - c)) * f, + e = n * (1 - c), + a && (l = Math.round(l), e = Math.round(e)); + var p = Os(t).map(function (t) { + return l + n * t + }); + return o(r + ? p.reverse() + : p) + } + var n, + e, + r = ir().unknown(void 0), + i = r.domain, + o = r.range, + u = [ + 0, 1 + ], + a = !1, + c = 0, + s = 0, + f = .5; + return delete r.unknown, + r.domain = function (n) { + return arguments.length + ? (i(n), t()) + : i() + }, + r.range = function (n) { + return arguments.length + ? (u = [ + n[0], + n[1] + ], t()) + : u.slice() + }, + r.rangeRound = function (n) { + return u = [ + n[0], + n[1] + ], + a = !0, + t() + }, + r.bandwidth = function () { + return e + }, + r.step = function () { + return n + }, + r.round = function (n) { + return arguments.length + ? (a = !!n, t()) + : a + }, + r.padding = function (n) { + return arguments.length + ? (c = s = Math.max(0, Math.min(1, n)), t()) + : c + }, + r.paddingInner = function (n) { + return arguments.length + ? (c = Math.max(0, Math.min(1, n)), t()) + : c + }, + r.paddingOuter = function (n) { + return arguments.length + ? (s = Math.max(0, Math.min(1, n)), t()) + : s + }, + r.align = function (n) { + return arguments.length + ? (f = Math.max(0, Math.min(1, n)), t()) + : f + }, + r.copy = function () { + return or() + .domain(i()) + .range(u) + .round(a) + .paddingInner(c) + .paddingOuter(s) + .align(f) + }, + t() + } + function ur(t) { + var n = t.copy; + return t.padding = t.paddingOuter, + delete t.paddingInner, + delete t.paddingOuter, + t.copy = function () { + return ur(n()) + }, + t + } + function ar() { + return ur(or().paddingInner(1)) + } + function cr(t, n) { + return (n -= t =+ t) + ? function (e) { + return (e - t) / n + } + : $v(n) + } + function sr(t) { + return function (n, e) { + var r = t(n =+ n, e =+ e); + return function (t) { + return t <= n + ? 0 + : t >= e + ? 1 + : r(t) + } + } + } + function fr(t) { + return function (n, e) { + var r = t(n =+ n, e =+ e); + return function (t) { + return t <= 0 + ? n + : t >= 1 + ? e + : r(t) + } + } + } + function lr(t, n, e, r) { + var i = t[0], + o = t[1], + u = n[0], + a = n[1]; + return o < i + ? (i = e(o, i), u = r(a, u)) + : (i = e(i, o), u = r(u, a)), + function (t) { + return u(i(t)) + } + } + function hr(t, n, e, r) { + var i = Math.min(t.length, n.length) - 1, + o = new Array(i), + u = new Array(i), + a = -1; + for (t[i] < t[0] && (t = t.slice().reverse(), n = n.slice().reverse()); ++a < i;) + o[a] = e(t[a], t[a + 1]), + u[a] = r(n[a], n[a + 1]); + return function (n) { + var e = ks(t, n, 1, i) - 1; + return u[e](o[e](n)) + } + } + function pr(t, n) { + return n + .domain(t.domain()) + .range(t.range()) + .interpolate(t.interpolate()) + .clamp(t.clamp()) + } + function dr(t, n) { + function e() { + return i = Math.min(a.length, c.length) > 2 + ? hr + : lr, + o = u = null, + r + } + function r(n) { + return (o || (o = i(a, c, f + ? sr(t) + : t, s)))(+ n) + } + var i, + o, + u, + a = Gv, + c = Gv, + s = _p, + f = !1; + return r.invert = function (t) { + return (u || (u = i(c, a, cr, f + ? fr(n) + : n)))(+ t) + }, + r.domain = function (t) { + return arguments.length + ? (a = Xv.call(t, Zv), e()) + : a.slice() + }, + r.range = function (t) { + return arguments.length + ? (c = Vv.call(t), e()) + : c.slice() + }, + r.rangeRound = function (t) { + return c = Vv.call(t), + s = yp, + e() + }, + r.clamp = function (t) { + return arguments.length + ? (f = !!t, e()) + : f + }, + r.interpolate = function (t) { + return arguments.length + ? (s = t, e()) + : s + }, + e() + } + function vr(t) { + var n = t.domain; + return t.ticks = function (t) { + var e = n(); + return Bs(e[0], e[e.length - 1], null == t + ? 10 + : t) + }, + t.tickFormat = function (t, e) { + return Jv(n(), t, e) + }, + t.nice = function (r) { + var i = n(), + o = i.length - 1, + u = null == r + ? 10 + : r, + a = i[0], + c = i[o], + s = e(a, c, u); + return s && (s = e(Math.floor(a / s) * s, Math.ceil(c / s) * s, u), i[0] = Math.floor(a / s) * s, i[o] = Math.ceil(c / s) * s, n(i)), + t + }, + t + } + function _r() { + var t = dr(cr, lp); + return t.copy = function () { + return pr(t, _r()) + }, + vr(t) + } + function yr() { + function t(t) { + return + t + } + var n = [0, 1]; + return t.invert = t, + t.domain = t.range = function (e) { + return arguments.length + ? (n = Xv.call(e, Zv), t) + : n.slice() + }, + t.copy = function () { + return yr().domain(n) + }, + vr(t) + } + function gr(t, n) { + return (n = Math.log(n / t)) + ? function (e) { + return Math.log(e / t) / n + } + : $v(n) + } + function mr(t, n) { + return t < 0 + ? function (e) { + return -Math.pow(-n, e) * Math.pow(-t, 1 - e) + } + : function (e) { + return Math.pow(n, e) * Math.pow(t, 1 - e) + } + } + function xr(t) { + return isFinite(t) ?+ ("1e" + t) : t < 0 + ? 0 + : t + } + function br(t) { + return 10 === t + ? xr + : t === Math.E + ? Math.exp + : function (n) { + return Math.pow(t, n) + } + } + function wr(t) { + return t === Math.E + ? Math.log + : 10 === t && Math.log10 || 2 === t && Math.log2 || (t = Math.log(t), function (n) { + return Math.log(n) / t + }) + } + function Mr(t) { + return function (n) { + return -t(-n) + } + } + function Tr() { + function n() { + return o = wr(i), + u = br(i), + r()[0] < 0 && (o = Mr(o), u = Mr(u)), + e + } + var e = dr(gr, mr).domain([1, 10]), + r = e.domain, + i = 10, + o = wr(10), + u = br(10); + return e.base = function (t) { + return arguments.length + ? (i =+ t, n()) + : i + }, + e.domain = function (t) { + return arguments.length + ? (r(t), n()) + : r() + }, + e.ticks = function (t) { + var n, + e = r(), + a = e[0], + c = e[e.length - 1]; + (n = c < a) && (h = a, a = c, c = h); + var s, + f, + l, + h = o(a), + p = o(c), + d = null == t + ? 10 :+ t, + v = []; + if (!(i % 1) && p - h < d) { + if (h = Math.round(h) - 1, p = Math.round(p) + 1, a > 0) { + for (; h < p; ++h) + for (f = 1, s = u(h); f < i; ++f) + if (l = s * f, !(l < a)) { + if (l > c) + break; + v.push(l) + } + } else + for (; h < p; ++h) + for (f = i - 1, s = u(h); f >= 1; --f) + if (l = s * f, !(l < a)) { + if (l > c) + break; + v.push(l) + } + } else + v = Bs(h, p, Math.min(p - h, d)).map(u); + return n + ? v.reverse() + : v + }, + e.tickFormat = function (n, r) { + if (null == r && (r = 10 === i + ? ".0e" + : ","), "function" != typeof r && (r = t.format(r)), n === 1 / 0) + return r; + null == n && (n = 10); + var a = Math.max(1, i * n / e.ticks().length); + return function (t) { + var n = t / u(Math.round(o(t))); + return n * i < i - .5 && (n *= i), + n <= a + ? r(t) + : "" + } + }, + e.nice = function () { + return r(Qv(r(), { + floor: function (t) { + return u(Math.floor(o(t))) + }, + ceil: function (t) { + return u(Math.ceil(o(t))) + } + })) + }, + e.copy = function () { + return pr(e, Tr().base(i)) + }, + e + } + function Nr(t, n) { + return t < 0 + ? -Math.pow(-t, n) + : Math.pow(t, n) + } + function kr() { + function t(t, n) { + return (n = Nr(n, e) - (t = Nr(t, e))) + ? function (r) { + return (Nr(r, e) - t) / n + } + : $v(n) + } + function n(t, n) { + return n = Nr(n, e) - (t = Nr(t, e)), + function (r) { + return Nr(t + n * r, 1 / e) + } + } + var e = 1, + r = dr(t, n), + i = r.domain; + return r.exponent = function (t) { + return arguments.length + ? (e =+ t, i(i())) + : e + }, + r.copy = function () { + return pr(r, kr().exponent(e)) + }, + vr(r) + } + function Sr() { + return kr().exponent(.5) + } + function Ar() { + function t() { + var t = 0, + o = Math.max(1, r.length); + for (i = new Array(o - 1); ++t < o;) + i[t - 1] = Xs(e, t / o); + return n + } + function n(t) { + if (!isNaN(t =+ t)) + return r[ks(i, t)] + } + var e = [], + r = [], + i = []; + return n.invertExtent = function (t) { + var n = r.indexOf(t); + return n < 0 + ? [NaN, NaN] + : [ + n > 0 + ? i[n - 1] + : e[0], + n < i.length + ? i[n] + : e[e.length - 1] + ] + }, + n.domain = function (n) { + if (!arguments.length) + return e.slice(); + e = []; + for (var r, i = 0, o = n.length; i < o; ++i) + r = n[i], + null == r || isNaN(r =+ r) || e.push(r); + return e.sort(Ms), + t() + }, + n.range = function (n) { + return arguments.length + ? (r = Vv.call(n), t()) + : r.slice() + }, + n.quantiles = function () { + return i.slice() + }, + n.copy = function () { + return Ar() + .domain(e) + .range(r) + }, + n + } + function Er() { + function t(t) { + if (t <= t) + return u[ks(o, t, 0, i)] + } + function n() { + var n = -1; + for (o = new Array(i); ++n < i;) + o[n] = ((n + 1) * r - (n - i) * e) / (i + 1); + return t + } + var e = 0, + r = 1, + i = 1, + o = [.5], + u = [0, 1]; + return t.domain = function (t) { + return arguments.length + ? (e =+ t[0], r =+ t[1], n()) + : [e, r] + }, + t.range = function (t) { + return arguments.length + ? (i = (u = Vv.call(t)).length - 1, n()) + : u.slice() + }, + t.invertExtent = function (t) { + var n = u.indexOf(t); + return n < 0 + ? [NaN, NaN] + : n < 1 + ? [e, o[0]] + : n >= i + ? [ + o[i - 1], + r + ] + : [ + o[n - 1], + o[n] + ] + }, + t.copy = function () { + return Er() + .domain([e, r]) + .range(u) + }, + vr(t) + } + function Cr() { + function t(t) { + if (t <= t) + return e[ks(n, t, 0, r)] + } + var n = [.5], + e = [ + 0, 1 + ], + r = 1; + return t.domain = function (i) { + return arguments.length + ? (n = Vv.call(i), r = Math.min(n.length, e.length - 1), t) + : n.slice() + }, + t.range = function (i) { + return arguments.length + ? (e = Vv.call(i), r = Math.min(n.length, e.length - 1), t) + : e.slice() + }, + t.invertExtent = function (t) { + var r = e.indexOf(t); + return [ + n[r - 1], + n[r] + ] + }, + t.copy = function () { + return Cr() + .domain(n) + .range(e) + }, + t + } + function zr(t) { + return new Date(t); + } + function Pr(t) { + return t instanceof Date ?+ t :+ new Date(+ t) + } + function qr(t, n, r, i, o, u, a, c, s) { + function f(e) { + return (a(e) < e + ? v + : u(e) < e + ? _ + : o(e) < e + ? y + : i(e) < e + ? g + : n(e) < e + ? r(e) < e + ? m + : x + : t(e) < e + ? b + : w)(e) + } + function l(n, r, i, o) { + if (null == n && (n = 10), "number" == typeof n) { + var u = Math.abs(i - r) / n, + a = Ts(function (t) { + return t[2] + }).right(M, u); + a === M.length + ? (o = e(r / o_, i / o_, n), n = t) + : a + ? (a = M[u / M[a - 1][2] < M[a][2] / u + ? a - 1 + : a], o = a[1], n = a[0]) + : (o = e(r, i, n), n = c) + } + return null == o + ? n + : n.every(o) + } + var h = dr(cr, lp), + p = h.invert, + d = h.domain, + v = s(".%L"), + _ = s(":%S"), + y = s("%I:%M"), + g = s("%I %p"), + m = s("%a %d"), + x = s("%b %d"), + b = s("%B"), + w = s("%Y"), + M = [ + [ + a, 1, Kv + ], + [ + a, 5, 5 * Kv + ], + [ + a, 15, 15 * Kv + ], + [ + a, 30, 30 * Kv + ], + [ + u, 1, t_ + ], + [ + u, 5, 5 * t_ + ], + [ + u, 15, 15 * t_ + ], + [ + u, 30, 30 * t_ + ], + [ + o, 1, n_ + ], + [ + o, 3, 3 * n_ + ], + [ + o, 6, 6 * n_ + ], + [ + o, 12, 12 * n_ + ], + [ + i, 1, e_ + ], + [ + i, 2, 2 * e_ + ], + [ + r, 1, r_ + ], + [ + n, 1, i_ + ], + [ + n, 3, 3 * i_ + ], + [t, 1, o_] + ]; + return h.invert = function (t) { + return new Date(p(t)) + }, + h.domain = function (t) { + return arguments.length + ? d(Xv.call(t, Pr)) + : d().map(zr) + }, + h.ticks = function (t, n) { + var e, + r = d(), + i = r[0], + o = r[r.length - 1], + u = o < i; + return u && (e = i, i = o, o = e), + e = l(t, i, o, n), + e = e + ? e.range(i, o + 1) + : [], + u + ? e.reverse() + : e + }, + h.tickFormat = function (t, n) { + return null == n + ? f + : s(n) + }, + h.nice = function (t, n) { + var e = d(); + return (t = l(t, e[0], e[e.length - 1], n)) + ? d(Qv(e, t)) + : h + }, + h.copy = function () { + return pr(h, qr(t, n, r, i, o, u, a, c, s)) + }, + h + } + function Lr(t) { + var n = t.length; + return function (e) { + return t[Math.max(0, Math.min(n - 1, Math.floor(e * n)))] + } + } + function Rr(t) { + function n(n) { + var o = (n - e) / (r - e); + return t(i + ? Math.max(0, Math.min(1, o)) + : o) + } + var e = 0, + r = 1, + i = !1; + return n.domain = function (t) { + return arguments.length + ? (e =+ t[0], r =+ t[1], n) + : [e, r] + }, + n.clamp = function (t) { + return arguments.length + ? (i = !!t, n) + : i + }, + n.interpolator = function (e) { + return arguments.length + ? (t = e, n) + : t + }, + n.copy = function () { + return Rr(t) + .domain([e, r]) + .clamp(i) + }, + vr(n) + } + function Ur(t) { + return function () { + var n = this.ownerDocument, + e = this.namespaceURI; + return e === w_ && n.documentElement.namespaceURI === w_ + ? n.createElement(t) + : n.createElementNS(e, t) + } + } + function Dr(t) { + return function () { + return this + .ownerDocument + .createElementNS(t.space, t.local) + } + } + function Or() { + return new Fr + } + function Fr() { + this._ = "@" + (++k_).toString(36) + } + function Ir(t, n, e) { + return t = Yr(t, n, e), + function (n) { + var e = n.relatedTarget; + e && (e === this || 8 & e.compareDocumentPosition(this)) || t.call(this, n) + } + } + function Yr(n, e, r) { + return function (i) { + var o = t.event; + t.event = i; + try { + n.call(this, this.__data__, e, r) + } finally { + t.event = o + } + } + } + function Br(t) { + return t + .trim() + .split(/^|\s+/) + .map(function (t) { + var n = "", + e = t.indexOf("."); + return e >= 0 && (n = t.slice(e + 1), t = t.slice(0, e)), { + type: t, + name: n + } + }) + } + function jr(t) { + return function () { + var n = this.__on; + if (n) { + for (var e, r = 0, i = -1, o = n.length; r < o; ++r) + e = n[r], + t.type && e.type !== t.type || e.name !== t.name + ? n[++i] = e + : this.removeEventListener(e.type, e.listener, e.capture); + + ++i + ? n.length = i + : delete this.__on + } + } + } + function Hr(t, n, e) { + var r = z_.hasOwnProperty(t.type) + ? Ir + : Yr; + return function (i, o, u) { + var a, + c = this.__on, + s = r(n, o, u); + if (c) + for (var f = 0, l = c.length; f < l; ++f) + if ((a = c[f]).type === t.type && a.name === t.name) + return this.removeEventListener(a.type, a.listener, a.capture), + this.addEventListener(a.type, a.listener = s, a.capture = e), + void(a.value = n); + this.addEventListener(t.type, s, e), + a = { + type: t.type, + name: t.name, + value: n, + listener: s, + capture: e + }, + c + ? c.push(a) + : this.__on = [a] + } + } + function Xr(n, e, r, i) { + var o = t.event; + n.sourceEvent = t.event, + t.event = n; + try { + return e.apply(r, i) + } finally { + t.event = o + } + } + function Vr() {} + function Wr() { + return [] + } + function $r(t, n) { + this.ownerDocument = t.ownerDocument, + this.namespaceURI = t.namespaceURI, + this._next = null, + this._parent = t, + this.__data__ = n + } + function Zr(t, n, e, r, i, o) { + for (var u, a = 0, c = n.length, s = o.length; a < s; ++a) + (u = n[a]) + ? (u.__data__ = o[a], r[a] = u) + : e[a] = new $r(t, o[a]); + for (; a < c; ++a) + (u = n[a]) && (i[a] = u) + } + function Gr(t, n, e, r, i, o, u) { + var a, + c, + s, + f = {}, + l = n.length, + h = o.length, + p = new Array(l); + for (a = 0; a < l; ++a) + (c = n[a]) && (p[a] = s = X_ + u.call(c, c.__data__, a, n), s in f + ? i[a] = c + : f[s] = c); + for (a = 0; a < h; ++a) + s = X_ + u.call(t, o[a], a, o), + (c = f[s]) + ? (r[a] = c, c.__data__ = o[a], f[s] = null) + : e[a] = new $r(t, o[a]); + for (a = 0; a < l; ++a) + (c = n[a]) && f[p[a]] === c && (i[a] = c) + } + function Jr(t, n) { + return t < n + ? -1 + : t > n + ? 1 + : t >= n + ? 0 + : NaN + } + function Qr(t) { + return function () { + this.removeAttribute(t) + } + } + function Kr(t) { + return function () { + this.removeAttributeNS(t.space, t.local) + } + } + function ti(t, n) { + return function () { + this.setAttribute(t, n) + } + } + function ni(t, n) { + return function () { + this.setAttributeNS(t.space, t.local, n) + } + } + function ei(t, n) { + return function () { + var e = n.apply(this, arguments); + null == e + ? this.removeAttribute(t) + : this.setAttribute(t, e) + } + } + function ri(t, n) { + return function () { + var e = n.apply(this, arguments); + null == e + ? this.removeAttributeNS(t.space, t.local) + : this.setAttributeNS(t.space, t.local, e) + } + } + function ii(t) { + return function () { + this + .style + .removeProperty(t) + } + } + function oi(t, n, e) { + return function () { + this + .style + .setProperty(t, n, e) + } + } + function ui(t, n, e) { + return function () { + var r = n.apply(this, arguments); + null == r + ? this + .style + .removeProperty(t) + : this + .style + .setProperty(t, r, e) + } + } + function ai(t) { + return function () { + delete this[t] + } + } + function ci(t, n) { + return function () { + this[t] = n + } + } + function si(t, n) { + return function () { + var e = n.apply(this, arguments); + null == e + ? delete this[t] + : this[t] = e + } + } + function fi(t) { + return t + .trim() + .split(/^|\s+/) + } + function li(t) { + return t.classList || new hi(t) + } + function hi(t) { + this._node = t, + this._names = fi(t.getAttribute("class") || "") + } + function pi(t, n) { + for (var e = li(t), r = -1, i = n.length; ++r < i;) + e.add(n[r]) + } + function di(t, n) { + for (var e = li(t), r = -1, i = n.length; ++r < i;) + e.remove(n[r]) + } + function vi(t) { + return function () { + pi(this, t) + } + } + function _i(t) { + return function () { + di(this, t) + } + } + function yi(t, n) { + return function () { + (n.apply(this, arguments) + ? pi + : di)(this, t) + } + } + function gi() { + this.textContent = "" + } + function mi(t) { + return function () { + this.textContent = t + } + } + function xi(t) { + return function () { + var n = t.apply(this, arguments); + this.textContent = null == n + ? "" + : n + } + } + function bi() { + this.innerHTML = "" + } + function wi(t) { + return function () { + this.innerHTML = t + } + } + function Mi(t) { + return function () { + var n = t.apply(this, arguments); + this.innerHTML = null == n + ? "" + : n + } + } + function Ti() { + this.nextSibling && this + .parentNode + .appendChild(this) + } + function Ni() { + this.previousSibling && this + .parentNode + .insertBefore(this, this.parentNode.firstChild) + } + function ki() { + return null + } + function Si() { + var t = this.parentNode; + t && t.removeChild(this) + } + function Ai(t, n, e) { + var r = iy(t), + i = r.CustomEvent; + i + ? i = new i(n, e) + : (i = r.document.createEvent("Event"), e + ? (i.initEvent(n, e.bubbles, e.cancelable), i.detail = e.detail) + : i.initEvent(n, !1, !1)), + t.dispatchEvent(i) + } + function Ei(t, n) { + return function () { + return Ai(this, t, n) + } + } + function Ci(t, n) { + return function () { + return Ai(this, t, n.apply(this, arguments)) + } + } + function zi(t, n) { + this._groups = t, + this._parents = n + } + function Pi() { + return new zi([ + [document.documentElement] + ], yy) + } + function qi(t, n) { + var e = t.__transition; + if (!e || !(e = e[n]) || e.state > Ty) + throw new Error("too late"); + return e + } + function Li(t, n) { + var e = t.__transition; + if (!e || !(e = e[n]) || e.state > ky) + throw new Error("too late"); + return e + } + function Ri(t, n) { + var e = t.__transition; + if (!e || !(e = e[n])) + throw new Error("too late"); + return e + } + function Ui(t, n, e) { + function r(t) { + e.state = Ny, + e + .timer + .restart(i, e.delay, e.time), + e.delay <= t && i(t - e.delay) + } + function i(r) { + var s, + f, + l, + h; + if (e.state !== Ny) + return u(); + for (s in c) + if (h = c[s], h.name === e.name) { + if (h.state === Sy) + return pd(i); + h.state === Ay + ? (h.state = Cy, h.timer.stop(), h.on.call("interrupt", t, t.__data__, h.index, h.group), delete c[s]) :+ s < n && (h.state = Cy, h.timer.stop(), delete c[s]) + } + if (pd(function () { + e.state === Sy && (e.state = Ay, e.timer.restart(o, e.delay, e.time), o(r)) + }), e.state = ky, e.on.call("start", t, t.__data__, e.index, e.group), e.state === ky) { + for (e.state = Sy, a = new Array(l = e.tween.length), s = 0, f = -1; s < l; ++s) + (h = e.tween[s].value.call(t, t.__data__, e.index, e.group)) && (a[++f] = h); + a.length = f + 1 + } + } + function o(n) { + for (var r = n < e.duration + ? e.ease.call(null, n / e.duration) + : (e.timer.restart(u), e.state = Ey, 1), i = -1, o = a.length; ++i < o;) + a[i].call(null, r); + e.state === Ey && (e.on.call("end", t, t.__data__, e.index, e.group), u()) + } + function u() { + e.state = Cy, + e + .timer + .stop(), + delete c[n]; + for (var r in c) + return; + delete t.__transition + } + var a, + c = t.__transition; + c[n] = e, + e.timer = Vn(r, 0, e.time) + } + function Di(t, n) { + var e, + r; + return function () { + var i = Li(this, t), + o = i.tween; + if (o !== e) { + r = e = o; + for (var u = 0, a = r.length; u < a; ++u) + if (r[u].name === n) { + r = r.slice(), + r.splice(u, 1); + break + } + } + i.tween = r + } + } + function Oi(t, n, e) { + var r, + i; + if ("function" != typeof e) + throw new Error; + return function () { + var o = Li(this, t), + u = o.tween; + if (u !== r) { + i = (r = u).slice(); + for (var a = { + name: n, + value: e + }, c = 0, s = i.length; c < s; ++c) + if (i[c].name === n) { + i[c] = a; + break + } + c === s && i.push(a) + } + o.tween = i + } + } + function Fi(t, n, e) { + var r = t._id; + return t.each(function () { + var t = Li(this, r); + (t.value || (t.value = {}))[n] = e.apply(this, arguments) + }), + function (t) { + return Ri(t, r).value[n] + } + } + function Ii(t) { + return function () { + this.removeAttribute(t) + } + } + function Yi(t) { + return function () { + this.removeAttributeNS(t.space, t.local) + } + } + function Bi(t, n, e) { + var r, + i; + return function () { + var o = this.getAttribute(t); + return o === e + ? null + : o === r + ? i + : i = n(r = o, e) + } + } + function ji(t, n, e) { + var r, + i; + return function () { + var o = this.getAttributeNS(t.space, t.local); + return o === e + ? null + : o === r + ? i + : i = n(r = o, e) + } + } + function Hi(t, n, e) { + var r, + i, + o; + return function () { + var u, + a = e(this); + return null == a + ? void this.removeAttribute(t) + : (u = this.getAttribute(t), u === a + ? null + : u === r && a === i + ? o + : o = n(r = u, i = a)) + } + } + function Xi(t, n, e) { + var r, + i, + o; + return function () { + var u, + a = e(this); + return null == a + ? void this.removeAttributeNS(t.space, t.local) + : (u = this.getAttributeNS(t.space, t.local), u === a + ? null + : u === r && a === i + ? o + : o = n(r = u, i = a)) + } + } + function Vi(t, n) { + function e() { + var e = this, + r = n.apply(e, arguments); + return r && function (n) { + e.setAttributeNS(t.space, t.local, r(n)) + } + } + return e._value = n, + e + } + function Wi(t, n) { + function e() { + var e = this, + r = n.apply(e, arguments); + return r && function (n) { + e.setAttribute(t, r(n)) + } + } + return e._value = n, + e + } + function $i(t, n) { + return function () { + qi(this, t).delay =+ n.apply(this, arguments) + } + } + function Zi(t, n) { + return n =+ n, + function () { + qi(this, t).delay = n + } + } + function Gi(t, n) { + return function () { + Li(this, t).duration =+ n.apply(this, arguments) + } + } + function Ji(t, n) { + return n =+ n, + function () { + Li(this, t).duration = n + } + } + function Qi(t, n) { + if ("function" != typeof n) + throw new Error; + return function () { + Li(this, t).ease = n + } + } + function Ki(t) { + return (t + "") + .trim() + .split(/^|\s+/) + .every(function (t) { + var n = t.indexOf("."); + return n >= 0 && (t = t.slice(0, n)), + !t || "start" === t + }) + } + function to(t, n, e) { + var r, + i, + o = Ki(n) + ? qi + : Li; + return function () { + var u = o(this, t), + a = u.on; + a !== r && (i = (r = a).copy()).on(n, e), + u.on = i + } + } + function no(t) { + return function () { + var n = this.parentNode; + for (var e in this.__transition) + if (+ e !== t) + return; + n && n.removeChild(this) + } + } + function eo(t, n) { + var e, + r, + i; + return function () { + var o = iy(this).getComputedStyle(this, null), + u = o.getPropertyValue(t), + a = (this.style.removeProperty(t), o.getPropertyValue(t)); + return u === a + ? null + : u === e && a === r + ? i + : i = n(e = u, r = a) + } + } + function ro(t) { + return function () { + this + .style + .removeProperty(t) + } + } + function io(t, n, e) { + var r, + i; + return function () { + var o = iy(this) + .getComputedStyle(this, null) + .getPropertyValue(t); + return o === e + ? null + : o === r + ? i + : i = n(r = o, e) + } + } + function oo(t, n, e) { + var r, + i, + o; + return function () { + var u = iy(this).getComputedStyle(this, null), + a = u.getPropertyValue(t), + c = e(this); + return null == c && (this.style.removeProperty(t), c = u.getPropertyValue(t)), + a === c + ? null + : a === r && c === i + ? o + : o = n(r = a, i = c) + } + } + function uo(t, n, e) { + function r() { + var r = this, + i = n.apply(r, arguments); + return i && function (n) { + r + .style + .setProperty(t, i(n), e) + } + } + return r._value = n, + r + } + function ao(t) { + return function () { + this.textContent = t + } + } + function co(t) { + return function () { + var n = t(this); + this.textContent = null == n + ? "" + : n + } + } + function so(t, n, e, r) { + this._groups = t, + this._parents = n, + this._name = e, + this._id = r + } + function fo(t) { + return Pi().transition(t) + } + function lo() { + return++ Ky + } + function ho(t, n) { + for (var e; !(e = t.__transition) || !(e = e[n]);) + if (!(t = t.parentNode)) + return ng.time = jn(), + ng; + return e + } + function po(t, n, e) { + var r = t(e); + return "translate(" + (isFinite(r) + ? r + : n(e)) + ",0)" + } + function vo(t, n, e) { + var r = t(e); + return "translate(0," + (isFinite(r) + ? r + : n(e)) + ")" + } + function _o(t) { + var n = t.bandwidth() / 2; + return t.round() && (n = Math.round(n)), + function (e) { + return t(e) + n + } + } + function yo() { + return !this.__axis + } + function go(t, n) { + function e(e) { + var s, + f = null == i + ? n.ticks + ? n + .ticks + .apply(n, r) + : n.domain() + : i, + l = null == o + ? n.tickFormat + ? n + .tickFormat + .apply(n, r) + : ug + : o, + h = Math.max(u, 0) + c, + p = t === ag || t === sg + ? po + : vo, + d = n.range(), + v = d[0] + .5, + _ = d[d.length - 1] + .5, + y = (n.bandwidth + ? _o + : ug)(n.copy()), + g = e.selection + ? e.selection() + : e, + m = g + .selectAll(".domain") + .data([null]), + x = g + .selectAll(".tick") + .data(f, n) + .order(), + b = x.exit(), + w = x + .enter() + .append("g") + .attr("class", "tick"), + M = x.select("line"), + T = x.select("text"), + N = t === ag || t === fg + ? -1 + : 1, + k = t === fg || t === cg + ? (s = "x", "y") + : (s = "y", "x"); + m = m.merge(m.enter().insert("path", ".tick").attr("class", "domain").attr("stroke", "#000")), + x = x.merge(w), + M = M.merge(w.append("line").attr("stroke", "#000").attr(s + "2", N * u).attr(k + "1", .5).attr(k + "2", .5)), + T = T.merge(w.append("text").attr("fill", "#000").attr(s, N * h).attr(k, .5).attr("dy", t === ag + ? "0em" + : t === sg + ? "0.71em" + : "0.32em")), + e !== g && (m = m.transition(e), x = x.transition(e), M = M.transition(e), T = T.transition(e), b = b.transition(e).attr("opacity", lg).attr("transform", function (t) { + return p(y, this.parentNode.__axis || y, t) + }), w.attr("opacity", lg).attr("transform", function (t) { + return p(this.parentNode.__axis || y, y, t) + })), + b.remove(), + m.attr("d", t === fg || t == cg + ? "M" + N * a + "," + v + "H0.5V" + _ + "H" + N * a + : "M" + v + "," + N * a + "V0.5H" + _ + "V" + N * a), + x + .attr("opacity", 1) + .attr("transform", function (t) { + return p(y, y, t) + }), + M.attr(s + "2", N * u), + T + .attr(s, N * h) + .text(l), + g + .filter(yo) + .attr("fill", "none") + .attr("font-size", 10) + .attr("font-family", "sans-serif") + .attr("text-anchor", t === cg + ? "start" + : t === fg + ? "end" + : "middle"), + g.each(function () { + this.__axis = y + }) + } + var r = [], + i = null, + o = null, + u = 6, + a = 6, + c = 3; + return e.scale = function (t) { + return arguments.length + ? (n = t, e) + : n + }, + e.ticks = function () { + return r = og.call(arguments), + e + }, + e.tickArguments = function (t) { + return arguments.length + ? (r = null == t + ? [] + : og.call(t), e) + : r.slice() + }, + e.tickValues = function (t) { + return arguments.length + ? (i = null == t + ? null + : og.call(t), e) + : i && i.slice() + }, + e.tickFormat = function (t) { + return arguments.length + ? (o = t, e) + : o + }, + e.tickSize = function (t) { + return arguments.length + ? (u = a =+ t, e) + : u + }, + e.tickSizeInner = function (t) { + return arguments.length + ? (u =+ t, e) + : u + }, + e.tickSizeOuter = function (t) { + return arguments.length + ? (a =+ t, e) + : a + }, + e.tickPadding = function (t) { + return arguments.length + ? (c =+ t, e) + : c + }, + e + } + function mo(t) { + return go(ag, t) + } + function xo(t) { + return go(cg, t) + } + function bo(t) { + return go(sg, t) + } + function wo(t) { + return go(fg, t) + } + function Mo(t, n) { + return t.parent === n.parent + ? 1 + : 2 + } + function To(t) { + return t.reduce(No, 0) / t.length + } + function No(t, n) { + return t + n.x + } + function ko(t) { + return 1 + t.reduce(So, 0) + } + function So(t, n) { + return Math.max(t, n.y) + } + function Ao(t) { + for (var n; n = t.children;) + t = n[0]; + return t + } + function Eo(t) { + for (var n; n = t.children;) + t = n[n.length - 1]; + return t + } + function Co(t, n) { + if (t === n) + return t; + var e = t.ancestors(), + r = n.ancestors(), + i = null; + for (t = e.pop(), n = r.pop(); t === n;) + i = t, + t = e.pop(), + n = r.pop(); + return i + } + function zo(t, n) { + var e, + r, + i, + o, + u, + a = new Uo(t), + c =+ t.value && (a.value = t.value), + s = [a]; + for (null == n && (n = qo); e = s.pop();) + if (c && (e.value =+ e.data.value), (i = n(e.data)) && (u = i.length)) + for (e.children = new Array(u), o = u - 1; o >= 0; --o) + s.push(r = e.children[o] = new Uo(i[o])), + r.parent = e, + r.depth = e.depth + 1; + return a.eachBefore(Ro) + } + function Po() { + return zo(this).eachBefore(Lo) + } + function qo(t) { + return t.children + } + function Lo(t) { + t.data = t.data.data + } + function Ro(t) { + var n = 0; + do + t.height = n; + while ((t = t.parent) && t.height < ++n) + } + function Uo(t) { + this.data = t, + this.depth = this.height = 0, + this.parent = null + } + function Do(t) { + this._ = t, + this.next = null + } + function Oo(t, n) { + var e = n.x - t.x, + r = n.y - t.y, + i = t.r - n.r; + return i * i + 1e-6 > e * e + r * r + } + function Fo(t, n) { + var e, + r, + i, + o = null, + u = t.head; + switch (n.length) { + case 1: + e = Io(n[0]); + break; + case 2: + e = Yo(n[0], n[1]); + break; + case 3: + e = Bo(n[0], n[1], n[2]) + } + for (; u;) + i = u._, + r = u.next, + e && Oo(e, i) + ? o = u + : (o + ? (t.tail = o, o.next = null) + : t.head = t.tail = null, n.push(i), e = Fo(t, n), n.pop(), t.head + ? (u.next = t.head, t.head = u) + : (u.next = null, t.head = t.tail = u), o = t.tail, o.next = r), + u = r; + return t.tail = o, + e + } + function Io(t) { + return {x: t.x, y: t.y, r: t.r} + } + function Yo(t, n) { + var e = t.x, + r = t.y, + i = t.r, + o = n.x, + u = n.y, + a = n.r, + c = o - e, + s = u - r, + f = a - i, + l = Math.sqrt(c * c + s * s); + return { + x: (e + o + c / l * f) / 2, + y: (r + u + s / l * f) / 2, + r: (l + i + a) / 2 + } + } + function Bo(t, n, e) { + var r = t.x, + i = t.y, + o = t.r, + u = n.x, + a = n.y, + c = n.r, + s = e.x, + f = e.y, + l = e.r, + h = 2 * (r - u), + p = 2 * (i - a), + d = 2 * (c - o), + v = r * r + i * i - o * o - u * u - a * a + c * c, + _ = 2 * (r - s), + y = 2 * (i - f), + g = 2 * (l - o), + m = r * r + i * i - o * o - s * s - f * f + l * l, + x = _ * p - h * y, + b = (p * m - y * v) / x - r, + w = (y * d - p * g) / x, + M = (_ * v - h * m) / x - i, + T = (h * g - _ * d) / x, + N = w * w + T * T - 1, + k = 2 * (b * w + M * T + o), + S = b * b + M * M - o * o, + A = (-k - Math.sqrt(k * k - 4 * N * S)) / (2 * N); + return { + x: b + *A + r, + y: M + *A + i, + r: A + } + } + function jo(t, n, e) { + var r = t.x, + i = t.y, + o = n.r + e.r, + u = t.r + e.r, + a = n.x - r, + c = n.y - i, + s = a * a + c * c; + if (s) { + var f = .5 + ((u *= u) - (o *= o)) / (2 * s), + l = Math.sqrt(Math.max(0, 2 * o * (u + s) - (u -= s) * u - o * o)) / (2 * s); + e.x = r + f * a + l * c, + e.y = i + f * c - l * a + } else + e.x = r + u, + e.y = i + } + function Ho(t, n) { + var e = n.x - t.x, + r = n.y - t.y, + i = t.r + n.r; + return i * i > e * e + r * r + } + function Xo(t, n, e) { + var r = t.x - n, + i = t.y - e; + return r * r + i * i + } + function Vo(t) { + this._ = t, + this.next = null, + this.previous = null + } + function Wo(t) { + if (!(i = t.length)) + return 0; + var n, + e, + r, + i; + if (n = t[0], n.x = 0, n.y = 0, !(i > 1)) + return n.r; + if (e = t[1], n.x = -e.r, e.x = n.r, e.y = 0, !(i > 2)) + return n.r + e.r; + jo(e, n, r = t[2]); + var o, + u, + a, + c, + s, + f, + l, + h = n.r * n.r, + p = e.r * e.r, + d = r.r * r.r, + v = h + p + d, + _ = h * n.x + p * e.x + d * r.x, + y = h * n.y + p * e.y + d * r.y; + n = new Vo(n), + e = new Vo(e), + r = new Vo(r), + n.next = r.previous = e, + e.next = n.previous = r, + r.next = e.previous = n; + t : for (a = 3; a < i; ++a) { + if (jo(n._, e._, r = t[a]), r = new Vo(r), (s = n.previous) === (c = e.next)) { + if (Ho(c._, r._)) { + n = e, + e = c, + --a; + continue t + } + } else { + f = c._.r, + l = s._.r; + do + if (f <= l) { + if (Ho(c._, r._)) { + e = c, + n.next = e, + e.previous = n, + --a; + continue t + } + c = c.next, + f += c._.r + } + else { + if (Ho(s._, r._)) { + n = s, + n.next = e, + e.previous = n, + --a; + continue t + } + s = s.previous, + l += s._.r + } + while (c !== s.next) + } + for (r.previous = n, r.next = e, n.next = e.previous = e = r, v += d = r._.r * r._.r, _ += d * r._.x, y += d * r._.y, h = Xo(n._, o = _ / v, u = y / v); (r = r.next) !== e;) + (d = Xo(r._, o, u)) < h && (n = r, h = d); + e = n.next + } + for (n = [e._], r = e; (r = r.next) !== e;) + n.push(r._); + for (r = Tg(n), a = 0; a < i; ++a) + n = t[a], + n.x -= r.x, + n.y -= r.y; + return r.r + } + function $o(t) { + return null == t + ? null + : Zo(t) + } + function Zo(t) { + if ("function" != typeof t) + throw new Error; + return t + } + function Go() { + return 0 + } + function Jo(t) { + return Math.sqrt(t.value) + } + function Qo(t) { + return function (n) { + n.children || (n.r = Math.max(0, + t(n) || 0)) + } + } + function Ko(t, n) { + return function (e) { + if (r = e.children) { + var r, + i, + o, + u = r.length, + a = t(e) * n || 0; + if (a) + for (i = 0; i < u; ++i) + r[i].r += a; + if (o = Wo(r), a) + for (i = 0; i < u; ++i) + r[i].r -= a; + e.r = o + a + } + } + } + function tu(t) { + return function (n) { + var e = n.parent; + n.r *= t, + e && (n.x = e.x + t * n.x, n.y = e.y + t * n.y) + } + } + function nu(t) { + return t.id + } + function eu(t) { + return t.parentId + } + function ru(t, n) { + return t.parent === n.parent + ? 1 + : 2 + } + function iu(t) { + var n = t.children; + return n + ? n[0] + : t.t + } + function ou(t) { + var n = t.children; + return n + ? n[n.length - 1] + : t.t + } + function uu(t, n, e) { + var r = e / (n.i - t.i); + n.c -= r, + n.s += e, + t.c += r, + n.z += e, + n.m += e + } + function au(t) { + for (var n, e = 0, r = 0, i = t.children, o = i.length; --o >= 0;) + n = i[o], + n.z += e, + n.m += e, + e += n.s + (r += n.c) + } + function cu(t, n, e) { + return t.a.parent === n.parent + ? t.a + : e + } + function su(t, n) { + this._ = t, + this.parent = null, + this.children = null, + this.A = null, + this.a = this, + this.z = 0, + this.m = 0, + this.c = 0, + this.s = 0, + this.t = null, + this.i = n + } + function fu(t) { + for (var n, e, r, i, o, u = new su(t, 0), a = [u]; n = a.pop();) + if (r = n._.children) + for (n.children = new Array(o = r.length), i = o - 1; i >= 0; --i) + a.push(e = n.children[i] = new su(r[i], i)), + e.parent = n; + return (u.parent = new su(null, 0)).children = [u], + u + } + function lu(t, n, e, r, i, o) { + for (var u, a, c, s, f, l, h, p, d, v, _, y, g = [], m = n.children, x = 0, b = m.length, w = n.value; x < b;) { + for (s = i - e, f = o - r, h = p = l = m[x].value, _ = Math.max(f / s, s / f) / (w * t), y = l * l * _, v = Math.max(p / y, y / h), c = x + 1; c < b; ++c) { + if (l += a = m[c].value, a < h && (h = a), a > p && (p = a), y = l * l * _, d = Math.max(p / y, y / h), d > v) { + l -= a; + break + } + v = d + } + g.push(u = { + value: l, + dice: s < f, + children: m.slice(x, c) + }), + u.dice + ? Eg(u, e, r, i, w + ? r += f * l / w + : o) + : Ug(u, e, r, w + ? e += s * l / w + : i, o), + w -= l, + x = c + } + return g + } + function hu(t) { + return t.x + t.vx + } + function pu(t) { + return t.y + t.vy + } + function du(t, n) { + return n + } + function vu(t, n) { + var e = t.get(n); + if (!e) + throw new Error("missing: " + n); + return e + } + function _u(t) { + return t.x + } + function yu(t) { + return t.y + } + function gu() { + t + .event + .stopImmediatePropagation() + } + function mu(t, n) { + var e = t.document.documentElement, + r = gy(t).on("dragstart.drag", null); + n && (r.on("click.drag", tm, !0), setTimeout(function () { + r.on("click.drag", null) + }, 0)), + "onselectstart" in e + ? r.on("selectstart.drag", null) + : (e.style.MozUserSelect = e.__noselect, delete e.__noselect) + } + function xu(t, n, e, r, i, o, u, a, c, s) { + this.target = t, + this.type = n, + this.subject = e, + this.identifier = r, + this.active = i, + this.x = o, + this.y = u, + this.dx = a, + this.dy = c, + this._ = s + } + function bu() { + return !t.event.button + } + function wu() { + return this.parentNode + } + function Mu(n) { + return null == n + ? { + x: t.event.x, + y: t.event.y + } + : n + } + function Tu(t) { + return t[0] + } + function Nu(t) { + return t[1] + } + function ku() { + this._ = null + } + function Su(t) { + t.U = t.C = t.L = t.R = t.P = t.N = null + } + function Au(t, n) { + var e = n, + r = n.R, + i = e.U; + i + ? i.L === e + ? i.L = r + : i.R = r + : t._ = r, + r.U = i, + e.U = r, + e.R = r.L, + e.R && (e.R.U = e), + r.L = e + } + function Eu(t, n) { + var e = n, + r = n.L, + i = e.U; + i + ? i.L === e + ? i.L = r + : i.R = r + : t._ = r, + r.U = i, + e.U = r, + e.L = r.R, + e.L && (e.L.U = e), + r.R = e + } + function Cu(t) { + for (; t.L;) + t = t.L; + return t + } + function zu(t, n, e, r) { + var i = [ + null, null + ], + o = sm.push(i) - 1; + return i.left = t, + i.right = n, + e && qu(i, t, n, e), + r && qu(i, n, t, r), + am[t.index] + .halfedges + .push(o), + am[n.index] + .halfedges + .push(o), + i + } + function Pu(t, n, e) { + var r = [n, e]; + return r.left = t, + r + } + function qu(t, n, e, r) { + t[0] || t[1] + ? t.left === e + ? t[1] = r + : t[0] = r + : (t[0] = r, t.left = n, t.right = e) + } + function Lu(t, n, e, r, i) { + var o, + u = t[0], + a = t[1], + c = u[0], + s = u[1], + f = a[0], + l = a[1], + h = 0, + p = 1, + d = f - c, + v = l - s; + if (o = n - c, d || !(o > 0)) { + if (o /= d, d < 0) { + if (o < h) + return; + o < p && (p = o) + } else if (d > 0) { + if (o > p) + return; + o > h && (h = o) + } + if (o = r - c, d || !(o < 0)) { + if (o /= d, d < 0) { + if (o > p) + return; + o > h && (h = o) + } else if (d > 0) { + if (o < h) + return; + o < p && (p = o) + } + if (o = e - s, v || !(o > 0)) { + if (o /= v, v < 0) { + if (o < h) + return; + o < p && (p = o) + } else if (v > 0) { + if (o > p) + return; + o > h && (h = o) + } + if (o = i - s, v || !(o < 0)) { + if (o /= v, v < 0) { + if (o > p) + return; + o > h && (h = o) + } else if (v > 0) { + if (o < h) + return; + o < p && (p = o) + } + return !(h > 0 || p < 1) || (h > 0 && (t[0] = [ + c + h * d, + s + h * v + ]), p < 1 && (t[1] = [ + c + p * d, + s + p * v + ]), !0) + } + } + } + } + } + function Ru(t, n, e, r, i) { + var o = t[1]; + if (o) + return !0; + var u, + a, + c = t[0], + s = t.left, + f = t.right, + l = s[0], + h = s[1], + p = f[0], + d = f[1], + v = (l + p) / 2, + _ = (h + d) / 2; + if (d === h) { + if (v < n || v >= r) + return; + if (l > p) { + if (c) { + if (c[1] >= i) + return + } else + c = [v, e]; + o = [v, i] + } else { + if (c) { + if (c[1] < e) + return + } else + c = [v, i]; + o = [v, e] + } + } else if (u = (l - p) / (d - h), a = _ - u * v, u < -1 || u > 1) + if (l > p) { + if (c) { + if (c[1] >= i) + return + } else + c = [ + (e - a) / u, + e + ]; + o = [ + (i - a) / u, + i + ] + } + else { + if (c) { + if (c[1] < e) + return + } else + c = [ + (i - a) / u, + i + ]; + o = [ + (e - a) / u, + e + ] + } else if (h < d) { + if (c) { + if (c[0] >= r) + return + } else + c = [ + n, u * n + a + ]; + o = [ + r, u * r + a + ] + } else { + if (c) { + if (c[0] < n) + return + } else + c = [ + r, u * r + a + ]; + o = [ + n, u * n + a + ] + } + return t[0] = c, + t[1] = o, + !0 + } + function Uu(t, n, e, r) { + for (var i, o = sm.length; o--;) + Ru(i = sm[o], t, n, e, r) && Lu(i, t, n, e, r) && (Math.abs(i[0][0] - i[1][0]) > hm || Math.abs(i[0][1] - i[1][1]) > hm) || delete sm[o] + } + function Du(t) { + return am[t.index] = { + site: t, + halfedges: [] + } + } + function Ou(t, n) { + var e = t.site, + r = n.left, + i = n.right; + return e === i && (i = r, r = e), + i + ? Math.atan2(i[1] - r[1], i[0] - r[0]) + : (e === r + ? (r = n[1], i = n[0]) + : (r = n[0], i = n[1]), Math.atan2(r[0] - i[0], i[1] - r[1])) + } + function Fu(t, n) { + return n[+ (n.left !== t.site)] + } + function Iu(t, n) { + return n[+ (n.left === t.site)] + } + function Yu() { + for (var t, n, e, r, i = 0, o = am.length; i < o; ++i) + if ((t = am[i]) && (r = (n = t.halfedges).length)) { + var u = new Array(r), + a = new Array(r); + for (e = 0; e < r; ++e) + u[e] = e, + a[e] = Ou(t, sm[n[e]]); + for (u.sort(function (t, n) { + return a[n] - a[t] + }), e = 0; e < r; ++e) + a[e] = n[u[e]]; + for (e = 0; e < r; ++e) + n[e] = a[e] + } + } + function Bu(t, n, e, r) { + var i, + o, + u, + a, + c, + s, + f, + l, + h, + p, + d, + v, + _ = am.length, + y = !0; + for (i = 0; i < _; ++i) + if (o = am[i]) { + for (u = o.site, c = o.halfedges, a = c.length; a--;) + sm[c[a]] || c.splice(a, 1); + for (a = 0, s = c.length; a < s;) + p = Iu(o, sm[c[a]]), + d = p[0], + v = p[1], + f = Fu(o, sm[c[++a % s]]), + l = f[0], + h = f[1], + (Math.abs(d - l) > hm || Math.abs(v - h) > hm) && (c.splice(a, 0, sm.push(Pu(u, p, Math.abs(d - t) < hm && r - v > hm + ? [ + t, Math.abs(l - t) < hm + ? h + : r + ] + : Math.abs(v - r) < hm && e - d > hm + ? [ + Math.abs(h - r) < hm + ? l + : e, + r + ] + : Math.abs(d - e) < hm && v - n > hm + ? [ + e, Math.abs(l - e) < hm + ? h + : n + ] + : Math.abs(v - n) < hm && d - t > hm + ? [ + Math.abs(h - n) < hm + ? l + : t, + n + ] + : null)) - 1), ++s); + s && (y = !1) + } + if (y) { + var g, + m, + x, + b = 1 / 0; + for (i = 0, y = null; i < _; ++i) + (o = am[i]) && (u = o.site, g = u[0] - t, m = u[1] - n, x = g * g + m * m, x < b && (b = x, y = o)); + if (y) { + var w = [ + t, n + ], + M = [ + t, r + ], + T = [ + e, r + ], + N = [e, n]; + y + .halfedges + .push(sm.push(Pu(u = y.site, w, M)) - 1, sm.push(Pu(u, M, T)) - 1, sm.push(Pu(u, T, N)) - 1, sm.push(Pu(u, N, w)) - 1) + } + } + for (i = 0; i < _; ++i) + (o = am[i]) && (o.halfedges.length || delete am[i]) + } + function ju() { + Su(this), + this.x = this.y = this.arc = this.site = this.cy = null + } + function Hu(t) { + var n = t.P, + e = t.N; + if (n && e) { + var r = n.site, + i = t.site, + o = e.site; + if (r !== o) { + var u = i[0], + a = i[1], + c = r[0] - u, + s = r[1] - a, + f = o[0] - u, + l = o[1] - a, + h = 2 * (c * l - s * f); + if (!(h >= -pm)) { + var p = c * c + s * s, + d = f * f + l * l, + v = (l * p - s * d) / h, + _ = (c * d - f * p) / h, + y = fm.pop() || new ju; + y.arc = t, + y.site = i, + y.x = v + u, + y.y = (y.cy = _ + a) + Math.sqrt(v * v + _ * _), + t.circle = y; + for (var g = null, m = cm._; m;) + if (y.y < m.y || y.y === m.y && y.x <= m.x) { + if (!m.L) { + g = m.P; + break + } + m = m.L + } + else { + if (!m.R) { + g = m; + break + } + m = m.R + } + cm.insert(g, y), + g || (om = y) + } + } + } + } + function Xu(t) { + var n = t.circle; + n && (n.P || (om = n.N), cm.remove(n), fm.push(n), Su(n), t.circle = null) + } + function Vu() { + Su(this), + this.edge = this.site = this.circle = null + } + function Wu(t) { + var n = lm.pop() || new Vu; + return n.site = t, + n + } + function $u(t) { + Xu(t), + um.remove(t), + lm.push(t), + Su(t) + } + function Zu(t) { + var n = t.circle, + e = n.x, + r = n.cy, + i = [ + e, r + ], + o = t.P, + u = t.N, + a = [t]; + $u(t); + for (var c = o; c.circle && Math.abs(e - c.circle.x) < hm && Math.abs(r - c.circle.cy) < hm;) + o = c.P, + a.unshift(c), + $u(c), + c = o; + a.unshift(c), + Xu(c); + for (var s = u; s.circle && Math.abs(e - s.circle.x) < hm && Math.abs(r - s.circle.cy) < hm;) + u = s.N, + a.push(s), + $u(s), + s = u; + a.push(s), + Xu(s); + var f, + l = a.length; + for (f = 1; f < l; ++f) + s = a[f], + c = a[f - 1], + qu(s.edge, c.site, s.site, i); + c = a[0], + s = a[l - 1], + s.edge = zu(c.site, s.site, null, i), + Hu(c), + Hu(s) + } + function Gu(t) { + for (var n, e, r, i, o = t[0], u = t[1], a = um._; a;) + if (r = Ju(a, u) - o, r > hm) + a = a.L; + else { + if (i = o - Qu(a, u), !(i > hm)) { + r > -hm + ? (n = a.P, e = a) + : i > -hm + ? (n = a, e = a.N) + : n = e = a; + break + } + if (!a.R) { + n = a; + break + } + a = a.R + } + Du(t); + var c = Wu(t); + if (um.insert(n, c), n || e) { + if (n === e) + return Xu(n), + e = Wu(n.site), + um.insert(c, e), + c.edge = e.edge = zu(n.site, c.site), + Hu(n), + void Hu(e); + if (!e) + return void(c.edge = zu(n.site, c.site)); + Xu(n), + Xu(e); + var s = n.site, + f = s[0], + l = s[1], + h = t[0] - f, + p = t[1] - l, + d = e.site, + v = d[0] - f, + _ = d[1] - l, + y = 2 * (h * _ - p * v), + g = h * h + p * p, + m = v * v + _ * _, + x = [ + (_ * g - p * m) / y + f, + (h * m - v * g) / y + l + ]; + qu(e.edge, s, d, x), + c.edge = zu(s, t, null, x), + e.edge = zu(t, d, null, x), + Hu(n), + Hu(e) + } + } + function Ju(t, n) { + var e = t.site, + r = e[0], + i = e[1], + o = i - n; + if (!o) + return r; + var u = t.P; + if (!u) + return -(1 / 0); + e = u.site; + var a = e[0], + c = e[1], + s = c - n; + if (!s) + return a; + var f = a - r, + l = 1 / o - 1 / s, + h = f / s; + return l + ? (-h + Math.sqrt(h * h - 2 * l * (f * f / (-2 * s) - c + s / 2 + i - o / 2))) / l + r + : (r + a) / 2 + } + function Qu(t, n) { + var e = t.N; + if (e) + return Ju(e, n); + var r = t.site; + return r[1] === n + ? r[0] + : 1 / 0 + } + function Ku(t, n, e) { + return (t[0] - e[0]) * (n[1] - t[1]) - (t[0] - n[0]) * (e[1] - t[1]) + } + function ta(t, n) { + return n[1] - t[1] || n[0] - t[0] + } + function na(t, n) { + var e, + r, + i, + o = t + .sort(ta) + .pop(); + for (sm = [], am = new Array(t.length), um = new ku, cm = new ku;;) + if (i = om, o && (!i || o[1] < i.y || o[1] === i.y && o[0] < i.x)) + o[0] === e && o[1] === r || (Gu(o), e = o[0], r = o[1]), + o = t.pop(); + else { + if (!i) + break; + Zu(i.arc) + } + if (Yu(), n) { + var u =+ n[0][0], + a =+ n[0][1], + c =+ n[1][0], + s =+ n[1][1]; + Uu(u, a, c, s), + Bu(u, a, c, s) + } + this.edges = sm, + this.cells = am, + um = cm = sm = am = null + } + function ea(t, n, e) { + this.target = t, + this.type = n, + this.transform = e + } + function ra(t, n, e) { + this.k = t, + this.x = n, + this.y = e + } + function ia(t) { + return t.__zoom || _m + } + function oa() { + t + .event + .stopImmediatePropagation() + } + function ua() { + return !t.event.button + } + function aa() { + var t, + n, + e = this; + return e instanceof SVGElement + ? (e = e.ownerSVGElement || e, t = e.width.baseVal.value, n = e.height.baseVal.value) + : (t = e.clientWidth, n = e.clientHeight), + [ + [ + 0, 0 + ], + [t, n] + ] + } + function ca() { + return this.__zoom || _m + } + function sa() { + t + .event + .stopImmediatePropagation() + } + function fa(t) { + return {type: t} + } + function la() { + return !t.event.button + } + function ha() { + var t = this.ownerSVGElement || this; + return [ + [ + 0, 0 + ], + [t.width.baseVal.value, t.height.baseVal.value] + ] + } + function pa(t) { + for (; !t.__brush;) + if (!(t = t.parentNode)) + return; + return t.__brush + } + function da(t) { + return t[0][0] === t[1][0] || t[0][1] === t[1][1] + } + function va(t) { + var n = t.__brush; + return n + ? n + .dim + .output(n.selection) + : null + } + function _a() { + return ga(km) + } + function ya() { + return ga(Sm) + } + function ga(n) { + function e(t) { + var e = t + .property("__brush", a) + .selectAll(".overlay") + .data([fa("overlay")]); + e + .enter() + .append("rect") + .attr("class", "overlay") + .attr("pointer-events", "all") + .attr("cursor", Em.overlay) + .merge(e) + .each(function () { + var t = pa(this).extent; + gy(this) + .attr("x", t[0][0]) + .attr("y", t[0][1]) + .attr("width", t[1][0] - t[0][0]) + .attr("height", t[1][1] - t[0][1]) + }), + t + .selectAll(".selection") + .data([fa("selection")]) + .enter() + .append("rect") + .attr("class", "selection") + .attr("cursor", Em.selection) + .attr("fill", "#777") + .attr("fill-opacity", .3) + .attr("stroke", "#fff") + .attr("shape-rendering", "crispEdges"); + var i = t + .selectAll(".handle") + .data(n.handles, function (t) { + return t.type + }); + i + .exit() + .remove(), + i + .enter() + .append("rect") + .attr("class", function (t) { + return "handle handle--" + t.type + }) + .attr("cursor", function (t) { + return Em[t.type] + }), + t + .each(r) + .attr("fill", "none") + .attr("pointer-events", "all") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") + .on("mousedown.brush touchstart.brush", u) + } + function r() { + var t = gy(this), + n = pa(this).selection; + n + ? (t.selectAll(".selection").style("display", null).attr("x", n[0][0]).attr("y", n[0][1]).attr("width", n[1][0] - n[0][0]).attr("height", n[1][1] - n[0][1]), t.selectAll(".handle").style("display", null).attr("x", function (t) { + return "e" === t.type[t.type.length - 1] + ? n[1][0] - h / 2 + : n[0][0] - h / 2 + }).attr("y", function (t) { + return "s" === t.type[0] + ? n[1][1] - h / 2 + : n[0][1] - h / 2 + }).attr("width", function (t) { + return "n" === t.type || "s" === t.type + ? n[1][0] - n[0][0] + h + : h + }).attr("height", function (t) { + return "e" === t.type || "w" === t.type + ? n[1][1] - n[0][1] + h + : h + })) + : t + .selectAll(".selection,.handle") + .style("display", "none") + .attr("x", null) + .attr("y", null) + .attr("width", null) + .attr("height", null) + } + function i(t, n) { + return t.__brush.emitter || new o(t, n) + } + function o(t, n) { + this.that = t, + this.args = n, + this.state = t.__brush, + this.active = 0 + } + function u() { + function e() { + var t = U_(T); + !U || w || M || (Math.abs(t[0] - O[0]) > Math.abs(t[1] - O[1]) + ? M = !0 + : w = !0), + O = t, + b = !0, + bm(), + o() + } + function o() { + var t; + switch (m = O[0] - D[0], x = O[1] - D[1], k) { + case Mm: + case wm: + S && (m = Math.max(P - l, Math.min(L - v, m)), h = l + m, _ = v + m), + A && (x = Math.max(q - p, Math.min(R - y, x)), d = p + x, g = y + x); + break; + case Tm: + S < 0 + ? (m = Math.max(P - l, Math.min(L - l, m)), h = l + m, _ = v) + : S > 0 && (m = Math.max(P - v, Math.min(L - v, m)), h = l, _ = v + m), + A < 0 + ? (x = Math.max(q - p, Math.min(R - p, x)), d = p + x, g = y) + : A > 0 && (x = Math.max(q - y, Math.min(R - y, x)), d = p, g = y + x); + break; + case Nm: + S && (h = Math.max(P, Math.min(L, l - m * S)), _ = Math.max(P, Math.min(L, v + m * S))), + A && (d = Math.max(q, Math.min(R, p - x * A)), g = Math.max(q, Math.min(R, y + x * A))) + } + _ < h && (S *= -1, t = l, l = v, v = t, t = h, h = _, _ = t, N in Cm && Y.attr("cursor", Em[N = Cm[N]])), + g < d && (A *= -1, t = p, p = y, y = t, t = d, d = g, g = t, N in zm && Y.attr("cursor", Em[N = zm[N]])), + E.selection && (z = E.selection), + w && (h = z[0][0], _ = z[1][0]), + M && (d = z[0][1], g = z[1][1]), + z[0][0] === h && z[0][1] === d && z[1][0] === _ && z[1][1] === g || (E.selection = [ + [ + h, d + ], + [_, g] + ], r.call(T), F.brush()) + } + function u() { + if (sa(), t.event.touches) { + if (t.event.touches.length) + return; + c && clearTimeout(c), + c = setTimeout(function () { + c = null + }, 500), + I.on("touchmove.brush touchend.brush touchcancel.brush", null) + } else + mu(t.event.view, b), + B.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null); + I.attr("pointer-events", "all"), + Y.attr("cursor", Em.overlay), + E.selection && (z = E.selection), + da(z) && (E.selection = null, r.call(T)), + F.end() + } + function a() { + switch (t.event.keyCode) { + case 16: + U = S && A; + break; + case 18: + k === Tm && (S && (v = _ - m * S, l = h + m * S), A && (y = g - x * A, p = d + x * A), k = Nm, o()); + break; + case 32: + k !== Tm && k !== Nm || (S < 0 + ? v = _ - m + : S > 0 && (l = h - m), A < 0 + ? y = g - x + : A > 0 && (p = d - x), k = Mm, Y.attr("cursor", Em.selection), o()); + break; + default: + return + } + bm() + } + function s() { + switch (t.event.keyCode) { + case 16: + U && (w = M = U = !1, o()); + break; + case 18: + k === Nm && (S < 0 + ? v = _ + : S > 0 && (l = h), A < 0 + ? y = g + : A > 0 && (p = d), k = Tm, o()); + break; + case 32: + k === Mm && (t.event.altKey + ? (S && (v = _ - m * S, l = h + m * S), A && (y = g - x * A, p = d + x * A), k = Nm) + : (S < 0 + ? v = _ + : S > 0 && (l = h), A < 0 + ? y = g + : A > 0 && (p = d), k = Tm), Y.attr("cursor", Em[N]), o()); + break; + default: + return + } + bm() + } + if (t.event.touches) { + if (t.event.changedTouches.length < t.event.touches.length) + return bm() + } else if (c) + return; + if (f.apply(this, arguments)) { + var l, + h, + p, + d, + v, + _, + y, + g, + m, + x, + b, + w, + M, + T = this, + N = t.event.target.__data__.type, + k = "selection" === (t.event.metaKey + ? N = "overlay" + : N) + ? wm + : t.event.altKey + ? Nm + : Tm, + S = n === Sm + ? null + : Pm[N], + A = n === km + ? null + : qm[N], + E = pa(T), + C = E.extent, + z = E.selection, + P = C[0][0], + q = C[0][1], + L = C[1][0], + R = C[1][1], + U = S && A && t.event.shiftKey, + D = U_(T), + O = D, + F = i(T, arguments).beforestart(); + "overlay" === N + ? E.selection = z = [ + [ + l = n === Sm + ? P + : D[0], + p = n === km + ? q + : D[1] + ], + [ + v = n === Sm + ? L + : l, + y = n === km + ? R + : p + ] + ] + : (l = z[0][0], p = z[0][1], v = z[1][0], y = z[1][1]), + h = l, + d = p, + _ = v, + g = y; + var I = gy(T).attr("pointer-events", "none"), + Y = I + .selectAll(".overlay") + .attr("cursor", Em[N]); + if (t.event.touches) + I.on("touchmove.brush", e, !0).on("touchend.brush touchcancel.brush", u, !0); + else { + var B = gy(t.event.view) + .on("keydown.brush", a, !0) + .on("keyup.brush", s, !0) + .on("mousemove.brush", e, !0) + .on("mouseup.brush", u, !0); + nm(t.event.view) + } + sa(), + Py(T), + r.call(T), + F.start() + } + } + function a() { + var t = this.__brush || { + selection: null + }; + return t.extent = s.apply(this, arguments), + t.dim = n, + t + } + var c, + s = ha, + f = la, + l = Pn(e, "start", "brush", "end"), + h = 6; + return e.move = function (t, e) { + t.selection + ? t.on("start.brush", function () { + i(this, arguments) + .beforestart() + .start() + }) + .on("interrupt.brush end.brush", function () { + i(this, arguments).end() + }) + .tween("brush", function () { + function t(t) { + u.selection = 1 === t && da(s) + ? null + : f(t), + r.call(o), + a.brush() + } + var o = this, + u = o.__brush, + a = i(o, arguments), + c = u.selection, + s = n.input("function" == typeof e + ? e.apply(this, arguments) + : e, u.extent), + f = _p(c, s); + return c && s + ? t + : t(1) + }) + : t.each(function () { + var t = this, + o = arguments, + u = t.__brush, + a = n.input("function" == typeof e + ? e.apply(t, o) + : e, u.extent), + c = i(t, o).beforestart(); + Py(t), + u.selection = null == a || da(a) + ? null + : a, + r.call(t), + c + .start() + .brush() + .end() + }) + }, + o.prototype = { + beforestart: function () { + return 1 === ++this.active && (this.state.emitter = this, this.starting = !0), + this + }, + start: function () { + return this.starting && (this.starting = !1, this.emit("start")), + this + }, + brush: function () { + return this.emit("brush"), + this + }, + end: function () { + return 0 === --this.active && (delete this.state.emitter, this.emit("end")), + this + }, + emit: function (t) { + Xr(new xm(e, t, n.output(this.state.selection)), l.apply, l, [t, this.that, this.args]) + } + }, + e.extent = function (t) { + return arguments.length + ? (s = "function" == typeof t + ? t + : mm([ + [ + t[0][0], + t[0][1] + ], + [ + t[1][0], + t[1][1] + ] + ]), e) + : s + }, + e.filter = function (t) { + return arguments.length + ? (f = "function" == typeof t + ? t + : mm(!!t), e) + : f + }, + e.handleSize = function (t) { + return arguments.length + ? (h =+ t, e) + : h + }, + e.on = function () { + var t = l + .on + .apply(l, arguments); + return t === l + ? e + : t + }, + e + } + function ma(t) { + return function (n, e) { + return t(n.source.value + n.target.value, e.source.value + e.target.value) + } + } + function xa(t) { + return t.source + } + function ba(t) { + return t.target + } + function wa(t) { + return t.radius + } + function Ma(t) { + return t.startAngle + } + function Ta(t) { + return t.endAngle + } + function Na() { + this.reset() + } + function ka(t, n, e) { + var r = t.s = n + e, + i = r - n, + o = r - i; + t.t = n - o + (e - i) + } + function Sa(t) { + return t > 1 + ? 0 + : t < -1 + ? kx + : Math.acos(t) + } + function Aa(t) { + return t > 1 + ? Sx + : t < -1 + ? -Sx + : Math.asin(t) + } + function Ea(t) { + return (t = Ix(t / 2)) * t + } + function Ca() {} + function za(t, n) { + t && Xx.hasOwnProperty(t.type) && Xx[t.type](t, n) + } + function Pa(t, n, e) { + var r, + i = -1, + o = t.length - e; + for (n.lineStart(); ++i < o;) + r = t[i], + n.point(r[0], r[1], r[2]); + n.lineEnd() + } + function qa(t, n) { + var e = -1, + r = t.length; + for (n.polygonStart(); ++e < r;) + Pa(t[e], n, 1); + n.polygonEnd() + } + function La() { + Zx.point = Ua + } + function Ra() { + Da(Vm, Wm) + } + function Ua(t, n) { + Zx.point = Da, + Vm = t, + Wm = n, + t *= zx, + n *= zx, + $m = t, + Zm = Rx(n = n / 2 + Ax), + Gm = Ix(n) + } + function Da(t, n) { + t *= zx, + n *= zx, + n = n / 2 + Ax; + var e = t - $m, + r = e >= 0 + ? 1 + : -1, + i = r * e, + o = Rx(n), + u = Ix(n), + a = Gm * u, + c = Zm * o + a * Rx(i), + s = a * r * Ix(i); + Wx.add(Lx(s, c)), + $m = t, + Zm = o, + Gm = u + } + function Oa(t) { + return [ + Lx(t[1], t[0]), + Aa(t[2]) + ] + } + function Fa(t) { + var n = t[0], + e = t[1], + r = Rx(e); + return [ + r * Rx(n), + r * Ix(n), + Ix(e) + ] + } + function Ia(t, n) { + return t[0] * n[0] + t[1] * n[1] + t[2] * n[2] + } + function Ya(t, n) { + return [ + t[1] * n[2] - t[2] * n[1], + t[2] * n[0] - t[0] * n[2], + t[0] * n[1] - t[1] * n[0] + ] + } + function Ba(t, n) { + t[0] += n[0], + t[1] += n[1], + t[2] += n[2] + } + function ja(t, n) { + return [ + t[0] * n, + t[1] * n, + t[2] * n + ] + } + function Ha(t) { + var n = Bx(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]); + t[0] /= n, + t[1] /= n, + t[2] /= n + } + function Xa(t, n) { + ox.push(ux = [ + Jm = t, + Km = t + ]), + n < Qm && (Qm = n), + n > tx && (tx = n) + } + function Va(t, n) { + var e = Fa([ + t * zx, + n * zx + ]); + if (ix) { + var r = Ya(ix, e), + i = [ + r[1], -r[0], + 0 + ], + o = Ya(i, r); + Ha(o), + o = Oa(o); + var u, + a = t - nx, + c = a > 0 + ? 1 + : -1, + s = o[0] * Cx * c, + f = Px(a) > 180; + f ^ (c * nx < s && s < c * t) + ? (u = o[1] * Cx, u > tx && (tx = u)) + : (s = (s + 360) % 360 - 180, f ^ (c * nx < s && s < c * t) + ? (u = -o[1] * Cx, u < Qm && (Qm = u)) + : (n < Qm && (Qm = n), n > tx && (tx = n))), + f + ? t < nx + ? Qa(Jm, t) > Qa(Jm, Km) && (Km = t) + : Qa(t, Km) > Qa(Jm, Km) && (Jm = t) + : Km >= Jm + ? (t < Jm && (Jm = t), t > Km && (Km = t)) + : t > nx + ? Qa(Jm, t) > Qa(Jm, Km) && (Km = t) + : Qa(t, Km) > Qa(Jm, Km) && (Jm = t) + } else + Xa(t, n); + ix = e, + nx = t + } + function Wa() { + Qx.point = Va + } + function $a() { + ux[0] = Jm, + ux[1] = Km, + Qx.point = Xa, + ix = null + } + function Za(t, n) { + if (ix) { + var e = t - nx; + Jx.add(Px(e) > 180 + ? e + (e > 0 + ? 360 + : -360) + : e) + } else + ex = t, + rx = n; + Zx.point(t, n), + Va(t, n) + } + function Ga() { + Zx.lineStart() + } + function Ja() { + Za(ex, rx), + Zx.lineEnd(), + Px(Jx) > Tx && (Jm = -(Km = 180)), + ux[0] = Jm, + ux[1] = Km, + ix = null + } + function Qa(t, n) { + return (n -= t) < 0 + ? n + 360 + : n + } + function Ka(t, n) { + return t[0] - n[0] + } + function tc(t, n) { + return t[0] <= t[1] + ? t[0] <= n && n <= t[1] + : n < t[0] || t[1] < n + } + function nc(t, n) { + t *= zx, + n *= zx; + var e = Rx(n); + ec(e * Rx(t), e * Ix(t), Ix(n)) + } + function ec(t, n, e) { + ++ax, + sx += (t - sx) / ax, + fx += (n - fx) / ax, + lx += (e - lx) / ax + } + function rc() { + tb.point = ic + } + function ic(t, n) { + t *= zx, + n *= zx; + var e = Rx(n); + xx = e * Rx(t), + bx = e * Ix(t), + wx = Ix(n), + tb.point = oc, + ec(xx, bx, wx) + } + function oc(t, n) { + t *= zx, + n *= zx; + var e = Rx(n), + r = e * Rx(t), + i = e * Ix(t), + o = Ix(n), + u = Lx(Bx((u = bx * o - wx * i) * u + (u = wx * r - xx * o) * u + (u = xx * i - bx * r) * u), xx * r + bx * i + wx * o); + cx += u, + hx += u * (xx + (xx = r)), + px += u * (bx + (bx = i)), + dx += u * (wx + (wx = o)), + ec(xx, bx, wx) + } + function uc() { + tb.point = nc + } + function ac() { + tb.point = sc + } + function cc() { + fc(gx, mx), + tb.point = nc + } + function sc(t, n) { + gx = t, + mx = n, + t *= zx, + n *= zx, + tb.point = fc; + var e = Rx(n); + xx = e * Rx(t), + bx = e * Ix(t), + wx = Ix(n), + ec(xx, bx, wx) + } + function fc(t, n) { + t *= zx, + n *= zx; + var e = Rx(n), + r = e * Rx(t), + i = e * Ix(t), + o = Ix(n), + u = bx * o - wx * i, + a = wx * r - xx * o, + c = xx * i - bx * r, + s = Bx(u * u + a * a + c * c), + f = xx * r + bx * i + wx * o, + l = s && -Sa(f) / s, + h = Lx(s, f); + vx += l * u, + _x += l * a, + yx += l * c, + cx += h, + hx += h * (xx + (xx = r)), + px += h * (bx + (bx = i)), + dx += h * (wx + (wx = o)), + ec(xx, bx, wx) + } + function lc(t, n) { + return [ + t > kx + ? t - Ex + : t < -kx + ? t + Ex + : t, + n + ] + } + function hc(t, n, e) { + return (t %= Ex) + ? n || e + ? rb(dc(t), vc(n, e)) + : dc(t) + : n || e + ? vc(n, e) + : lc + } + function pc(t) { + return function (n, e) { + return n += t, + [ + n > kx + ? n - Ex + : n < -kx + ? n + Ex + : n, + e + ] + } + } + function dc(t) { + var n = pc(t); + return n.invert = pc(-t), + n + } + function vc(t, n) { + function e(t, n) { + var e = Rx(n), + a = Rx(t) * e, + c = Ix(t) * e, + s = Ix(n), + f = s * r + a * i; + return [ + Lx(c * o - f * u, a * r - s * i), + Aa(f * o + c * u) + ] + } + var r = Rx(t), + i = Ix(t), + o = Rx(n), + u = Ix(n); + return e.invert = function (t, n) { + var e = Rx(n), + a = Rx(t) * e, + c = Ix(t) * e, + s = Ix(n), + f = s * o - c * u; + return [ + Lx(c * o + s * u, a * r + f * i), + Aa(f * r - a * i) + ] + }, + e + } + function _c(t, n, e, r, i, o) { + if (e) { + var u = Rx(n), + a = Ix(n), + c = r * e; + null == i + ? (i = n + r * Ex, o = n - c / 2) + : (i = yc(u, i), o = yc(u, o), (r > 0 + ? i < o + : i > o) && (i += r * Ex)); + for (var s, f = i; r > 0 + ? f > o + : f < o; f -= c) + s = Oa([ + u, -a * Rx(f), -a * Ix(f) + ]), + t.point(s[0], s[1]) + } + } + function yc(t, n) { + n = Fa(n), + n[0] -= t, + Ha(n); + var e = Sa(-n[1]); + return ((-n[2] < 0 + ? -e + : e) + Ex - Tx) % Ex + } + function gc(t, n, e, r) { + this.x = t, + this.z = n, + this.o = e, + this.e = r, + this.v = !1, + this.n = this.p = null + } + function mc(t) { + if (n = t.length) { + for (var n, e, r = 0, i = t[0]; ++r < n;) + i.n = e = t[r], + e.p = i, + i = e; + i.n = e = t[0], + e.p = i + } + } + function xc(t, n, e, r) { + function i(i, o) { + return t <= i && i <= e && n <= o && o <= r + } + function o(i, o, a, s) { + var f = 0, + l = 0; + if (null == i || (f = u(i, a)) !== (l = u(o, a)) || c(i, o) < 0 ^ a > 0) { + do + s.point(0 === f || 3 === f + ? t + : e, f > 1 + ? r + : n); + while ((f = (f + a + 4) % 4) !== l) + } else + s.point(o[0], o[1]) + } + function u(r, i) { + return Px(r[0] - t) < Tx + ? i > 0 + ? 0 + : 3 + : Px(r[0] - e) < Tx + ? i > 0 + ? 2 + : 1 + : Px(r[1] - n) < Tx + ? i > 0 + ? 1 + : 0 + : i > 0 + ? 3 + : 2 + } + function a(t, n) { + return c(t.x, n.x) + } + function c(t, n) { + var e = u(t, 1), + r = u(n, 1); + return e !== r + ? e - r + : 0 === e + ? n[1] - t[1] + : 1 === e + ? t[0] - n[0] + : 2 === e + ? t[1] - n[1] + : n[0] - t[0] + } + return function (u) { + function c(t, n) { + i(t, n) && k.point(t, n) + } + function s() { + for (var n = 0, e = 0, i = _.length; e < i; ++e) + for (var o, u, a = _[e], c = 1, s = a.length, f = a[0], l = f[0], h = f[1]; c < s; ++c) + o = l, + u = h, + f = a[c], + l = f[0], + h = f[1], + u <= r + ? h > r && (l - o) * (r - u) > (h - u) * (t - o) && ++n + : h <= r && (l - o) * (r - u) < (h - u) * (t - o) && --n; + return n + } + function f() { + k = S, + v = [], + _ = [], + N = !0 + } + function l() { + var t = s(), + n = N && t, + e = (v = Js(v)).length; + (n || e) && (u.polygonStart(), n && (u.lineStart(), o(null, null, 1, u), u.lineEnd()), e && xb(v, a, t, o, u), u.polygonEnd()), + k = u, + v = _ = y = null + } + function h() { + A.point = d, + _ && _.push(y = []), + T = !0, + M = !1, + b = w = NaN + } + function p() { + v && (d(g, m), x && M && S.rejoin(), v.push(S.result())), + A.point = c, + M && k.lineEnd() + } + function d(o, u) { + var a = i(o, u); + if (_ && y.push([o, u]), T) + g = o, + m = u, + x = a, + T = !1, + a && (k.lineStart(), k.point(o, u)); + else if (a && M) + k.point(o, u); + else { + var c = [ + b = Math.max(wb, Math.min(bb, b)), + w = Math.max(wb, Math.min(bb, w)) + ], + s = [ + o = Math.max(wb, Math.min(bb, o)), + u = Math.max(wb, Math.min(bb, u)) + ]; + gb(c, s, t, n, e, r) + ? (M || (k.lineStart(), k.point(c[0], c[1])), k.point(s[0], s[1]), a || k.lineEnd(), N = !1) + : a && (k.lineStart(), k.point(o, u), N = !1) + } + b = o, + w = u, + M = a + } + var v, + _, + y, + g, + m, + x, + b, + w, + M, + T, + N, + k = u, + S = yb(), + A = { + point: c, + lineStart: h, + lineEnd: p, + polygonStart: f, + polygonEnd: l + }; + return A + } + } + function bc() { + Nb.point = Mc, + Nb.lineEnd = wc + } + function wc() { + Nb.point = Nb.lineEnd = Ca + } + function Mc(t, n) { + t *= zx, + n *= zx, + ib = t, + ob = Ix(n), + ub = Rx(n), + Nb.point = Tc + } + function Tc(t, n) { + t *= zx, + n *= zx; + var e = Ix(n), + r = Rx(n), + i = Px(t - ib), + o = Rx(i), + u = Ix(i), + a = r * u, + c = ub * e - ob * r * o, + s = ob * e + ub * r * o; + Tb.add(Lx(Bx(a * a + c * c), s)), + ib = t, + ob = e, + ub = r + } + function Nc(t, n, e) { + var r = Os(t, n - Tx, e).concat(n); + return function (t) { + return r.map(function (n) { + return [t, n] + }) + } + } + function kc(t, n, e) { + var r = Os(t, n - Tx, e).concat(n); + return function (t) { + return r.map(function (n) { + return [n, t] + }) + } + } + function Sc() { + function t() { + return {type: "MultiLineString", coordinates: n()} + } + function n() { + return Os(Ux(o / _) * _, i, _) + .map(h) + .concat(Os(Ux(s / y) * y, c, y).map(p)) + .concat(Os(Ux(r / d) * d, e, d).filter(function (t) { + return Px(t % _) > Tx + }).map(f)) + .concat(Os(Ux(a / v) * v, u, v).filter(function (t) { + return Px(t % y) > Tx + }).map(l)) + } + var e, + r, + i, + o, + u, + a, + c, + s, + f, + l, + h, + p, + d = 10, + v = d, + _ = 90, + y = 360, + g = 2.5; + return t.lines = function () { + return n().map(function (t) { + return {type: "LineString", coordinates: t} + }) + }, + t.outline = function () { + return { + type: "Polygon", + coordinates: [h(o).concat(p(c).slice(1), h(i).reverse().slice(1), p(s).reverse().slice(1))] + } + }, + t.extent = function (n) { + return arguments.length + ? t + .extentMajor(n) + .extentMinor(n) + : t.extentMinor() + }, + t.extentMajor = function (n) { + return arguments.length + ? (o =+ n[0][0], i =+ n[1][0], s =+ n[0][1], c =+ n[1][1], o > i && (n = o, o = i, i = n), s > c && (n = s, s = c, c = n), t.precision(g)) + : [ + [ + o, s + ], + [i, c] + ] + }, + t.extentMinor = function (n) { + return arguments.length + ? (r =+ n[0][0], e =+ n[1][0], a =+ n[0][1], u =+ n[1][1], r > e && (n = r, r = e, e = n), a > u && (n = a, a = u, u = n), t.precision(g)) + : [ + [ + r, a + ], + [e, u] + ] + }, + t.step = function (n) { + return arguments.length + ? t + .stepMajor(n) + .stepMinor(n) + : t.stepMinor() + }, + t.stepMajor = function (n) { + return arguments.length + ? (_ =+ n[0], y =+ n[1], t) + : [_, y] + }, + t.stepMinor = function (n) { + return arguments.length + ? (d =+ n[0], v =+ n[1], t) + : [d, v] + }, + t.precision = function (n) { + return arguments.length + ? (g =+ n, f = Nc(a, u, 90), l = kc(r, e, g), h = Nc(s, c, 90), p = kc(o, i, g), t) + : g + }, + t.extentMajor([ + [ + -180, -90 + Tx + ], + [ + 180, 90 - Tx + ] + ]).extentMinor([ + [ + -180, -80 - Tx + ], + [ + 180, 80 + Tx + ] + ]) + } + function Ac() { + return Sc()() + } + function Ec() { + Lb.point = Cc + } + function Cc(t, n) { + Lb.point = zc, + ab = sb = t, + cb = fb = n + } + function zc(t, n) { + qb.add(fb * t - sb * n), + sb = t, + fb = n + } + function Pc() { + zc(ab, cb) + } + function qc(t, n) { + t < Rb && (Rb = t), + t > Db && (Db = t), + n < Ub && (Ub = n), + n > Ob && (Ob = n) + } + function Lc(t, n) { + Ib += t, + Yb += n, + ++Bb + } + function Rc() { + Zb.point = Uc + } + function Uc(t, n) { + Zb.point = Dc, + Lc(pb = t, db = n) + } + function Dc(t, n) { + var e = t - pb, + r = n - db, + i = Bx(e * e + r * r); + jb += i * (pb + t) / 2, + Hb += i * (db + n) / 2, + Xb += i, + Lc(pb = t, db = n) + } + function Oc() { + Zb.point = Lc + } + function Fc() { + Zb.point = Yc + } + function Ic() { + Bc(lb, hb) + } + function Yc(t, n) { + Zb.point = Bc, + Lc(lb = pb = t, hb = db = n) + } + function Bc(t, n) { + var e = t - pb, + r = n - db, + i = Bx(e * e + r * r); + jb += i * (pb + t) / 2, + Hb += i * (db + n) / 2, + Xb += i, + i = db * t - pb * n, + Vb += i * (pb + t), + Wb += i * (db + n), + $b += 3 * i, + Lc(pb = t, db = n) + } + function jc(t) { + this._context = t + } + function Hc() { + this._string = [] + } + function Xc(t) { + return "m0," + t + "a" + t + "," + t + " 0 1,1 0," + -2 * t + "a" + t + "," + t + " 0 1,1 0," + 2 * t + "z" + } + function Vc(t) { + return t.length > 1 + } + function Wc(t, n) { + return ((t = t.x)[0] < 0 + ? t[1] - Sx - Tx + : Sx - t[1]) - ((n = n.x)[0] < 0 + ? n[1] - Sx - Tx + : Sx - n[1]) + } + function $c(t) { + var n, + e = NaN, + r = NaN, + i = NaN; + return { + lineStart: function () { + t.lineStart(), + n = 1 + }, + point: function (o, u) { + var a = o > 0 + ? kx + : -kx, + c = Px(o - e); + Px(c - kx) < Tx + ? (t.point(e, r = (r + u) / 2 > 0 + ? Sx + : -Sx), t.point(i, r), t.lineEnd(), t.lineStart(), t.point(a, r), t.point(o, r), n = 0) + : i !== a && c >= kx && (Px(e - i) < Tx && (e -= i * Tx), Px(o - a) < Tx && (o -= a * Tx), r = Zc(e, r, o, u), t.point(i, r), t.lineEnd(), t.lineStart(), t.point(a, r), n = 0), + t.point(e = o, r = u), + i = a + }, + lineEnd: function () { + t.lineEnd(), + e = r = NaN + }, + clean: function () { + return 2 - n + } + } + } + function Zc(t, n, e, r) { + var i, + o, + u = Ix(t - e); + return Px(u) > Tx + ? qx((Ix(n) * (o = Rx(r)) * Ix(e) - Ix(r) * (i = Rx(n)) * Ix(t)) / (i * o * u)) + : (n + r) / 2 + } + function Gc(t, n, e, r) { + var i; + if (null == t) + i = e * Sx, + r.point(-kx, i), + r.point(0, i), + r.point(kx, i), + r.point(kx, 0), + r.point(kx, -i), + r.point(0, -i), + r.point(-kx, -i), + r.point(-kx, 0), + r.point(-kx, i); + else if (Px(t[0] - n[0]) > Tx) { + var o = t[0] < n[0] + ? kx + : -kx; + i = e * o / 2, + r.point(-o, i), + r.point(0, i), + r.point(o, i) + } else + r.point(n[0], n[1]) + } + function Jc(t) { + return function (n) { + var e = new Qc; + for (var r in t) + e[r] = t[r]; + return e.stream = n, + e + } + } + function Qc() {} + function Kc(t, n, e) { + var r = n[1][0] - n[0][0], + i = n[1][1] - n[0][1], + o = t.clipExtent && t.clipExtent(); + t + .scale(150) + .translate([0, 0]), + null != o && t.clipExtent(null), + Vx(e, t.stream(Fb)); + var u = Fb.result(), + a = Math.min(r / (u[1][0] - u[0][0]), i / (u[1][1] - u[0][1])), + c =+ n[0][0] + (r - a * (u[1][0] + u[0][0])) / 2, + s =+ n[0][1] + (i - a * (u[1][1] + u[0][1])) / 2; + return null != o && t.clipExtent(o), + t + .scale(150 * a) + .translate([c, s]) + } + function ts(t, n, e) { + return Kc(t, [ + [ + 0, 0 + ], + n + ], e) + } + function ns(t) { + return Jc({ + point: function (n, e) { + n = t(n, e), + this + .stream + .point(n[0], n[1]) + } + }) + } + function es(t, n) { + function e(r, i, o, u, a, c, s, f, l, h, p, d, v, _) { + var y = s - r, + g = f - i, + m = y * y + g * g; + if (m > 4 * n && v--) { + var x = u + h, + b = a + p, + w = c + d, + M = Bx(x * x + b * b + w * w), + T = Aa(w /= M), + N = Px(Px(w) - 1) < Tx || Px(o - l) < Tx + ? (o + l) / 2 + : Lx(b, x), + k = t(N, T), + S = k[0], + A = k[1], + E = S - r, + C = A - i, + z = g * E - y * C; + (z * z / m > n || Px((y * E + g * C) / m - .5) > .3 || u * h + a * p + c * d < iw) && (e(r, i, o, u, a, c, S, A, N, x /= M, b /= M, w, v, _), _.point(S, A), e(S, A, N, x, b, w, s, f, l, h, p, d, v, _)) + } + } + return function (n) { + function r(e, r) { + e = t(e, r), + n.point(e[0], e[1]) + } + function i() { + y = NaN, + w.point = o, + n.lineStart() + } + function o(r, i) { + var o = Fa([r, i]), + u = t(r, i); + e(y, g, _, m, x, b, y = u[0], g = u[1], _ = r, m = o[0], x = o[1], b = o[2], rw, n), + n.point(y, g) + } + function u() { + w.point = r, + n.lineEnd() + } + function a() { + i(), + w.point = c, + w.lineEnd = s + } + function c(t, n) { + o(f = t, n), + l = y, + h = g, + p = m, + d = x, + v = b, + w.point = o + } + function s() { + e(y, g, _, m, x, b, l, h, f, p, d, v, rw, n), + w.lineEnd = u, + u() + } + var f, + l, + h, + p, + d, + v, + _, + y, + g, + m, + x, + b, + w = { + point: r, + lineStart: i, + lineEnd: u, + polygonStart: function () { + n.polygonStart(), + w.lineStart = a + }, + polygonEnd: function () { + n.polygonEnd(), + w.lineStart = i + } + }; + return w + } + } + function rs(t) { + return is(function () { + return t + })() + } + function is(t) { + function n(t) { + return t = f(t[0] * zx, t[1] * zx), + [ + t[0] * _ + a, + c - t[1] * _ + ] + } + function e(t) { + return t = f.invert((t[0] - a) / _, (c - t[1]) / _), + t && [ + t[0] * Cx, + t[1] * Cx + ] + } + function r(t, n) { + return t = u(t, n), + [ + t[0] * _ + a, + c - t[1] * _ + ] + } + function i() { + f = rb(s = hc(b, w, M), u); + var t = u(m, x); + return a = y - t[0] * _, + c = g + t[1] * _, + o() + } + function o() { + return d = v = null, + n + } + var u, + a, + c, + s, + f, + l, + h, + p, + d, + v, + _ = 150, + y = 480, + g = 250, + m = 0, + x = 0, + b = 0, + w = 0, + M = 0, + T = null, + N = tw, + k = null, + S = zb, + A = .5, + E = ow(r, A); + return n.stream = function (t) { + return d && v === t + ? d + : d = uw(N(s, E(S(v = t)))) + }, + n.clipAngle = function (t) { + return arguments.length + ? (N =+ t + ? nw(T = t * zx, 6 * zx) + : (T = null, tw), o()) + : T * Cx + }, + n.clipExtent = function (t) { + return arguments.length + ? (S = null == t + ? (k = l = h = p = null, zb) + : xc(k =+ t[0][0], l =+ t[0][1], h =+ t[1][0], p =+ t[1][1]), o()) + : null == k + ? null + : [ + [ + k, l + ], + [h, p] + ] + }, + n.scale = function (t) { + return arguments.length + ? (_ =+ t, i()) + : _ + }, + n.translate = function (t) { + return arguments.length + ? (y =+ t[0], g =+ t[1], i()) + : [y, g] + }, + n.center = function (t) { + return arguments.length + ? (m = t[0] % 360 * zx, x = t[1] % 360 * zx, i()) + : [ + m * Cx, + x * Cx + ] + }, + n.rotate = function (t) { + return arguments.length + ? (b = t[0] % 360 * zx, w = t[1] % 360 * zx, M = t.length > 2 + ? t[2] % 360 * zx + : 0, i()) + : [ + b * Cx, + w * Cx, + M * Cx + ] + }, + n.precision = function (t) { + return arguments.length + ? (E = ow(r, A = t * t), o()) + : Bx(A) + }, + n.fitExtent = function (t, e) { + return Kc(n, t, e) + }, + n.fitSize = function (t, e) { + return ts(n, t, e) + }, + function () { + return u = t.apply(this, arguments), + n.invert = u.invert && e, + i() + } + } + function os(t) { + var n = 0, + e = kx / 3, + r = is(t), + i = r(n, e); + return i.parallels = function (t) { + return arguments.length + ? r(n = t[0] * zx, e = t[1] * zx) + : [ + n * Cx, + e * Cx + ] + }, + i + } + function us(t) { + function n(t, n) { + return [ + t * e, + Ix(n) / e + ] + } + var e = Rx(t); + return n.invert = function (t, n) { + return [ + t / e, + Aa(n * e) + ] + }, + n + } + function as(t, n) { + function e(t, n) { + var e = Bx(o - 2 * i * Ix(n)) / i; + return [ + e * Ix(t *= i), + u - e * Rx(t) + ] + } + var r = Ix(t), + i = (r + Ix(n)) / 2; + if (Px(i) < Tx) + return us(t); + var o = 1 + r * (2 * i - r), + u = Bx(o) / i; + return e.invert = function (t, n) { + var e = u - n; + return [ + Lx(t, Px(e)) / i * Yx(e), + Aa((o - (t * t + e * e) * i * i) / (2 * i)) + ] + }, + e + } + function cs(t) { + var n = t.length; + return { + point: function (e, r) { + for (var i = -1; ++i < n;) + t[i].point(e, r) + }, + sphere: function () { + for (var e = -1; ++e < n;) + t[e].sphere() + }, + lineStart: function () { + for (var e = -1; ++e < n;) + t[e].lineStart() + }, + lineEnd: function () { + for (var e = -1; ++e < n;) + t[e].lineEnd() + }, + polygonStart: function () { + for (var e = -1; ++e < n;) + t[e].polygonStart() + }, + polygonEnd: function () { + for (var e = -1; ++e < n;) + t[e].polygonEnd() + } + } + } + function ss(t) { + return function (n, e) { + var r = Rx(n), + i = Rx(e), + o = t(r * i); + return [ + o * i * Ix(n), + o * Ix(e) + ] + } + } + function fs(t) { + return function (n, e) { + var r = Bx(n * n + e * e), + i = t(r), + o = Ix(i), + u = Rx(i); + return [ + Lx(n * o, r * u), + Aa(r && e * o / r) + ] + } + } + function ls(t, n) { + return [ + t, + Ox(jx((Sx + n) / 2)) + ] + } + function hs(t) { + var n, + e = rs(t), + r = e.scale, + i = e.translate, + o = e.clipExtent; + return e.scale = function (t) { + return arguments.length + ? (r(t), n && e.clipExtent(null), e) + : r() + }, + e.translate = function (t) { + return arguments.length + ? (i(t), n && e.clipExtent(null), e) + : i() + }, + e.clipExtent = function (t) { + if (!arguments.length) + return n + ? null + : o(); + if (n = null == t) { + var u = kx * r(), + a = i(); + t = [ + [ + a[0] - u, + a[1] - u + ], + [ + a[0] + u, + a[1] + u + ] + ] + } + return o(t), + e + }, + e.clipExtent(null) + } + function ps(t) { + return jx((Sx + t) / 2) + } + function ds(t, n) { + function e(t, n) { + o > 0 + ? n < -Sx + Tx && (n = -Sx + Tx) + : n > Sx - Tx && (n = Sx - Tx); + var e = o / Fx(ps(n), i); + return [ + e * Ix(i * t), + o - e * Rx(i * t) + ] + } + var r = Rx(t), + i = t === n + ? Ix(t) + : Ox(r / Rx(n)) / Ox(ps(n) / ps(t)), + o = r * Fx(ps(t), i) / i; + return i + ? (e.invert = function (t, n) { + var e = o - n, + r = Yx(i) * Bx(t * t + e * e); + return [ + Lx(t, Px(e)) / i * Yx(e), + 2 * qx(Fx(o / r, 1 / i)) - Sx + ] + }, + e) + : ls + } + function vs(t, n) { + return [t, n] + } + function _s(t, n) { + function e(t, n) { + var e = o - n, + r = i * t; + return [ + e * Ix(r), + o - e * Rx(r) + ] + } + var r = Rx(t), + i = t === n + ? Ix(t) + : (r - Rx(n)) / (n - t), + o = r / i + t; + return Px(i) < Tx + ? vs + : (e.invert = function (t, n) { + var e = o - n; + return [ + Lx(t, Px(e)) / i * Yx(e), + o - Yx(i) * Bx(t * t + e * e) + ] + }, + e) + } + function ys(t, n) { + var e = Rx(n), + r = Rx(t) * e; + return [ + e * Ix(t) / r, + Ix(n) / r + ] + } + function gs(t, n, e) { + return 1 === t && 0 === n && 0 === e + ? zb + : Jc({ + point: function (r, i) { + this + .stream + .point(r * t + n, i * t + e) + } + }) + } + function ms(t, n) { + return [ + Rx(n) * Ix(t), + Ix(n) + ] + } + function xs(t, n) { + var e = Rx(n), + r = 1 + Rx(t) * e; + return [ + e * Ix(t) / r, + Ix(n) / r + ] + } + function bs(t, n) { + return [ + Ox(jx((Sx + n) / 2)), -t + ] + } + var ws = "4.3.0", + Ms = function (t, n) { + return t < n + ? -1 + : t > n + ? 1 + : t >= n + ? 0 + : NaN + }, + Ts = function (t) { + return 1 === t.length && (t = n(t)), { + left: function (n, e, r, i) { + for (null == r && (r = 0), null == i && (i = n.length); r < i;) { + var o = r + i >>> 1; + t(n[o], e) < 0 + ? r = o + 1 + : i = o + } + return r + }, + right: function (n, e, r, i) { + for (null == r && (r = 0), null == i && (i = n.length); r < i;) { + var o = r + i >>> 1; + t(n[o], e) > 0 + ? i = o + : r = o + 1 + } + return r + } + } + }, + Ns = Ts(Ms), + ks = Ns.right, + Ss = Ns.left, + As = function (t, n) { + return n < t + ? -1 + : n > t + ? 1 + : n >= t + ? 0 + : NaN + }, + Es = function (t) { + return null === t + ? NaN :+ t + }, + Cs = function (t, n) { + var e, + r, + i = t.length, + o = 0, + u = 0, + a = -1, + c = 0; + if (null == n) + for (; ++a < i;) + isNaN(e = Es(t[a])) || (r = e - o, o += r / ++c, u += r * (e - o)); + else + for (; ++a < i;) + isNaN(e = Es(n(t[a], a, t))) || (r = e - o, o += r / ++c, u += r * (e - o)); + if (c > 1) + return u / (c - 1) + }, + zs = function (t, n) { + var e = Cs(t, n); + return e + ? Math.sqrt(e) + : e + }, + Ps = function (t, n) { + var e, + r, + i, + o = -1, + u = t.length; + if (null == n) { + for (; ++o < u;) + if (null != (r = t[o]) && r >= r) { + e = i = r; + break + } + for (; ++o < u;) + null != (r = t[o]) && (e > r && (e = r), i < r && (i = r)) + } else { + for (; ++o < u;) + if (null != (r = n(t[o], o, t)) && r >= r) { + e = i = r; + break + } + for (; ++o < u;) + null != (r = n(t[o], o, t)) && (e > r && (e = r), i < r && (i = r)) + } + return [e, i] + }, + qs = Array.prototype, + Ls = qs.slice, + Rs = qs.map, + Us = function (t) { + return function () { + return t + } + }, + Ds = function (t) { + return t + }, + Os = function (t, n, e) { + t =+ t, + n =+ n, + e = (i = arguments.length) < 2 + ? (n = t, t = 0, 1) + : i < 3 + ? 1 :+ e; + for (var r = -1, i = 0 | Math.max(0, Math.ceil((n - t) / e)), o = new Array(i); ++r < i;) + o[r] = t + r * e; + return o + }, + Fs = Math.sqrt(50), + Is = Math.sqrt(10), + Ys = Math.sqrt(2), + Bs = function (t, n, r) { + var i = e(t, n, r); + return Os(Math.ceil(t / i) * i, Math.floor(n / i) * i + i / 2, i) + }, + js = function (t) { + return Math.ceil(Math.log(t.length) / Math.LN2) + 1 + }, + Hs = function () { + function t(t) { + var i, + o, + u = t.length, + a = new Array(u); + for (i = 0; i < u; ++i) + a[i] = n(t[i], i, t); + var c = e(a), + s = c[0], + f = c[1], + l = r(a, s, f); + Array.isArray(l) || (l = Bs(s, f, l)); + for (var h = l.length; l[0] <= s;) + l.shift(), + --h; + for (; l[h - 1] >= f;) + l.pop(), + --h; + var p, + d = new Array(h + 1); + for (i = 0; i <= h; ++i) + p = d[i] = [], + p.x0 = i > 0 + ? l[i - 1] + : s, + p.x1 = i < h + ? l[i] + : f; + for (i = 0; i < u; ++i) + o = a[i], + s <= o && o <= f && d[ks(l, o, 0, h)].push(t[i]); + return d + } + var n = Ds, + e = Ps, + r = js; + return t.value = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : Us(e), t) + : n + }, + t.domain = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : Us([n[0], n[1]]), t) + : e + }, + t.thresholds = function (n) { + return arguments.length + ? (r = "function" == typeof n + ? n + : Us(Array.isArray(n) + ? Ls.call(n) + : n), t) + : r + }, + t + }, + Xs = function (t, n, e) { + if (null == e && (e = Es), r = t.length) { + if ((n =+ n) <= 0 || r < 2) + return + e(t[0], 0, t); + if (n >= 1) + return + e(t[r - 1], r - 1, t); + var r, + i = (r - 1) * n, + o = Math.floor(i), + u =+ e(t[o], o, t), + a =+ e(t[o + 1], o + 1, t); + return u + (a - u) * (i - o) + } + }, + Vs = function (t, n, e) { + return t = Rs + .call(t, Es) + .sort(Ms), + Math.ceil((e - n) / (2 * (Xs(t, .75) - Xs(t, .25)) * Math.pow(t.length, -1 / 3))) + }, + Ws = function (t, n, e) { + return Math.ceil((e - n) / (3.5 * zs(t) * Math.pow(t.length, -1 / 3))) + }, + $s = function (t, n) { + var e, + r, + i = -1, + o = t.length; + if (null == n) { + for (; ++i < o;) + if (null != (r = t[i]) && r >= r) { + e = r; + break + } + for (; ++i < o;) + null != (r = t[i]) && r > e && (e = r) + } else { + for (; ++i < o;) + if (null != (r = n(t[i], i, t)) && r >= r) { + e = r; + break + } + for (; ++i < o;) + null != (r = n(t[i], i, t)) && r > e && (e = r) + } + return e + }, + Zs = function (t, n) { + var e, + r = 0, + i = t.length, + o = -1, + u = i; + if (null == n) + for (; ++o < i;) + isNaN(e = Es(t[o])) + ? --u + : r += e; + else + for (; ++o < i;) + isNaN(e = Es(n(t[o], o, t))) + ? --u + : r += e; + if (u) + return r / u + }, + Gs = function (t, n) { + var e, + r = [], + i = t.length, + o = -1; + if (null == n) + for (; ++o < i;) + isNaN(e = Es(t[o])) || r.push(e); + else + for (; ++o < i;) + isNaN(e = Es(n(t[o], o, t))) || r.push(e); + return Xs(r.sort(Ms), .5) + }, + Js = function (t) { + for (var n, e, r, i = t.length, o = -1, u = 0; ++o < i;) + u += t[o].length; + for (e = new Array(u); --i >= 0;) + for (r = t[i], n = r.length; --n >= 0;) + e[--u] = r[n]; + return e + }, + Qs = function (t, n) { + var e, + r, + i = -1, + o = t.length; + if (null == n) { + for (; ++i < o;) + if (null != (r = t[i]) && r >= r) { + e = r; + break + } + for (; ++i < o;) + null != (r = t[i]) && e > r && (e = r) + } else { + for (; ++i < o;) + if (null != (r = n(t[i], i, t)) && r >= r) { + e = r; + break + } + for (; ++i < o;) + null != (r = n(t[i], i, t)) && e > r && (e = r) + } + return e + }, + Ks = function (t) { + for (var n = 0, e = t.length - 1, r = t[0], i = new Array(e < 0 + ? 0 + : e); n < e;) + i[n] = [ + r, r = t[++n] + ]; + return i + }, + tf = function (t, n) { + for (var e = n.length, r = new Array(e); e--;) + r[e] = t[n[e]]; + return r + }, + nf = function (t, n) { + if (e = t.length) { + var e, + r, + i = 0, + o = 0, + u = t[o]; + for (n || (n = Ms); ++i < e;) + (n(r = t[i], u) < 0 || 0 !== n(u, u)) && (u = r, o = i); + return 0 === n(u, u) + ? o + : void 0 + } + }, + ef = function (t, n, e) { + for (var r, i, o = (null == e + ? t.length + : e) - (n = null == n + ? 0 :+ n); o;) + i = Math.random() * o-- | 0, + r = t[o + n], + t[o + n] = t[i + n], + t[i + n] = r; + return t + }, + rf = function (t, n) { + var e, + r = 0, + i = t.length, + o = -1; + if (null == n) + for (; ++o < i;) + (e =+ t[o]) && (r += e); + else + for (; ++o < i;) + (e =+ n(t[o], o, t)) && (r += e); + return r + }, + of = function (t) { + if (!(o = t.length)) + return []; + for (var n = -1, e = Qs(t, r), i = new Array(e); ++n < e;) + for (var o, u = -1, a = i[n] = new Array(o); ++u < o;) + a[u] = t[u][n]; + return i + }, + uf = function () { + return of(arguments) + }, + af = "$"; + i.prototype = o.prototype = { + constructor: i, + has: function (t) { + return af + t in this + }, + get: function (t) { + return this[af + t] + }, + set: function (t, n) { + return this[af + t] = n, + this + }, + remove: function (t) { + var n = af + t; + return n in this && delete this[n] + }, + clear: function () { + for (var t in this) + t[0] === af && delete this[t] + }, + keys: function () { + var t = []; + for (var n in this) + n[0] === af && t.push(n.slice(1)); + return t + }, + values: function () { + var t = []; + for (var n in this) + n[0] === af && t.push(this[n]); + return t + }, + entries: function () { + var t = []; + for (var n in this) + n[0] === af && t.push({ + key: n.slice(1), + value: this[n] + }); + return t + }, + size: function () { + var t = 0; + for (var n in this) + n[0] === af && ++t; + return t + }, + empty: function () { + for (var t in this) + if (t[0] === af) + return !1; + return !0 + }, + each: function (t) { + for (var n in this) + n[0] === af && t(this[n], n.slice(1), this) + } + }; + var cf = function () { + function t(n, i, u, a) { + if (i >= f.length) + return null != r + ? r(n) + : null != e + ? n.sort(e) + : n; + for (var c, s, l, h = -1, p = n.length, d = f[i++], v = o(), _ = u(); ++h < p;) + (l = v.get(c = d(s = n[h]) + "")) + ? l.push(s) + : v.set(c, [s]); + return v.each(function (n, e) { + a(_, e, t(n, i, u, a)) + }), + _ + } + function n(t, e) { + if (++e > f.length) + return t; + var i, + o = l[e - 1]; + return null != r && e >= f.length + ? i = t.entries() + : (i = [], t.each(function (t, r) { + i.push({ + key: r, + values: n(t, e) + }) + })), + null != o + ? i.sort(function (t, n) { + return o(t.key, n.key) + }) + : i + } + var e, + r, + i, + f = [], + l = []; + return i = { + object: function (n) { + return t(n, 0, u, a) + }, + map: function (n) { + return t(n, 0, c, s) + }, + entries: function (e) { + return n(t(e, 0, c, s), 0) + }, + key: function (t) { + return f.push(t), + i + }, + sortKeys: function (t) { + return l[f.length - 1] = t, + i + }, + sortValues: function (t) { + return e = t, + i + }, + rollup: function (t) { + return r = t, + i + } + } + }, + sf = o.prototype; + f.prototype = l.prototype = { + constructor: f, + has: sf.has, + add: function (t) { + return t += "", + this[af + t] = t, + this + }, + remove: sf.remove, + clear: sf.clear, + values: sf.keys, + size: sf.size, + empty: sf.empty, + each: sf.each + }; + var ff = function (t) { + var n = []; + for (var e in t) + n.push(e); + return n + }, + lf = function (t) { + var n = []; + for (var e in t) + n.push(t[e]); + return n + }, + hf = function (t) { + var n = []; + for (var e in t) + n.push({key: e, value: t[e]}); + return n + }, + pf = function (t, n) { + return t = null == t + ? 0 :+ t, + n = null == n + ? 1 :+ n, + 1 === arguments.length + ? (n = t, t = 0) + : n -= t, + function () { + return Math.random() * n + t + } + }, + df = function (t, n) { + var e, + r; + return t = null == t + ? 0 :+ t, + n = null == n + ? 1 :+ n, + function () { + var i; + if (null != e) + i = e, + e = null; + else + do + e = 2 * Math.random() - 1, + i = 2 * Math.random() - 1, + r = e * e + i * i; + while (!r || r > 1) + ; + return t + n * i * Math.sqrt(-2 * Math.log(r) / r) + } + }, + vf = function () { + var t = df.apply(this, arguments); + return function () { + return Math.exp(t()) + } + }, + _f = function (t) { + return function () { + for (var n = 0, e = 0; e < t; ++e) + n += Math.random(); + return n + } + }, + yf = function (t) { + var n = _f(t); + return function () { + return n() / t + } + }, + gf = function (t) { + return function () { + return -Math.log(1 - Math.random()) / t + } + }, + mf = 3, + xf = function t(n) { + function e(t) { + return Math.pow(t, n) + } + return n =+ n, + e.exponent = t, + e + }(mf), + bf = function t(n) { + function e(t) { + return 1 - Math.pow(1 - t, n) + } + return n =+ n, + e.exponent = t, + e + }(mf), + wf = function t(n) { + function e(t) { + return ((t *= 2) <= 1 + ? Math.pow(t, n) + : 2 - Math.pow(2 - t, n)) / 2 + } + return n =+ n, + e.exponent = t, + e + }(mf), + Mf = Math.PI, + Tf = Mf / 2, + Nf = 4 / 11, + kf = 6 / 11, + Sf = 8 / 11, + Af = .75, + Ef = 9 / 11, + Cf = 10 / 11, + zf = .9375, + Pf = 21 / 22, + qf = 63 / 64, + Lf = 1 / Nf / Nf, + Rf = 1.70158, + Uf = function t(n) { + function e(t) { + return t * t * ((n + 1) * t - n) + } + return n =+ n, + e.overshoot = t, + e + }(Rf), + Df = function t(n) { + function e(t) { + return-- t * t * ((n + 1) * t + n) + 1 + } + return n =+ n, + e.overshoot = t, + e + }(Rf), + Of = function t(n) { + function e(t) { + return ((t *= 2) < 1 + ? t * t * ((n + 1) * t - n) + : (t -= 2) * t * ((n + 1) * t + n) + 2) / 2 + } + return n =+ n, + e.overshoot = t, + e + }(Rf), + Ff = 2 * Math.PI, + If = 1, + Yf = .3, + Bf = function t(n, e) { + function r(t) { + return n * Math.pow(2, 10 * --t) * Math.sin((i - t) / e) + } + var i = Math.asin(1 / (n = Math.max(1, n))) * (e /= Ff); + return r.amplitude = function (n) { + return t(n, e * Ff) + }, + r.period = function (e) { + return t(n, e) + }, + r + }(If, Yf), + jf = function t(n, e) { + function r(t) { + return 1 - n * Math.pow(2, -10 * (t =+ t)) * Math.sin((t + i) / e) + } + var i = Math.asin(1 / (n = Math.max(1, n))) * (e /= Ff); + return r.amplitude = function (n) { + return t(n, e * Ff) + }, + r.period = function (e) { + return t(n, e) + }, + r + }(If, Yf), + Hf = function t(n, e) { + function r(t) { + return ((t = 2 * t - 1) < 0 + ? n * Math.pow(2, 10 * t) * Math.sin((i - t) / e) + : 2 - n * Math.pow(2, -10 * t) * Math.sin((i + t) / e)) / 2 + } + var i = Math.asin(1 / (n = Math.max(1, n))) * (e /= Ff); + return r.amplitude = function (n) { + return t(n, e * Ff) + }, + r.period = function (e) { + return t(n, e) + }, + r + }(If, Yf), + Xf = function (t) { + for (var n, e = -1, r = t.length, i = t[r - 1], o = 0; ++e < r;) + n = i, + i = t[e], + o += n[1] * i[0] - n[0] * i[1]; + return o / 2 + }, + Vf = function (t) { + for (var n, e, r = -1, i = t.length, o = 0, u = 0, a = t[i - 1], c = 0; ++r < i;) + n = a, + a = t[r], + c += e = n[0] * a[1] - a[0] * n[1], + o += (n[0] + a[0]) * e, + u += (n[1] + a[1]) * e; + return c *= 3, + [ + o / c, + u / c + ] + }, + Wf = function (t, n, e) { + return (n[0] - t[0]) * (e[1] - t[1]) - (n[1] - t[1]) * (e[0] - t[0]) + }, + $f = function (t) { + if ((e = t.length) < 3) + return null; + var n, + e, + r = new Array(e), + i = new Array(e); + for (n = 0; n < e; ++n) + r[n] = [ + t[n][0], + t[n][1], + n + ]; + for (r.sort(z), n = 0; n < e; ++n) + i[n] = [ + r[n][0], -r[n][1] + ]; + var o = P(r), + u = P(i), + a = u[0] === o[0], + c = u[u.length - 1] === o[o.length - 1], + s = []; + for (n = o.length - 1; n >= 0; --n) + s.push(t[r[o[n]][2]]); + for (n =+ a; n < u.length - c; ++n) + s.push(t[r[u[n]][2]]); + return s + }, + Zf = function (t, n) { + for (var e, r, i = t.length, o = t[i - 1], u = n[0], a = n[1], c = o[0], s = o[1], f = !1, l = 0; l < i; ++l) + o = t[l], + e = o[0], + r = o[1], + r > a != s > a && u < (c - e) * (a - r) / (s - r) + e && (f = !f), + c = e, + s = r; + return f + }, + Gf = function (t) { + for (var n, e, r = -1, i = t.length, o = t[i - 1], u = o[0], a = o[1], c = 0; ++r < i;) + n = u, + e = a, + o = t[r], + u = o[0], + a = o[1], + n -= u, + e -= a, + c += Math.sqrt(n * n + e * e); + return c + }, + Jf = Math.PI, + Qf = 2 * Jf, + Kf = 1e-6, + tl = Qf - Kf; + q.prototype = L.prototype = { + constructor: q, + moveTo: function (t, n) { + this + ._ + .push("M", this._x0 = this._x1 =+ t, ",", this._y0 = this._y1 =+ n) + }, + closePath: function () { + null !== this._x1 && (this._x1 = this._x0, this._y1 = this._y0, this._.push("Z")) + }, + lineTo: function (t, n) { + this + ._ + .push("L", this._x1 =+ t, ",", this._y1 =+ n) + }, + quadraticCurveTo: function (t, n, e, r) { + this + ._ + .push("Q", + t, ",", + n, ",", this._x1 =+ e, ",", this._y1 =+ r) + }, + bezierCurveTo: function (t, n, e, r, i, o) { + this + ._ + .push("C", + t, ",", + n, ",", + e, ",", + r, ",", this._x1 =+ i, ",", this._y1 =+ o) + }, + arcTo: function (t, n, e, r, i) { + t =+ t, + n =+ n, + e =+ e, + r =+ r, + i =+ i; + var o = this._x1, + u = this._y1, + a = e - t, + c = r - n, + s = o - t, + f = u - n, + l = s * s + f * f; + if (i < 0) + throw new Error("negative radius: " + i); + if (null === this._x1) + this._.push("M", this._x1 = t, ",", this._y1 = n); + else if (l > Kf) + if (Math.abs(f * a - c * s) > Kf && i) { + var h = e - o, + p = r - u, + d = a * a + c * c, + v = h * h + p * p, + _ = Math.sqrt(d), + y = Math.sqrt(l), + g = i * Math.tan((Jf - Math.acos((d + l - v) / (2 * _ * y))) / 2), + m = g / y, + x = g / _; + Math.abs(m - 1) > Kf && this + ._ + .push("L", t + m * s, ",", n + m * f), + this + ._ + .push("A", i, ",", i, ",0,0,", + (f * h > s * p), ",", this._x1 = t + x * a, ",", this._y1 = n + x * c) + } else + this + ._ + .push("L", this._x1 = t, ",", this._y1 = n); + else ; + } + , + arc: function (t, n, e, r, i, o) { + t =+ t, + n =+ n, + e =+ e; + var u = e * Math.cos(r), + a = e * Math.sin(r), + c = t + u, + s = n + a, + f = 1 ^ o, + l = o + ? r - i + : i - r; + if (e < 0) + throw new Error("negative radius: " + e); + null === this._x1 + ? this + ._ + .push("M", c, ",", s) + : (Math.abs(this._x1 - c) > Kf || Math.abs(this._y1 - s) > Kf) && this + ._ + .push("L", c, ",", s), + e && (l > tl + ? this._.push("A", e, ",", e, ",0,1,", f, ",", t - u, ",", n - a, "A", e, ",", e, ",0,1,", f, ",", this._x1 = c, ",", this._y1 = s) + : (l < 0 && (l = l % Qf + Qf), this._.push("A", e, ",", e, ",0,", + (l >= Jf), ",", f, ",", this._x1 = t + e * Math.cos(i), ",", this._y1 = n + e * Math.sin(i)))) + }, + rect: function (t, n, e, r) { + this + ._ + .push("M", this._x0 = this._x1 =+ t, ",", this._y0 = this._y1 =+ n, "h", + e, "v", + r, "h", -e, "Z") + }, + toString: function () { + return this + ._ + .join("") + } + }; + var nl = function (t) { + var n =+ this + ._x + .call(null, t), + e =+ this + ._y + .call(null, t); + return R(this.cover(n, e), n, e, t) + }, + el = function (t, n) { + if (isNaN(t =+ t) || isNaN(n =+ n)) + return this; + var e = this._x0, + r = this._y0, + i = this._x1, + o = this._y1; + if (isNaN(e)) + i = (e = Math.floor(t)) + 1, + o = (r = Math.floor(n)) + 1; + else { + if (!(e > t || t > i || r > n || n > o)) + return this; + var u, + a, + c = i - e, + s = this._root; + switch (a = (n < (r + o) / 2) << 1 | t < (e + i) / 2) { + case 0: + do + u = new Array(4), + u[a] = s, + s = u; + while (c *= 2, i = e + c, o = r + c, t > i || n > o); + break; + case 1: + do + u = new Array(4), + u[a] = s, + s = u; + while (c *= 2, e = i - c, o = r + c, e > t || n > o); + break; + case 2: + do + u = new Array(4), + u[a] = s, + s = u; + while (c *= 2, i = e + c, r = o - c, t > i || r > n); + break; + case 3: + do + u = new Array(4), + u[a] = s, + s = u; + while (c *= 2, e = i - c, r = o - c, e > t || r > n) + } + this._root && this._root.length && (this._root = s) + } + return this._x0 = e, + this._y0 = r, + this._x1 = i, + this._y1 = o, + this + }, + rl = function () { + var t = []; + return this.visit(function (n) { + if (!n.length) + do + t.push(n.data); + while (n = n.next) + } + ), + t + }, + il = function (t) { + return arguments.length + ? this.cover( + t[0][0], + t[0][1]).cover( + t[1][0], + t[1][1]) + : isNaN(this._x0) + ? void 0 + : [ + [ + this._x0, this._y0 + ], + [this._x1, this._y1] + ] + }, + ol = function (t, n, e, r, i) { + this.node = t, + this.x0 = n, + this.y0 = e, + this.x1 = r, + this.y1 = i + }, + ul = function (t, n, e) { + var r, + i, + o, + u, + a, + c, + s, + f = this._x0, + l = this._y0, + h = this._x1, + p = this._y1, + d = [], + v = this._root; + for (v && d.push(new ol(v, f, l, h, p)), null == e + ? e = 1 / 0 + : (f = t - e, l = n - e, h = t + e, p = n + e, e *= e); c = d.pop();) + if (!(!(v = c.node) || (i = c.x0) > h || (o = c.y0) > p || (u = c.x1) < f || (a = c.y1) < l)) + if (v.length) { + var _ = (i + u) / 2, + y = (o + a) / 2; + d.push(new ol(v[3], _, y, u, a), new ol(v[2], i, y, _, a), new ol(v[1], _, o, u, y), new ol(v[0], i, o, _, y)), + (s = (n >= y) << 1 | t >= _) && (c = d[d.length - 1], d[d.length - 1] = d[d.length - 1 - s], d[d.length - 1 - s] = c) + } + else { + var g = t - + this + ._x + .call(null, v.data), + m = n - + this + ._y + .call(null, v.data), + x = g * g + m * m; + if (x < e) { + var b = Math.sqrt(e = x); + f = t - b, + l = n - b, + h = t + b, + p = n + b, + r = v.data + } + } + return r + }, + al = function (t) { + if (isNaN(o =+ this._x.call(null, t)) || isNaN(u =+ this._y.call(null, t))) + return this; + var n, + e, + r, + i, + o, + u, + a, + c, + s, + f, + l, + h, + p = this._root, + d = this._x0, + v = this._y0, + _ = this._x1, + y = this._y1; + if (!p) + return this; + if (p.length) + for (;;) { + if ((s = o >= (a = (d + _) / 2)) + ? d = a + : _ = a, (f = u >= (c = (v + y) / 2)) + ? v = c + : y = c, n = p, !(p = p[l = f << 1 | s])) + return this; + if (!p.length) + break; + + (n[l + 1 & 3] || n[l + 2 & 3] || n[l + 3 & 3]) && (e = n, h = l) + } + for (; p.data !== t;) + if (r = p, !(p = p.next)) + return this; + return (i = p.next) && delete p.next, + r + ? (i + ? r.next = i + : delete r.next, this) + : n + ? (i + ? n[l] = i + : delete n[l], (p = n[0] || n[1] || n[2] || n[3]) && p === (n[3] || n[2] || n[1] || n[0]) && !p.length && (e + ? e[h] = p + : this._root = p), this) + : (this._root = i, this) + }, + cl = function () { + return this._root + }, + sl = function () { + var t = 0; + return this.visit(function (n) { + if (!n.length) + do + ++t; + while (n = n.next) + } + ), + t + }, + fl = function (t) { + var n, + e, + r, + i, + o, + u, + a = [], + c = this._root; + for (c && a.push(new ol(c, this._x0, this._y0, this._x1, this._y1)); n = a.pop();) + if (!t(c = n.node, r = n.x0, i = n.y0, o = n.x1, u = n.y1) && c.length) { + var s = (r + o) / 2, + f = (i + u) / 2; + (e = c[3]) && a.push(new ol(e, s, f, o, u)), + (e = c[2]) && a.push(new ol(e, r, f, s, u)), + (e = c[1]) && a.push(new ol(e, s, i, o, f)), + (e = c[0]) && a.push(new ol(e, r, i, s, f)) + } + return this + }, + ll = function (t) { + var n, + e = [], + r = []; + for (this._root && e.push(new ol(this._root, this._x0, this._y0, this._x1, this._y1)); n = e.pop();) { + var i = n.node; + if (i.length) { + var o, + u = n.x0, + a = n.y0, + c = n.x1, + s = n.y1, + f = (u + c) / 2, + l = (a + s) / 2; + (o = i[0]) && e.push(new ol(o, u, a, f, l)), + (o = i[1]) && e.push(new ol(o, f, a, c, l)), + (o = i[2]) && e.push(new ol(o, u, l, f, s)), + (o = i[3]) && e.push(new ol(o, f, l, c, s)) + } + r.push(n) + } + for (; n = r.pop();) + t(n.node, n.x0, n.y0, n.x1, n.y1); + return this + }, + hl = function (t) { + return arguments.length + ? (this._x = t, this) + : this._x + }, + pl = function (t) { + return arguments.length + ? (this._y = t, this) + : this._y + }, + dl = I.prototype = Y.prototype; + dl.copy = function () { + var t, + n, + e = new Y(this._x, this._y, this._x0, this._y0, this._x1, this._y1), + r = this._root; + if (!r) + return e; + if (!r.length) + return e._root = B(r), + e; + for (t = [ + { + source: r, + target: e._root = new Array(4) + } + ]; r = t.pop();) + for (var i = 0; i < 4; ++i) + (n = r.source[i]) && (n.length + ? t.push({ + source: n, + target: r.target[i] = new Array(4) + }) + : r.target[i] = B(n)); + return e + }, + dl.add = nl, + dl.addAll = U, + dl.cover = el, + dl.data = rl, + dl.extent = il, + dl.find = ul, + dl.remove = al, + dl.removeAll = D, + dl.root = cl, + dl.size = sl, + dl.visit = fl, + dl.visitAfter = ll, + dl.x = hl, + dl.y = pl; + var vl = [].slice, + _l = {}; + j.prototype = Z.prototype = { + constructor: j, + defer: function (t) { + if ("function" != typeof t || this._call) + throw new Error; + if (null != this._error) + return this; + var n = vl.call(arguments, 1); + return n.push(t), + ++this._waiting, + this + ._tasks + .push(n), + H(this), + this + }, + abort: function () { + return null == this._error && W(this, new Error("abort")), + this + }, + await: function (t) { + if ("function" != typeof t || this._call) + throw new Error; + return this._call = function (n, e) { + t.apply(null, [n].concat(e)) + }, + $(this), + this + }, + awaitAll: function (t) { + if ("function" != typeof t || this._call) + throw new Error; + return this._call = t, + $(this), + this + } + }; + var yl = function (t) { + return function () { + return t + } + }, + gl = 1e-12, + ml = Math.PI, + xl = ml / 2, + bl = 2 * ml, + wl = function () { + function t() { + var t, + s, + f =+ n.apply(this, arguments), + l =+ e.apply(this, arguments), + h = o.apply(this, arguments) - xl, + p = u.apply(this, arguments) - xl, + d = Math.abs(p - h), + v = p > h; + if (c || (c = t = L()), l < f && (s = l, l = f, f = s), l > gl) + if (d > bl - gl) + c.moveTo(l * Math.cos(h), l * Math.sin(h)), + c.arc(0, 0, l, h, p, !v), + f > gl && (c.moveTo(f * Math.cos(p), f * Math.sin(p)), c.arc(0, 0, f, p, h, v)); + else { + var _, + y, + g = h, + m = p, + x = h, + b = p, + w = d, + M = d, + T = a.apply(this, arguments) / 2, + N = T > gl && (i ?+ i.apply(this, arguments) : Math.sqrt(f * f + l * l)), + k = Math.min(Math.abs(l - f) / 2, + r.apply(this, arguments)), + S = k, + A = k; + if (N > gl) { + var E = nt(N / f * Math.sin(T)), + C = nt(N / l * Math.sin(T)); + (w -= 2 * E) > gl + ? (E *= v + ? 1 + : -1, x += E, b -= E) + : (w = 0, x = b = (h + p) / 2), + (M -= 2 * C) > gl + ? (C *= v + ? 1 + : -1, g += C, m -= C) + : (M = 0, g = m = (h + p) / 2) + } + var z = l * Math.cos(g), + P = l * Math.sin(g), + q = f * Math.cos(b), + R = f * Math.sin(b); + if (k > gl) { + var U = l * Math.cos(m), + D = l * Math.sin(m), + O = f * Math.cos(x), + F = f * Math.sin(x); + if (d < ml) { + var I = w > gl + ? et(z, P, O, F, U, D, q, R) + : [ + q, R + ], + Y = z - I[0], + B = P - I[1], + j = U - I[0], + H = D - I[1], + X = 1 / Math.sin(Math.acos((Y * j + B * H) / (Math.sqrt(Y * Y + B * B) * Math.sqrt(j * j + H * H))) / 2), + V = Math.sqrt(I[0] * I[0] + I[1] * I[1]); + S = Math.min(k, (f - V) / (X - 1)), + A = Math.min(k, (l - V) / (X + 1)) + } + } + M > gl + ? A > gl + ? (_ = rt(O, F, z, P, l, A, v), y = rt(U, D, q, R, l, A, v), c.moveTo(_.cx + _.x01, _.cy + _.y01), A < k + ? c.arc(_.cx, _.cy, A, Math.atan2(_.y01, _.x01), Math.atan2(y.y01, y.x01), !v) + : (c.arc(_.cx, _.cy, A, Math.atan2(_.y01, _.x01), Math.atan2(_.y11, _.x11), !v), c.arc(0, 0, l, Math.atan2(_.cy + _.y11, _.cx + _.x11), Math.atan2(y.cy + y.y11, y.cx + y.x11), !v), c.arc(y.cx, y.cy, A, Math.atan2(y.y11, y.x11), Math.atan2(y.y01, y.x01), !v))) + : (c.moveTo(z, P), c.arc(0, 0, l, g, m, !v)) + : c.moveTo(z, P), + f > gl && w > gl + ? S > gl + ? (_ = rt(q, R, U, D, f, -S, v), y = rt(z, P, O, F, f, -S, v), c.lineTo(_.cx + _.x01, _.cy + _.y01), S < k + ? c.arc(_.cx, _.cy, S, Math.atan2(_.y01, _.x01), Math.atan2(y.y01, y.x01), !v) + : (c.arc(_.cx, _.cy, S, Math.atan2(_.y01, _.x01), Math.atan2(_.y11, _.x11), !v), c.arc(0, 0, f, Math.atan2(_.cy + _.y11, _.cx + _.x11), Math.atan2(y.cy + y.y11, y.cx + y.x11), v), c.arc(y.cx, y.cy, S, Math.atan2(y.y11, y.x11), Math.atan2(y.y01, y.x01), !v))) + : c.arc(0, 0, f, b, x, v) + : c.lineTo(q, R) + } + else + c.moveTo(0, 0); + if (c.closePath(), t) + return c = null, + t + "" || null + } + var n = G, + e = J, + r = yl(0), + i = null, + o = Q, + u = K, + a = tt, + c = null; + return t.centroid = function () { + var t = (+ n.apply(this, arguments) + + e.apply(this, arguments)) / 2, + r = (+ o.apply(this, arguments) + + u.apply(this, arguments)) / 2 - ml / 2; + return [ + Math.cos(r) * t, + Math.sin(r) * t + ] + }, + t.innerRadius = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : yl(+ e), t) + : n + }, + t.outerRadius = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : yl(+ n), t) + : e + }, + t.cornerRadius = function (n) { + return arguments.length + ? (r = "function" == typeof n + ? n + : yl(+ n), t) + : r + }, + t.padRadius = function (n) { + return arguments.length + ? (i = null == n + ? null + : "function" == typeof n + ? n + : yl(+ n), t) + : i + }, + t.startAngle = function (n) { + return arguments.length + ? (o = "function" == typeof n + ? n + : yl(+ n), t) + : o + }, + t.endAngle = function (n) { + return arguments.length + ? (u = "function" == typeof n + ? n + : yl(+ n), t) + : u + }, + t.padAngle = function (n) { + return arguments.length + ? (a = "function" == typeof n + ? n + : yl(+ n), t) + : a + }, + t.context = function (n) { + return arguments.length + ? (c = null == n + ? null + : n, t) + : c + }, + t + }; + it.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._point = 0 + }, + lineEnd: function () { + (this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2; + default: + this + ._context + .lineTo(t, n) + } + } + }; + var Ml = function (t) { + return new it(t) + }, + Tl = function () { + function t(t) { + var a, + c, + s, + f = t.length, + l = !1; + for (null == i && (u = o(s = L())), a = 0; a <= f; ++a) + !(a < f && r(c = t[a], a, t)) === l && ((l = !l) + ? u.lineStart() + : u.lineEnd()), + l && u.point(+ n(c, a, t), + e(c, a, t)); + if (s) + return u = null, + s + "" || null + } + var n = ot, + e = ut, + r = yl(!0), + i = null, + o = Ml, + u = null; + return t.x = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : yl(+ e), t) + : n + }, + t.y = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : yl(+ n), t) + : e + }, + t.defined = function (n) { + return arguments.length + ? (r = "function" == typeof n + ? n + : yl(!!n), t) + : r + }, + t.curve = function (n) { + return arguments.length + ? (o = n, null != i && (u = o(i)), t) + : o + }, + t.context = function (n) { + return arguments.length + ? (null == n + ? i = u = null + : u = o(i = n), t) + : i + }, + t + }, + Nl = function () { + function t(t) { + var n, + f, + l, + h, + p, + d = t.length, + v = !1, + _ = new Array(d), + y = new Array(d); + for (null == a && (s = c(p = L())), n = 0; n <= d; ++n) { + if (!(n < d && u(h = t[n], n, t)) === v) + if (v = !v) + f = n, + s.areaStart(), + s.lineStart(); + else { + for (s.lineEnd(), s.lineStart(), l = n - 1; l >= f; --l) + s.point(_[l], y[l]); + s.lineEnd(), + s.areaEnd() + } + v && (_[n] =+ e(h, n, t), y[n] =+ i(h, n, t), s.point(r ?+ r(h, n, t) : _[n], o ?+ o(h, n, t) : y[n])) + } + if (p) + return s = null, + p + "" || null + } + function n() { + return Tl() + .defined(u) + .curve(c) + .context(a) + } + var e = ot, + r = null, + i = yl(0), + o = ut, + u = yl(!0), + a = null, + c = Ml, + s = null; + return t.x = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : yl(+ n), r = null, t) + : e + }, + t.x0 = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : yl(+ n), t) + : e + }, + t.x1 = function (n) { + return arguments.length + ? (r = null == n + ? null + : "function" == typeof n + ? n + : yl(+ n), t) + : r + }, + t.y = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : yl(+ n), o = null, t) + : i + }, + t.y0 = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : yl(+ n), t) + : i + }, + t.y1 = function (n) { + return arguments.length + ? (o = null == n + ? null + : "function" == typeof n + ? n + : yl(+ n), t) + : o + }, + t.lineX0 = t.lineY0 = function () { + return n() + .x(e) + .y(i) + }, + t.lineY1 = function () { + return n() + .x(e) + .y(o) + }, + t.lineX1 = function () { + return n() + .x(r) + .y(i) + }, + t.defined = function (n) { + return arguments.length + ? (u = "function" == typeof n + ? n + : yl(!!n), t) + : u + }, + t.curve = function (n) { + return arguments.length + ? (c = n, null != a && (s = c(a)), t) + : c + }, + t.context = function (n) { + return arguments.length + ? (null == n + ? a = s = null + : s = c(a = n), t) + : a + }, + t + }, + kl = function (t, n) { + return n < t + ? -1 + : n > t + ? 1 + : n >= t + ? 0 + : NaN + }, + Sl = function (t) { + return t + }, + Al = function () { + function t(t) { + var a, + c, + s, + f, + l, + h = t.length, + p = 0, + d = new Array(h), + v = new Array(h), + _ =+ i.apply(this, arguments), + y = Math.min(bl, Math.max(-bl, o.apply(this, arguments) - _)), + g = Math.min(Math.abs(y) / h, u.apply(this, arguments)), + m = g * (y < 0 + ? -1 + : 1); + for (a = 0; a < h; ++a) + (l = v[d[a] = a] =+ n(t[a], a, t)) > 0 && (p += l); + for (null != e + ? d.sort(function (t, n) { + return e(v[t], v[n]) + }) + : null != r && d.sort(function (n, e) { + return r(t[n], t[e]) + }), a = 0, s = p + ? (y - h * m) / p + : 0; a < h; ++a, _ = f) + c = d[a], + l = v[c], + f = _ + (l > 0 + ? l * s + : 0) + m, + v[c] = { + data: t[c], + index: a, + value: l, + startAngle: _, + endAngle: f, + padAngle: g + }; + return v + } + var n = Sl, + e = kl, + r = null, + i = yl(0), + o = yl(bl), + u = yl(0); + return t.value = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : yl(+ e), t) + : n + }, + t.sortValues = function (n) { + return arguments.length + ? (e = n, r = null, t) + : e + }, + t.sort = function (n) { + return arguments.length + ? (r = n, e = null, t) + : r + }, + t.startAngle = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : yl(+ n), t) + : i + }, + t.endAngle = function (n) { + return arguments.length + ? (o = "function" == typeof n + ? n + : yl(+ n), t) + : o + }, + t.padAngle = function (n) { + return arguments.length + ? (u = "function" == typeof n + ? n + : yl(+ n), t) + : u + }, + t + }, + El = ct(Ml); + at.prototype = { + areaStart: function () { + this + ._curve + .areaStart() + }, + areaEnd: function () { + this + ._curve + .areaEnd() + }, + lineStart: function () { + this + ._curve + .lineStart() + }, + lineEnd: function () { + this + ._curve + .lineEnd() + }, + point: function (t, n) { + this + ._curve + .point(n * Math.sin(t), n * -Math.cos(t)) + } + }; + var Cl = function () { + return st(Tl().curve(El)) + }, + zl = function () { + var t = Nl().curve(El), + n = t.curve, + e = t.lineX0, + r = t.lineX1, + i = t.lineY0, + o = t.lineY1; + return t.angle = t.x, + delete t.x, + t.startAngle = t.x0, + delete t.x0, + t.endAngle = t.x1, + delete t.x1, + t.radius = t.y, + delete t.y, + t.innerRadius = t.y0, + delete t.y0, + t.outerRadius = t.y1, + delete t.y1, + t.lineStartAngle = function () { + return st(e()) + }, + delete t.lineX0, + t.lineEndAngle = function () { + return st(r()) + }, + delete t.lineX1, + t.lineInnerRadius = function () { + return st(i()) + }, + delete t.lineY0, + t.lineOuterRadius = function () { + return st(o()) + }, + delete t.lineY1, + t.curve = function (t) { + return arguments.length + ? n(ct(t)) + : n()._curve + }, + t + }, + Pl = { + draw: function (t, n) { + var e = Math.sqrt(n / ml); + t.moveTo(e, 0), + t.arc(0, 0, e, 0, bl) + } + }, + ql = { + draw: function (t, n) { + var e = Math.sqrt(n / 5) / 2; + t.moveTo(-3 * e, -e), + t.lineTo(-e, -e), + t.lineTo(-e, -3 * e), + t.lineTo(e, -3 * e), + t.lineTo(e, -e), + t.lineTo(3 * e, -e), + t.lineTo(3 * e, e), + t.lineTo(e, e), + t.lineTo(e, 3 * e), + t.lineTo(-e, 3 * e), + t.lineTo(-e, e), + t.lineTo(-3 * e, e), + t.closePath() + } + }, + Ll = Math.sqrt(1 / 3), + Rl = 2 * Ll, + Ul = { + draw: function (t, n) { + var e = Math.sqrt(n / Rl), + r = e * Ll; + t.moveTo(0, -e), + t.lineTo(r, 0), + t.lineTo(0, e), + t.lineTo(-r, 0), + t.closePath() + } + }, + Dl = .8908130915292852, + Ol = Math.sin(ml / 10) / Math.sin(7 * ml / 10), + Fl = Math.sin(bl / 10) * Ol, + Il = -Math.cos(bl / 10) * Ol, + Yl = { + draw: function (t, n) { + var e = Math.sqrt(n * Dl), + r = Fl * e, + i = Il * e; + t.moveTo(0, -e), + t.lineTo(r, i); + for (var o = 1; o < 5; ++o) { + var u = bl * o / 5, + a = Math.cos(u), + c = Math.sin(u); + t.lineTo(c * e, -a * e), + t.lineTo(a * r - c * i, c * r + a * i) + } + t.closePath() + } + }, + Bl = { + draw: function (t, n) { + var e = Math.sqrt(n), + r = -e / 2; + t.rect(r, r, e, e) + } + }, + jl = Math.sqrt(3), + Hl = { + draw: function (t, n) { + var e = -Math.sqrt(n / (3 * jl)); + t.moveTo(0, 2 * e), + t.lineTo(-jl * e, -e), + t.lineTo(jl * e, -e), + t.closePath() + } + }, + Xl = -.5, + Vl = Math.sqrt(3) / 2, + Wl = 1 / Math.sqrt(12), + $l = 3 * (Wl / 2 + 1), + Zl = { + draw: function (t, n) { + var e = Math.sqrt(n / $l), + r = e / 2, + i = e * Wl, + o = r, + u = e * Wl + e, + a = -o, + c = u; + t.moveTo(r, i), + t.lineTo(o, u), + t.lineTo(a, c), + t.lineTo(Xl * r - Vl * i, Vl * r + Xl * i), + t.lineTo(Xl * o - Vl * u, Vl * o + Xl * u), + t.lineTo(Xl * a - Vl * c, Vl * a + Xl * c), + t.lineTo(Xl * r + Vl * i, Xl * i - Vl * r), + t.lineTo(Xl * o + Vl * u, Xl * u - Vl * o), + t.lineTo(Xl * a + Vl * c, Xl * c - Vl * a), + t.closePath() + } + }, + Gl = [ + Pl, + ql, + Ul, + Bl, + Yl, + Hl, + Zl + ], + Jl = function () { + function t() { + var t; + if (r || (r = t = L()), n.apply(this, arguments).draw(r, + e.apply(this, arguments)), t) + return r = null, + t + "" || null + } + var n = yl(Pl), + e = yl(64), + r = null; + return t.type = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : yl(e), t) + : n + }, + t.size = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : yl(+ n), t) + : e + }, + t.context = function (n) { + return arguments.length + ? (r = null == n + ? null + : n, t) + : r + }, + t + }, + Ql = function () {}; + lt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._y0 = this._y1 = NaN, + this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 3: + ft(this, this._x1, this._y1); + case 2: + this + ._context + .lineTo(this._x1, this._y1) + }(this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3, + this + ._context + .lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); + default: + ft(this, t, n) + } + this._x0 = this._x1, + this._x1 = t, + this._y0 = this._y1, + this._y1 = n + } + }; + var Kl = function (t) { + return new lt(t) + }; + ht.prototype = { + areaStart: Ql, + areaEnd: Ql, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN, + this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 1: + this + ._context + .moveTo(this._x2, this._y2), + this + ._context + .closePath(); + break; + case 2: + this + ._context + .moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3), + this + ._context + .lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3), + this + ._context + .closePath(); + break; + case 3: + this.point(this._x2, this._y2), + this.point(this._x3, this._y3), + this.point(this._x4, this._y4) + } + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._x2 = t, + this._y2 = n; + break; + case 1: + this._point = 2, + this._x3 = t, + this._y3 = n; + break; + case 2: + this._point = 3, + this._x4 = t, + this._y4 = n, + this + ._context + .moveTo((this._x0 + 4 * this._x1 + t) / 6, (this._y0 + 4 * this._y1 + n) / 6); + break; + default: + ft(this, t, n) + } + this._x0 = this._x1, + this._x1 = t, + this._y0 = this._y1, + this._y1 = n + } + }; + var th = function (t) { + return new ht(t) + }; + pt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._y0 = this._y1 = NaN, + this._point = 0 + }, + lineEnd: function () { + (this._line || 0 !== this._line && 3 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1; + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3; + var e = (this._x0 + 4 * this._x1 + t) / 6, + r = (this._y0 + 4 * this._y1 + n) / 6; + this._line + ? this + ._context + .lineTo(e, r) + : this + ._context + .moveTo(e, r); + break; + case 3: + this._point = 4; + default: + ft(this, t, n) + } + this._x0 = this._x1, + this._x1 = t, + this._y0 = this._y1, + this._y1 = n + } + }; + var nh = function (t) { + return new pt(t) + }; + dt.prototype = { + lineStart: function () { + this._x = [], + this._y = [], + this + ._basis + .lineStart() + }, + lineEnd: function () { + var t = this._x, + n = this._y, + e = t.length - 1; + if (e > 0) + for (var r, i = t[0], o = n[0], u = t[e] - i, a = n[e] - o, c = -1; ++c <= e;) + r = c / e, + this._basis.point(this._beta * t[c] + (1 - this._beta) * (i + r * u), this._beta * n[c] + (1 - this._beta) * (o + r * a)); + this._x = this._y = null, + this + ._basis + .lineEnd() + }, + point: function (t, n) { + this + ._x + .push(+ t), + this + ._y + .push(+ n) + } + }; + var eh = function t(n) { + function e(t) { + return 1 === n + ? new lt(t) + : new dt(t, n) + } + return e.beta = function (n) { + return t(+ n) + }, + e + }(.85); + _t.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, + this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 2: + this + ._context + .lineTo(this._x2, this._y2); + break; + case 3: + vt(this, this._x1, this._y1) + }(this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2, + this._x1 = t, + this._y1 = n; + break; + case 2: + this._point = 3; + default: + vt(this, t, n) + } + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var rh = function t(n) { + function e(t) { + return new _t(t, n) + } + return e.tension = function (n) { + return t(+ n) + }, + e + }(0); + yt.prototype = { + areaStart: Ql, + areaEnd: Ql, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, + this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 1: + this + ._context + .moveTo(this._x3, this._y3), + this + ._context + .closePath(); + break; + case 2: + this + ._context + .lineTo(this._x3, this._y3), + this + ._context + .closePath(); + break; + case 3: + this.point(this._x3, this._y3), + this.point(this._x4, this._y4), + this.point(this._x5, this._y5) + } + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._x3 = t, + this._y3 = n; + break; + case 1: + this._point = 2, + this + ._context + .moveTo(this._x4 = t, this._y4 = n); + break; + case 2: + this._point = 3, + this._x5 = t, + this._y5 = n; + break; + default: + vt(this, t, n) + } + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var ih = function t(n) { + function e(t) { + return new yt(t, n) + } + return e.tension = function (n) { + return t(+ n) + }, + e + }(0); + gt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, + this._point = 0 + }, + lineEnd: function () { + (this._line || 0 !== this._line && 3 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1; + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3, + this._line + ? this + ._context + .lineTo(this._x2, this._y2) + : this + ._context + .moveTo(this._x2, this._y2); + break; + case 3: + this._point = 4; + default: + vt(this, t, n) + } + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var oh = function t(n) { + function e(t) { + return new gt(t, n) + } + return e.tension = function (n) { + return t(+ n) + }, + e + }(0); + xt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 2: + this + ._context + .lineTo(this._x2, this._y2); + break; + case 3: + this.point(this._x2, this._y2) + }(this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + if (t =+ t, n =+ n, this._point) { + var e = this._x2 - t, + r = this._y2 - n; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(e * e + r * r, this._alpha)) + } + switch (this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3; + default: + mt(this, t, n) + } + this._l01_a = this._l12_a, + this._l12_a = this._l23_a, + this._l01_2a = this._l12_2a, + this._l12_2a = this._l23_2a, + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var uh = function t(n) { + function e(t) { + return n + ? new xt(t, n) + : new _t(t, 0) + } + return e.alpha = function (n) { + return t(+ n) + }, + e + }(.5); + bt.prototype = { + areaStart: Ql, + areaEnd: Ql, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 1: + this + ._context + .moveTo(this._x3, this._y3), + this + ._context + .closePath(); + break; + case 2: + this + ._context + .lineTo(this._x3, this._y3), + this + ._context + .closePath(); + break; + case 3: + this.point(this._x3, this._y3), + this.point(this._x4, this._y4), + this.point(this._x5, this._y5) + } + }, + point: function (t, n) { + if (t =+ t, n =+ n, this._point) { + var e = this._x2 - t, + r = this._y2 - n; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(e * e + r * r, this._alpha)) + } + switch (this._point) { + case 0: + this._point = 1, + this._x3 = t, + this._y3 = n; + break; + case 1: + this._point = 2, + this + ._context + .moveTo(this._x4 = t, this._y4 = n); + break; + case 2: + this._point = 3, + this._x5 = t, + this._y5 = n; + break; + default: + mt(this, t, n) + } + this._l01_a = this._l12_a, + this._l12_a = this._l23_a, + this._l01_2a = this._l12_2a, + this._l12_2a = this._l23_2a, + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var ah = function t(n) { + function e(t) { + return n + ? new bt(t, n) + : new yt(t, 0) + } + return e.alpha = function (n) { + return t(+ n) + }, + e + }(.5); + wt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0 + }, + lineEnd: function () { + (this._line || 0 !== this._line && 3 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + if (t =+ t, n =+ n, this._point) { + var e = this._x2 - t, + r = this._y2 - n; + this._l23_a = Math.sqrt(this._l23_2a = Math.pow(e * e + r * r, this._alpha)) + } + switch (this._point) { + case 0: + this._point = 1; + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3, + this._line + ? this + ._context + .lineTo(this._x2, this._y2) + : this + ._context + .moveTo(this._x2, this._y2); + break; + case 3: + this._point = 4; + default: + mt(this, t, n) + } + this._l01_a = this._l12_a, + this._l12_a = this._l23_a, + this._l01_2a = this._l12_2a, + this._l12_2a = this._l23_2a, + this._x0 = this._x1, + this._x1 = this._x2, + this._x2 = t, + this._y0 = this._y1, + this._y1 = this._y2, + this._y2 = n + } + }; + var ch = function t(n) { + function e(t) { + return n + ? new wt(t, n) + : new gt(t, 0) + } + return e.alpha = function (n) { + return t(+ n) + }, + e + }(.5); + Mt.prototype = { + areaStart: Ql, + areaEnd: Ql, + lineStart: function () { + this._point = 0 + }, + lineEnd: function () { + this._point && this + ._context + .closePath() + }, + point: function (t, n) { + t =+ t, + n =+ n, + this._point + ? this + ._context + .lineTo(t, n) + : (this._point = 1, this._context.moveTo(t, n)) + } + }; + var sh = function (t) { + return new Mt(t) + }; + At.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, + this._point = 0 + }, + lineEnd: function () { + switch (this._point) { + case 2: + this + ._context + .lineTo(this._x1, this._y1); + break; + case 3: + St(this, this._t0, kt(this, this._t0)) + }(this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line = 1 - this._line + }, + point: function (t, n) { + var e = NaN; + if (t =+ t, n =+ n, t !== this._x1 || n !== this._y1) { + switch (this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2; + break; + case 2: + this._point = 3, + St(this, kt(this, e = Nt(this, t, n)), e); + break; + default: + St(this, this._t0, e = Nt(this, t, n)) + } + this._x0 = this._x1, + this._x1 = t, + this._y0 = this._y1, + this._y1 = n, + this._t0 = e + } + } + }, + (Et.prototype = Object.create(At.prototype)).point = function (t, n) { + At + .prototype + .point + .call(this, n, t) + }, + Ct.prototype = { + moveTo: function (t, n) { + this + ._context + .moveTo(n, t) + }, + closePath: function () { + this + ._context + .closePath() + }, + lineTo: function (t, n) { + this + ._context + .lineTo(n, t) + }, + bezierCurveTo: function (t, n, e, r, i, o) { + this + ._context + .bezierCurveTo(n, t, r, e, o, i) + } + }, + qt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x = [], + this._y = [] + }, + lineEnd: function () { + var t = this._x, + n = this._y, + e = t.length; + if (e) + if (this._line + ? this._context.lineTo(t[0], n[0]) + : this._context.moveTo(t[0], n[0]), 2 === e) + this._context.lineTo(t[1], n[1]); + else + for (var r = Lt(t), i = Lt(n), o = 0, u = 1; u < e; ++o, ++u) + this._context.bezierCurveTo(r[0][o], i[0][o], r[1][o], i[1][o], t[u], n[u]); + (this._line || 0 !== this._line && 1 === e) && this + ._context + .closePath(), + this._line = 1 - this._line, + this._x = this._y = null + }, + point: function (t, n) { + this + ._x + .push(+ t), + this + ._y + .push(+ n) + } + }; + var fh = function (t) { + return new qt(t) + }; + Rt.prototype = { + areaStart: function () { + this._line = 0 + }, + areaEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._x = this._y = NaN, + this._point = 0 + }, + lineEnd: function () { + 0 < this._t && this._t < 1 && 2 === this._point && this + ._context + .lineTo(this._x, this._y), + (this._line || 0 !== this._line && 1 === this._point) && this + ._context + .closePath(), + this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line) + }, + point: function (t, n) { + switch (t =+ t, n =+ n, this._point) { + case 0: + this._point = 1, + this._line + ? this + ._context + .lineTo(t, n) + : this + ._context + .moveTo(t, n); + break; + case 1: + this._point = 2; + default: + if (this._t <= 0) + this._context.lineTo(this._x, n), + this._context.lineTo(t, n); + else { + var e = this._x * (1 - this._t) + t * this._t; + this + ._context + .lineTo(e, this._y), + this + ._context + .lineTo(e, n) + } + } + this._x = t, + this._y = n + } + }; + var lh = function (t) { + return new Rt(t, .5) + }, + hh = Array.prototype.slice, + ph = function (t, n) { + if ((r = t.length) > 1) + for (var e, r, i = 1, o = t[n[0]], u = o.length; i < r; ++i) { + e = o, + o = t[n[i]]; + for (var a = 0; a < u; ++a) + o[a][1] += o[a][0] = isNaN(e[a][1]) + ? e[a][0] + : e[a][1] + } + }, + dh = function (t) { + for (var n = t.length, e = new Array(n); --n >= 0;) + e[n] = n; + return e + }, + vh = function () { + function t(t) { + var o, + u, + a = n.apply(this, arguments), + c = t.length, + s = a.length, + f = new Array(s); + for (o = 0; o < s; ++o) { + for (var l, h = a[o], p = f[o] = new Array(c), d = 0; d < c; ++d) + p[d] = l = [ + 0, + i(t[d], h, d, t) + ], + l.data = t[d]; + p.key = h + } + for (o = 0, u = e(f); o < s; ++o) + f[u[o]].index = o; + return r(f, u), + f + } + var n = yl([]), + e = dh, + r = ph, + i = Ot; + return t.keys = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : yl(hh.call(e)), t) + : n + }, + t.value = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : yl(+ n), t) + : i + }, + t.order = function (n) { + return arguments.length + ? (e = null == n + ? dh + : "function" == typeof n + ? n + : yl(hh.call(n)), t) + : e + }, + t.offset = function (n) { + return arguments.length + ? (r = null == n + ? ph + : n, t) + : r + }, + t + }, + _h = function (t, n) { + if ((r = t.length) > 0) { + for (var e, r, i, o = 0, u = t[0].length; o < u; ++o) { + for (i = e = 0; e < r; ++e) + i += t[e][o][1] || 0; + if (i) + for (e = 0; e < r; ++e) + t[e][o][1] /= i + } + ph(t, n) + } + }, + yh = function (t, n) { + if ((e = t.length) > 0) { + for (var e, r = 0, i = t[n[0]], o = i.length; r < o; ++r) { + for (var u = 0, a = 0; u < e; ++u) + a += t[u][r][1] || 0; + i[r][1] += i[r][0] = -a / 2 + } + ph(t, n) + } + }, + gh = function (t, n) { + if ((i = t.length) > 0 && (r = (e = t[n[0]]).length) > 0) { + for (var e, r, i, o = 0, u = 1; u < r; ++u) { + for (var a = 0, c = 0, s = 0; a < i; ++a) { + for (var f = t[n[a]], l = f[u][1] || 0, + h = f[u - 1][1] || 0, + p = (l - h) / 2, + d = 0; d < a; ++d) { + var v = t[n[d]], + _ = v[u][1] || 0, + y = v[u - 1][1] || 0; + p += _ - y + } + c += l, + s += p * l + } + e[u - 1][1] += e[u - 1][0] = o, + c && (o -= s / c) + } + e[u - 1][1] += e[u - 1][0] = o, + ph(t, n) + } + }, + mh = function (t) { + var n = t.map(Ft); + return dh(t).sort(function (t, e) { + return n[t] - n[e] + }) + }, + xh = function (t) { + return mh(t).reverse() + }, + bh = function (t) { + var n, + e, + r = t.length, + i = t.map(Ft), + o = dh(t).sort(function (t, n) { + return i[n] - i[t] + }), + u = 0, + a = 0, + c = [], + s = []; + for (n = 0; n < r; ++n) + e = o[n], + u < a + ? (u += i[e], c.push(e)) + : (a += i[e], s.push(e)); + return s + .reverse() + .concat(c) + }, + wh = function (t) { + return dh(t).reverse() + }, + Mh = function (t, n, e) { + t.prototype = n.prototype = e, + e.constructor = t + }, + Th = .7, + Nh = 1 / Th, + kh = /^#([0-9a-f]{3})$/, + Sh = /^#([0-9a-f]{6})$/, + Ah = /^rgb\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*\)$/, + Eh = /^rgb\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/, + Ch = /^rgba\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/, + zh = /^rgba\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/, + Ph = /^hsl\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/, + qh = /^hsla\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/, + Lh = { + aliceblue: 15792383, + antiquewhite: 16444375, + aqua: 65535, + aquamarine: 8388564, + azure: 15794175, + beige: 16119260, + bisque: 16770244, + black: 0, + blanchedalmond: 16772045, + blue: 255, + blueviolet: 9055202, + brown: 10824234, + burlywood: 14596231, + cadetblue: 6266528, + chartreuse: 8388352, + chocolate: 13789470, + coral: 16744272, + cornflowerblue: 6591981, + cornsilk: 16775388, + crimson: 14423100, + cyan: 65535, + darkblue: 139, + darkcyan: 35723, + darkgoldenrod: 12092939, + darkgray: 11119017, + darkgreen: 25600, + darkgrey: 11119017, + darkkhaki: 12433259, + darkmagenta: 9109643, + darkolivegreen: 5597999, + darkorange: 16747520, + darkorchid: 10040012, + darkred: 9109504, + darksalmon: 15308410, + darkseagreen: 9419919, + darkslateblue: 4734347, + darkslategray: 3100495, + darkslategrey: 3100495, + darkturquoise: 52945, + darkviolet: 9699539, + deeppink: 16716947, + deepskyblue: 49151, + dimgray: 6908265, + dimgrey: 6908265, + dodgerblue: 2003199, + firebrick: 11674146, + floralwhite: 16775920, + forestgreen: 2263842, + fuchsia: 16711935, + gainsboro: 14474460, + ghostwhite: 16316671, + gold: 16766720, + goldenrod: 14329120, + gray: 8421504, + green: 32768, + greenyellow: 11403055, + grey: 8421504, + honeydew: 15794160, + hotpink: 16738740, + indianred: 13458524, + indigo: 4915330, + ivory: 16777200, + khaki: 15787660, + lavender: 15132410, + lavenderblush: 16773365, + lawngreen: 8190976, + lemonchiffon: 16775885, + lightblue: 11393254, + lightcoral: 15761536, + lightcyan: 14745599, + lightgoldenrodyellow: 16448210, + lightgray: 13882323, + lightgreen: 9498256, + lightgrey: 13882323, + lightpink: 16758465, + lightsalmon: 16752762, + lightseagreen: 2142890, + lightskyblue: 8900346, + lightslategray: 7833753, + lightslategrey: 7833753, + lightsteelblue: 11584734, + lightyellow: 16777184, + lime: 65280, + limegreen: 3329330, + linen: 16445670, + magenta: 16711935, + maroon: 8388608, + mediumaquamarine: 6737322, + mediumblue: 205, + mediumorchid: 12211667, + mediumpurple: 9662683, + mediumseagreen: 3978097, + mediumslateblue: 8087790, + mediumspringgreen: 64154, + mediumturquoise: 4772300, + mediumvioletred: 13047173, + midnightblue: 1644912, + mintcream: 16121850, + mistyrose: 16770273, + moccasin: 16770229, + navajowhite: 16768685, + navy: 128, + oldlace: 16643558, + olive: 8421376, + olivedrab: 7048739, + orange: 16753920, + orangered: 16729344, + orchid: 14315734, + palegoldenrod: 15657130, + palegreen: 10025880, + paleturquoise: 11529966, + palevioletred: 14381203, + papayawhip: 16773077, + peachpuff: 16767673, + peru: 13468991, + pink: 16761035, + plum: 14524637, + powderblue: 11591910, + purple: 8388736, + rebeccapurple: 6697881, + red: 16711680, + rosybrown: 12357519, + royalblue: 4286945, + saddlebrown: 9127187, + salmon: 16416882, + sandybrown: 16032864, + seagreen: 3050327, + seashell: 16774638, + sienna: 10506797, + silver: 12632256, + skyblue: 8900331, + slateblue: 6970061, + slategray: 7372944, + slategrey: 7372944, + snow: 16775930, + springgreen: 65407, + steelblue: 4620980, + tan: 13808780, + teal: 32896, + thistle: 14204888, + tomato: 16737095, + turquoise: 4251856, + violet: 15631086, + wheat: 16113331, + white: 16777215, + whitesmoke: 16119285, + yellow: 16776960, + yellowgreen: 10145074 + }; + Mh(Yt, Bt, { + displayable: function () { + return this + .rgb() + .displayable() + }, + toString: function () { + return this.rgb() + "" + } + }), + Mh(Wt, Vt, It(Yt, { + brighter: function (t) { + return t = null == t + ? Nh + : Math.pow(Nh, t), + new Wt(this.r * t, this.g * t, this.b * t, this.opacity) + }, + darker: function (t) { + return t = null == t + ? Th + : Math.pow(Th, t), + new Wt(this.r * t, this.g * t, this.b * t, this.opacity) + }, + rgb: function () { + return this + }, + displayable: function () { + return 0 <= this.r && this.r <= 255 && 0 <= this.g && this.g <= 255 && 0 <= this.b && this.b <= 255 && 0 <= this.opacity && this.opacity <= 1 + }, + toString: function () { + var t = this.opacity; + return t = isNaN(t) + ? 1 + : Math.max(0, Math.min(1, t)), + (1 === t + ? "rgb(" + : "rgba(") + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.b) || 0)) + (1 === t + ? ")" + : ", " + t + ")") + } + })), + Mh(Jt, Gt, It(Yt, { + brighter: function (t) { + return t = null == t + ? Nh + : Math.pow(Nh, t), + new Jt(this.h, this.s, this.l * t, this.opacity) + }, + darker: function (t) { + return t = null == t + ? Th + : Math.pow(Th, t), + new Jt(this.h, this.s, this.l * t, this.opacity) + }, + rgb: function () { + var t = this.h % 360 + 360 * (this.h < 0), + n = isNaN(t) || isNaN(this.s) + ? 0 + : this.s, + e = this.l, + r = e + (e < .5 + ? e + : 1 - e) * n, + i = 2 * e - r; + return new Wt(Qt(t >= 240 + ? t - 240 + : t + 120, i, r), Qt(t, i, r), Qt(t < 120 + ? t + 240 + : t - 120, i, r), this.opacity) + }, + displayable: function () { + return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1 + } + })); + var Rh = Math.PI / 180, + Uh = 180 / Math.PI, + Dh = 18, + Oh = .95047, + Fh = 1, + Ih = 1.08883, + Yh = 4 / 29, + Bh = 6 / 29, + jh = 3 * Bh * Bh, + Hh = Bh * Bh * Bh; + Mh(nn, tn, It(Yt, { + brighter: function (t) { + return new nn(this.l + Dh * (null == t + ? 1 + : t), this.a, this.b, this.opacity) + }, + darker: function (t) { + return new nn(this.l - Dh * (null == t + ? 1 + : t), this.a, this.b, this.opacity) + }, + rgb: function () { + var t = (this.l + 16) / 116, + n = isNaN(this.a) + ? t + : t + this.a / 500, + e = isNaN(this.b) + ? t + : t - this.b / 200; + return t = Fh * rn(t), + n = Oh * rn(n), + e = Ih * rn(e), + new Wt(on(3.2404542 * n - 1.5371385 * t - .4985314 * e), on(-.969266 * n + 1.8760108 * t + .041556 * e), on(.0556434 * n - .2040259 * t + 1.0572252 * e), this.opacity) + } + })), + Mh(sn, cn, It(Yt, { + brighter: function (t) { + return new sn(this.h, this.c, this.l + Dh * (null == t + ? 1 + : t), this.opacity) + }, + darker: function (t) { + return new sn(this.h, this.c, this.l - Dh * (null == t + ? 1 + : t), this.opacity) + }, + rgb: function () { + return Kt(this).rgb() + } + })); + var Xh = -.14861, + Vh = 1.78277, + Wh = -.29227, + $h = -.90649, + Zh = 1.97294, + Gh = Zh * $h, + Jh = Zh * Vh, + Qh = Vh * Wh - $h * Xh; + Mh(hn, ln, It(Yt, { + brighter: function (t) { + return t = null == t + ? Nh + : Math.pow(Nh, t), + new hn(this.h, this.s, this.l * t, this.opacity) + }, + darker: function (t) { + return t = null == t + ? Th + : Math.pow(Th, t), + new hn(this.h, this.s, this.l * t, this.opacity) + }, + rgb: function () { + var t = isNaN(this.h) + ? 0 + : (this.h + 120) * Rh, + n =+ this.l, + e = isNaN(this.s) + ? 0 + : this.s * n * (1 - n), + r = Math.cos(t), + i = Math.sin(t); + return new Wt(255 * (n + e * (Xh * r + Vh * i)), 255 * (n + e * (Wh * r + $h * i)), 255 * (n + e * (Zh * r)), this.opacity) + } + })); + var Kh, + tp, + np, + ep, + rp = function (t) { + var n = t.length - 1; + return function (e) { + var r = e <= 0 + ? e = 0 + : e >= 1 + ? (e = 1, n - 1) + : Math.floor(e * n), + i = t[r], + o = t[r + 1], + u = r > 0 + ? t[r - 1] + : 2 * i - o, + a = r < n - 1 + ? t[r + 2] + : 2 * o - i; + return pn((e - r / n) * n, u, i, o, a) + } + }, + ip = function (t) { + var n = t.length; + return function (e) { + var r = Math.floor(((e %= 1) < 0 + ? ++e + : e) * n), + i = t[(r + n - 1) % n], + o = t[r % n], + u = t[(r + 1) % n], + a = t[(r + 2) % n]; + return pn((e - r / n) * n, i, o, u, a) + } + }, + op = function (t) { + return function () { + return t + } + }, + up = function t(n) { + function e(t, n) { + var e = r((t = Vt(t)).r, (n = Vt(n)).r), + i = r(t.g, n.g), + o = r(t.b, n.b), + u = r(t.opacity, n.opacity); + return function (n) { + return t.r = e(n), + t.g = i(n), + t.b = o(n), + t.opacity = u(n), + t + "" + } + } + var r = yn(n); + return e.gamma = t, + e + }(1), + ap = mn(rp), + cp = mn(ip), + sp = function (t, n) { + var e, + r = n + ? n.length + : 0, + i = t + ? Math.min(r, t.length) + : 0, + o = new Array(r), + u = new Array(r); + for (e = 0; e < i; ++e) + o[e] = _p(t[e], n[e]); + for (; e < r; ++e) + u[e] = n[e]; + return function (t) { + for (e = 0; e < i; ++e) + u[e] = o[e](t); + return u + } + }, + fp = function (t, n) { + var e = new Date; + return t =+ t, + n -= t, + function (r) { + return e.setTime(t + n * r), + e + } + }, + lp = function (t, n) { + return t =+ t, + n -= t, + function (e) { + return t + n * e + } + }, + hp = function (t, n) { + var e, + r = {}, + i = {}; + null !== t && "object" == typeof t || (t = {}), + null !== n && "object" == typeof n || (n = {}); + for (e in n) + e in t + ? r[e] = _p(t[e], n[e]) + : i[e] = n[e]; + return function (t) { + for (e in r) + i[e] = r[e](t); + return i + } + }, + pp = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, + dp = new RegExp(pp.source, "g"), + vp = function (t, n) { + var e, + r, + i, + o = pp.lastIndex = dp.lastIndex = 0, + u = -1, + a = [], + c = []; + for (t += "", n += ""; (e = pp.exec(t)) && (r = dp.exec(n));) + (i = r.index) > o && (i = n.slice(o, i), a[u] + ? a[u] += i + : a[++u] = i), + (e = e[0]) === (r = r[0]) + ? a[u] + ? a[u] += r + : a[++u] = r + : (a[++u] = null, c.push({ + i: u, + x: lp(e, r) + })), + o = dp.lastIndex; + return o < n.length && (i = n.slice(o), a[u] + ? a[u] += i + : a[++u] = i), + a.length < 2 + ? c[0] + ? bn(c[0].x) + : xn(n) + : (n = c.length, function (t) { + for (var e, r = 0; r < n; ++r) + a[(e = c[r]).i] = e.x(t); + return a.join("") + }) + }, + _p = function (t, n) { + var e, + r = typeof n; + return null == n || "boolean" === r + ? op(n) + : ("number" === r + ? lp + : "string" === r + ? (e = Bt(n)) + ? (n = e, up) + : vp + : n instanceof Bt + ? up + : n instanceof Date + ? fp + : Array.isArray(n) + ? sp + : isNaN(n) + ? hp + : lp)(t, n) + }, + yp = function (t, n) { + return t =+ t, + n -= t, + function (e) { + return Math.round(t + n * e) + } + }, + gp = 180 / Math.PI, + mp = { + translateX: 0, + translateY: 0, + rotate: 0, + skewX: 0, + scaleX: 1, + scaleY: 1 + }, + xp = function (t, n, e, r, i, o) { + var u, + a, + c; + return (u = Math.sqrt(t * t + n * n)) && (t /= u, n /= u), + (c = t * e + n * r) && (e -= t * c, r -= n * c), + (a = Math.sqrt(e * e + r * r)) && (e /= a, r /= a, c /= a), + t * r < n * e && (t = -t, n = -n, c = -c, u = -u), { + translateX: i, + translateY: o, + rotate: Math.atan2(n, t) * gp, + skewX: Math.atan(c) * gp, + scaleX: u, + scaleY: a + } + }, + bp = Tn(wn, "px, ", "px)", "deg)"), + wp = Tn(Mn, ", ", ")", ")"), + Mp = Math.SQRT2, + Tp = 2, + Np = 4, + kp = 1e-12, + Sp = function (t, n) { + var e, + r, + i = t[0], + o = t[1], + u = t[2], + a = n[0], + c = n[1], + s = n[2], + f = a - i, + l = c - o, + h = f * f + l * l; + if (h < kp) + r = Math.log(s / u) / Mp, + e = function (t) { + return [ + i + t * f, + o + t * l, + u * Math.exp(Mp * t * r) + ] + }; + else { + var p = Math.sqrt(h), + d = (s * s - u * u + Np * h) / (2 * u * Tp * p), + v = (s * s - u * u - Np * h) / (2 * s * Tp * p), + _ = Math.log(Math.sqrt(d * d + 1) - d), + y = Math.log(Math.sqrt(v * v + 1) - v); + r = (y - _) / Mp, + e = function (t) { + var n = t * r, + e = Nn(_), + a = u / (Tp * p) * (e * Sn(Mp * n + _) - kn(_)); + return [ + i + a * f, + o + a * l, + u * e / Nn(Mp * n + _) + ] + } + } + return e.duration = 1e3 * r, + e + }, + Ap = An(_n), + Ep = An(gn), + Cp = Cn(_n), + zp = Cn(gn), + Pp = zn(_n), + qp = zn(gn), + Lp = function (t, n) { + for (var e = new Array(n), r = 0; r < n; ++r) + e[r] = t(r / (n - 1)); + return e + }, + Rp = { + value: function () {} + }; + qn.prototype = Pn.prototype = { + constructor: qn, + on: function (t, n) { + var e, + r = this._, + i = Ln(t + "", r), + o = -1, + u = i.length; + { + if (!(arguments.length < 2)) { + if (null != n && "function" != typeof n) + throw new Error("invalid callback: " + n); + for (; ++o < u;) + if (e = (t = i[o]).type) + r[e] = Un(r[e], t.name, n); + else if (null == n) + for (e in r) + r[e] = Un(r[e], t.name, null); + return this + } + for (; ++o < u;) + if ((e = (t = i[o]).type) && (e = Rn(r[e], t.name))) + return e + } + }, + copy: function () { + var t = {}, + n = this._; + for (var e in n) + t[e] = n[e].slice(); + return new qn(t) + }, + call: function (t, n) { + if ((e = arguments.length - 2) > 0) + for (var e, r, i = new Array(e), o = 0; o < e; ++o) + i[o] = arguments[o + 2]; + if (!this._.hasOwnProperty(t)) + throw new Error("unknown type: " + t); + for (r = this._[t], o = 0, e = r.length; o < e; ++o) + r[o].value.apply(n, i) + }, + apply: function (t, n, e) { + if (!this._.hasOwnProperty(t)) + throw new Error("unknown type: " + t); + for (var r = this._[t], i = 0, o = r.length; i < o; ++i) + r[i].value.apply(n, e) + } + }; + var Up, + Dp, + Op = function (t) { + function n(t, n) { + var r, + i, + o = e(t, function (t, e) { + return r + ? r(t, e - 1) + : (i = t, void(r = n + ? On(t, n) + : Dn(t))) + }); + return o.columns = i, + o + } + function e(t, n) { + function e() { + if (f >= s) + return u; + if (i) + return i = !1, + o; + var n, + e = f; + if (34 === t.charCodeAt(e)) { + for (var r = e; r++ < s;) + if (34 === t.charCodeAt(r)) { + if (34 !== t.charCodeAt(r + 1)) + break; + + ++r + } + return f = r + 2, + n = t.charCodeAt(r + 1), + 13 === n + ? (i = !0, 10 === t.charCodeAt(r + 2) && ++f) + : 10 === n && (i = !0), + t + .slice(e + 1, r) + .replace(/""/g, '"') + } + for (; f < s;) { + var a = 1; + if (n = t.charCodeAt(f++), 10 === n) + i = !0; + else if (13 === n) + i = !0, + 10 === t.charCodeAt(f) && (++f, ++a); + else if (n !== c) + continue; + return t.slice(e, f - a) + } + return t.slice(e) + } + for (var r, i, o = {}, u = {}, a = [], s = t.length, f = 0, l = 0; (r = e()) !== u;) { + for (var h = []; r !== o && r !== u;) + h.push(r), + r = e(); + n && null == (h = n(h, l++)) || a.push(h) + } + return a + } + function r(n, e) { + return null == e && (e = Fn(n)), + [ + e + .map(u) + .join(t) + ].concat(n.map(function (n) { + return e.map(function (t) { + return u(n[t]) + }).join(t) + })).join("\n") + } + function i(t) { + return t + .map(o) + .join("\n") + } + function o(n) { + return n + .map(u) + .join(t) + } + function u(t) { + return null == t + ? "" + : a.test(t += "") + ? '"' + t.replace(/\"/g, '""') + '"' + : t + } + var a = new RegExp('["' + t + "\n]"), + c = t.charCodeAt(0); + return {parse: n, parseRows: e, format: r, formatRows: i} + }, + Fp = Op(","), + Ip = Fp.parse, + Yp = Fp.parseRows, + Bp = Fp.format, + jp = Fp.formatRows, + Hp = Op("\t"), + Xp = Hp.parse, + Vp = Hp.parseRows, + Wp = Hp.format, + $p = Hp.formatRows, + Zp = function (t, n) { + function e(t) { + var n, + e = f.status; + if (!e && Yn(f) || e >= 200 && e < 300 || 304 === e) { + if (u) + try { + n = u.call(r, f) + } catch (t) { + return void c.call("error", r, t) + } + else + n = f; + c.call("load", r, n) + } else + c.call("error", r, t) + } + var r, + i, + u, + a, + c = Pn("beforesend", "progress", "load", "error"), + s = o(), + f = new XMLHttpRequest, + l = null, + h = null, + p = 0; + if ("undefined" == typeof XDomainRequest || "withCredentials" in f || !/^(http(s)?:)?\/\//.test(t) || (f = new XDomainRequest), "onload" in f + ? f.onload = f.onerror = f.ontimeout = e + : f.onreadystatechange = function (t) { + f.readyState > 3 && e(t) + }, + f.onprogress = function (t) { + c.call("progress", r, t) + }, + r = { + header: function (t, n) { + return t = (t + "").toLowerCase(), + arguments.length < 2 + ? s.get(t) + : (null == n + ? s.remove(t) + : s.set(t, n + ""), r) + }, + mimeType: function (t) { + return arguments.length + ? (i = null == t + ? null + : t + "", r) + : i + }, + responseType: function (t) { + return arguments.length + ? (a = t, r) + : a + }, + timeout: function (t) { + return arguments.length + ? (p =+ t, r) + : p + }, + user: function (t) { + return arguments.length < 1 + ? l + : (l = null == t + ? null + : t + "", r) + }, + password: function (t) { + return arguments.length < 1 + ? h + : (h = null == t + ? null + : t + "", r) + }, + response: function (t) { + return u = t, + r + }, + get: function (t, n) { + return r.send("GET", t, n) + }, + post: function (t, n) { + return r.send("POST", t, n) + }, + send: function (n, e, o) { + return f.open(n, t, !0, l, h), + null == i || s.has("accept") || s.set("accept", i + ",*/*"), + f.setRequestHeader && s.each(function (t, n) { + f.setRequestHeader(n, t) + }), + null != i && f.overrideMimeType && f.overrideMimeType(i), + null != a && (f.responseType = a), + p > 0 && (f.timeout = p), + null == o && "function" == typeof e && (o = e, e = null), + null != o && 1 === o.length && (o = In(o)), + null != o && r + .on("error", o) + .on("load", function (t) { + o(null, t) + }), + c.call("beforesend", r, f), + f.send(null == e + ? null + : e), + r + }, + abort: function () { + return f.abort(), + r + }, + on: function () { + var t = c + .on + .apply(c, arguments); + return t === c + ? r + : t + } + }, + null != n) { + if ("function" != typeof n) + throw new Error("invalid callback: " + n); + return r.get(n) + } + return r + }, + Gp = function (t, n) { + return function (e, r) { + var i = Zp(e) + .mimeType(t) + .response(n); + if (null != r) { + if ("function" != typeof r) + throw new Error("invalid callback: " + r); + return i.get(r) + } + return i + } + }, + Jp = Gp("text/html", function (t) { + return document + .createRange() + .createContextualFragment(t.responseText) + }), + Qp = Gp("application/json", function (t) { + return JSON.parse(t.responseText) + }), + Kp = Gp("text/plain", function (t) { + return t.responseText + }), + td = Gp("application/xml", function (t) { + var n = t.responseXML; + if (!n) + throw new Error("parse error"); + return n + }), + nd = function (t, n) { + return function (e, r, i) { + arguments.length < 3 && (i = r, r = null); + var o = Zp(e).mimeType(t); + return o.row = function (t) { + return arguments.length + ? o.response(Bn(n, r = t)) + : r + }, + o.row(r), + i + ? o.get(i) + : o + } + }, + ed = nd("text/csv", Ip), + rd = nd("text/tab-separated-values", Xp), + id = 0, + od = 0, + ud = 0, + ad = 1e3, + cd = 0, + sd = 0, + fd = 0, + ld = "object" == typeof performance && performance.now + ? performance + : Date, + hd = "function" == typeof requestAnimationFrame + ? requestAnimationFrame + : function (t) { + setTimeout(t, 17) + }; + Xn.prototype = Vn.prototype = { + constructor: Xn, + restart: function (t, n, e) { + if ("function" != typeof t) + throw new TypeError("callback is not a function"); + e = (null == e + ? jn() :+ e) + (null == n + ? 0 :+ n), + this._next || Dp === this || (Dp + ? Dp._next = this + : Up = this, Dp = this), + this._call = t, + this._time = e, + Jn() + }, + stop: function () { + this._call && (this._call = null, this._time = 1 / 0, Jn()) + } + }; + var pd = function (t, n, e) { + var r = new Xn; + return n = null == n + ? 0 :+ n, + r.restart(function (e) { + r.stop(), + t(e + n) + }, n, e), + r + }, + dd = function (t, n, e) { + var r = new Xn, + i = n; + return null == n + ? (r.restart(t, n, e), r) + : (n =+ n, e = null == e + ? jn() :+ e, r.restart(function o(u) { + u += i, + r.restart(o, i += n, e), + t(u) + }, n, e), r) + }, + vd = new Date, + _d = new Date, + yd = Qn(function () {}, function (t, n) { + t.setTime(+ t + n) + }, function (t, n) { + return n - t + }); + yd.every = function (t) { + return t = Math.floor(t), + isFinite(t) && t > 0 + ? t > 1 + ? Qn(function (n) { + n.setTime(Math.floor(n / t) * t) + }, function (n, e) { + n.setTime(+ n + e * t) + }, function (n, e) { + return (e - n) / t + }) + : yd + : null + }; + var gd = yd.range, + md = 1e3, + xd = 6e4, + bd = 36e5, + wd = 864e5, + Md = 6048e5, + Td = Qn(function (t) { + t.setTime(Math.floor(t / md) * md) + }, function (t, n) { + t.setTime(+ t + n * md) + }, function (t, n) { + return (n - t) / md + }, function (t) { + return t.getUTCSeconds() + }), + Nd = Td.range, + kd = Qn(function (t) { + t.setTime(Math.floor(t / xd) * xd) + }, function (t, n) { + t.setTime(+ t + n * xd) + }, function (t, n) { + return (n - t) / xd + }, function (t) { + return t.getMinutes() + }), + Sd = kd.range, + Ad = Qn(function (t) { + var n = t.getTimezoneOffset() * xd % bd; + n < 0 && (n += bd), + t.setTime(Math.floor((+ t - n) / bd) * bd + n) + }, function (t, n) { + t.setTime(+ t + n * bd) + }, function (t, n) { + return (n - t) / bd + }, function (t) { + return t.getHours() + }), + Ed = Ad.range, + Cd = Qn(function (t) { + t.setHours(0, 0, 0, 0) + }, function (t, n) { + t.setDate(t.getDate() + n) + }, function (t, n) { + return (n - t - (n.getTimezoneOffset() - t.getTimezoneOffset()) * xd) / wd + }, function (t) { + return t.getDate() - 1 + }), + zd = Cd.range, + Pd = Kn(0), + qd = Kn(1), + Ld = Kn(2), + Rd = Kn(3), + Ud = Kn(4), + Dd = Kn(5), + Od = Kn(6), + Fd = Pd.range, + Id = qd.range, + Yd = Ld.range, + Bd = Rd.range, + jd = Ud.range, + Hd = Dd.range, + Xd = Od.range, + Vd = Qn(function (t) { + t.setDate(1), + t.setHours(0, 0, 0, 0) + }, function (t, n) { + t.setMonth(t.getMonth() + n) + }, function (t, n) { + return n.getMonth() - t.getMonth() + 12 * (n.getFullYear() - t.getFullYear()) + }, function (t) { + return t.getMonth() + }), + Wd = Vd.range, + $d = Qn(function (t) { + t.setMonth(0, 1), + t.setHours(0, 0, 0, 0) + }, function (t, n) { + t.setFullYear(t.getFullYear() + n) + }, function (t, n) { + return n.getFullYear() - t.getFullYear() + }, function (t) { + return t.getFullYear() + }); + $d.every = function (t) { + return isFinite(t = Math.floor(t)) && t > 0 + ? Qn(function (n) { + n.setFullYear(Math.floor(n.getFullYear() / t) * t), + n.setMonth(0, 1), + n.setHours(0, 0, 0, 0) + }, function (n, e) { + n.setFullYear(n.getFullYear() + e * t) + }) + : null + }; + var Zd = $d.range, + Gd = Qn(function (t) { + t.setUTCSeconds(0, 0) + }, function (t, n) { + t.setTime(+ t + n * xd) + }, function (t, n) { + return (n - t) / xd + }, function (t) { + return t.getUTCMinutes() + }), + Jd = Gd.range, + Qd = Qn(function (t) { + t.setUTCMinutes(0, 0, 0) + }, function (t, n) { + t.setTime(+ t + n * bd) + }, function (t, n) { + return (n - t) / bd + }, function (t) { + return t.getUTCHours() + }), + Kd = Qd.range, + tv = Qn(function (t) { + t.setUTCHours(0, 0, 0, 0) + }, function (t, n) { + t.setUTCDate(t.getUTCDate() + n) + }, function (t, n) { + return (n - t) / wd + }, function (t) { + return t.getUTCDate() - 1 + }), + nv = tv.range, + ev = te(0), + rv = te(1), + iv = te(2), + ov = te(3), + uv = te(4), + av = te(5), + cv = te(6), + sv = ev.range, + fv = rv.range, + lv = iv.range, + hv = ov.range, + pv = uv.range, + dv = av.range, + vv = cv.range, + _v = Qn(function (t) { + t.setUTCDate(1), + t.setUTCHours(0, 0, 0, 0) + }, function (t, n) { + t.setUTCMonth(t.getUTCMonth() + n) + }, function (t, n) { + return n.getUTCMonth() - t.getUTCMonth() + 12 * (n.getUTCFullYear() - t.getUTCFullYear()) + }, function (t) { + return t.getUTCMonth() + }), + yv = _v.range, + gv = Qn(function (t) { + t.setUTCMonth(0, 1), + t.setUTCHours(0, 0, 0, 0) + }, function (t, n) { + t.setUTCFullYear(t.getUTCFullYear() + n) + }, function (t, n) { + return n.getUTCFullYear() - t.getUTCFullYear() + }, function (t) { + return t.getUTCFullYear() + }); + gv.every = function (t) { + return isFinite(t = Math.floor(t)) && t > 0 + ? Qn(function (n) { + n.setUTCFullYear(Math.floor(n.getUTCFullYear() / t) * t), + n.setUTCMonth(0, 1), + n.setUTCHours(0, 0, 0, 0) + }, function (n, e) { + n.setUTCFullYear(n.getUTCFullYear() + e * t) + }) + : null + }; + var mv, + xv = gv.range, + bv = function (t, n) { + if ((e = (t = n + ? t.toExponential(n - 1) + : t.toExponential()).indexOf("e")) < 0) + return null; + var e, + r = t.slice(0, e); + return [ + r.length > 1 + ? r[0] + r.slice(2) + : r, + t.slice(e + 1) + ] + }, + wv = function (t) { + return t = bv(Math.abs(t)), + t + ? t[1] + : NaN + }, + Mv = function (t, n) { + return function (e, r) { + for (var i = e.length, o = [], u = 0, a = t[0], c = 0; i > 0 && a > 0 && (c + a + 1 > r && (a = Math.max(1, r - c)), o.push(e.substring(i -= a, i + a)), !((c += a + 1) > r));) + a = t[u = (u + 1) % t.length]; + return o + .reverse() + .join(n) + } + }, + Tv = function (t, n) { + t = t.toPrecision(n); + t : for (var e, r = t.length, i = 1, o = -1; i < r; ++i) + switch (t[i]) { + case ".": + o = e = i; + break; + case "0": + 0 === o && (o = i), + e = i; + break; + case "e": + break t; + default: + o > 0 && (o = 0) + } + return o > 0 + ? t.slice(0, o) + t.slice(e + 1) + : t + }, + Nv = function (t, n) { + var e = bv(t, n); + if (!e) + return t + ""; + var r = e[0], + i = e[1], + o = i - (mv = 3 * Math.max(-8, Math.min(8, Math.floor(i / 3)))) + 1, + u = r.length; + return o === u + ? r + : o > u + ? r + new Array(o - u + 1).join("0") + : o > 0 + ? r.slice(0, o) + "." + r.slice(o) + : "0." + new Array(1 - o).join("0") + bv(t, Math.max(0, n + o - 1))[0] + }, + kv = function (t, n) { + var e = bv(t, n); + if (!e) + return t + ""; + var r = e[0], + i = e[1]; + return i < 0 + ? "0." + new Array(-i).join("0") + r + : r.length > i + 1 + ? r.slice(0, i + 1) + "." + r.slice(i + 1) + : r + new Array(i - r.length + 2).join("0") + }, + Sv = { + "": Tv, + "%": function (t, n) { + return (100 * t).toFixed(n) + }, + b: function (t) { + return Math + .round(t) + .toString(2) + }, + c: function (t) { + return t + "" + }, + d: function (t) { + return Math + .round(t) + .toString(10) + }, + e: function (t, n) { + return t.toExponential(n) + }, + f: function (t, n) { + return t.toFixed(n) + }, + g: function (t, n) { + return t.toPrecision(n) + }, + o: function (t) { + return Math + .round(t) + .toString(8) + }, + p: function (t, n) { + return kv(100 * t, n) + }, + r: kv, + s: Nv, + X: function (t) { + return Math + .round(t) + .toString(16) + .toUpperCase() + }, + x: function (t) { + return Math + .round(t) + .toString(16) + } + }, + Av = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i, + Ev = function (t) { + return new ne(t) + }; + ne.prototype.toString = function () { + return this.fill + this.align + this.sign + this.symbol + (this.zero + ? "0" + : "") + (null == this.width + ? "" + : Math.max(1, 0 | this.width)) + (this.comma + ? "," + : "") + (null == this.precision + ? "" + : "." + Math.max(0, 0 | this.precision)) + this.type + }; + var Cv, + zv = [ + "y", + "z", + "a", + "f", + "p", + "n", + "µ", + "m", + "", + "k", + "M", + "G", + "T", + "P", + "E", + "Z", + "Y" + ], + Pv = function (t) { + function n(t) { + function n(t) { + var n, + i, + c, + g = d, + m = v; + if ("c" === p) + m = _(t) + m, + t = ""; + else { + t =+ t; + var x = (t < 0 || 1 / t < 0) && (t *= -1, !0); + if (t = _(t, h), x) + for (n = -1, i = t.length, x = !1; ++n < i;) + if (c = t.charCodeAt(n), 48 < c && c < 58 || "x" === p && 96 < c && c < 103 || "X" === p && 64 < c && c < 71) { + x = !0; + break + } + if (g = (x + ? "(" === a + ? a + : "-" + : "-" === a || "(" === a + ? "" + : a) + g, m = m + ("s" === p + ? zv[8 + mv / 3] + : "") + (x && "(" === a + ? ")" + : ""), y) + for (n = -1, i = t.length; ++n < i;) + if (c = t.charCodeAt(n), 48 > c || c > 57) { + m = (46 === c + ? o + t.slice(n + 1) + : t.slice(n)) + m, + t = t.slice(0, n); + break + } + } + l && !s && (t = r(t, 1 / 0)); + var b = g.length + t.length + m.length, + w = b < f + ? new Array(f - b + 1).join(e) + : ""; + switch (l && s && (t = r(w + t, w.length + ? f - m.length + : 1 / 0), w = ""), u) { + case "<": + return g + t + m + w; + case "=": + return g + w + t + m; + case "^": + return w.slice(0, b = w.length >> 1) + g + t + m + w.slice(b) + } + return w + g + t + m + } + t = Ev(t); + var e = t.fill, + u = t.align, + a = t.sign, + c = t.symbol, + s = t.zero, + f = t.width, + l = t.comma, + h = t.precision, + p = t.type, + d = "$" === c + ? i[0] + : "#" === c && /[boxX]/.test(p) + ? "0" + p.toLowerCase() + : "", + v = "$" === c + ? i[1] + : /[%p]/.test(p) + ? "%" + : "", + _ = Sv[p], + y = !p || /[defgprs%]/.test(p); + return h = null == h + ? p + ? 6 + : 12 + : /[gprs]/.test(p) + ? Math.max(1, Math.min(21, h)) + : Math.max(0, Math.min(20, h)), + n.toString = function () { + return t + "" + }, + n + } + function e(t, e) { + var r = n((t = Ev(t), t.type = "f", t)), + i = 3 * Math.max(-8, Math.min(8, Math.floor(wv(e) / 3))), + o = Math.pow(10, -i), + u = zv[8 + i / 3]; + return function (t) { + return r(o * t) + u + } + } + var r = t.grouping && t.thousands + ? Mv(t.grouping, t.thousands) + : ee, + i = t.currency, + o = t.decimal; + return {format: n, formatPrefix: e} + }; + re({ + decimal: ".", + thousands: ",", + grouping: [3], + currency: ["$", ""] + }); + var qv, + Lv = function (t) { + return Math.max(0, -wv(Math.abs(t))) + }, + Rv = function (t, n) { + return Math.max(0, 3 * Math.max(-8, Math.min(8, Math.floor(wv(n) / 3))) - wv(Math.abs(t))) + }, + Uv = function (t, n) { + return t = Math.abs(t), + n = Math.abs(n) - t, + Math.max(0, wv(n) - wv(t)) + 1 + }, + Dv = { + "-": "", + _: " ", + 0: "0" + }, + Ov = /^\s*\d+/, + Fv = /^%/, + Iv = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; + nr({ + dateTime: "%x, %X", + date: "%-m/%-d/%Y", + time: "%-I:%M:%S %p", + periods: [ + "AM", "PM" + ], + days: [ + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday" + ], + shortDays: [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ], + months: [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December" + ], + shortMonths: [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ] + }); + var Yv = "%Y-%m-%dT%H:%M:%S.%LZ", + Bv = Date.prototype.toISOString + ? er + : t.utcFormat(Yv), + jv =+ new Date("2000-01-01T00:00:00.000Z") + ? rr + : t.utcParse(Yv), + Hv = Array.prototype, + Xv = Hv.map, + Vv = Hv.slice, + Wv = { + name: "implicit" + }, + $v = function (t) { + return function () { + return t + } + }, + Zv = function (t) { + return + t + }, + Gv = [ + 0, 1 + ], + Jv = function (n, r, i) { + var o, + u = n[0], + a = n[n.length - 1], + c = e(u, a, null == r + ? 10 + : r); + switch (i = Ev(null == i + ? ",f" + : i), i.type) { + case "s": + var s = Math.max(Math.abs(u), Math.abs(a)); + return null != i.precision || isNaN(o = Rv(c, s)) || (i.precision = o), + t.formatPrefix(i, s); + case "": + case "e": + case "g": + case "p": + case "r": + null != i.precision || isNaN(o = Uv(c, Math.max(Math.abs(u), Math.abs(a)))) || (i.precision = o - ("e" === i.type)); + break; + case "f": + case "%": + null != i.precision || isNaN(o = Lv(c)) || (i.precision = o - 2 * ("%" === i.type)) + } + return t.format(i) + }, + Qv = function (t, n) { + t = t.slice(); + var e, + r = 0, + i = t.length - 1, + o = t[r], + u = t[i]; + return u < o && (e = r, r = i, i = e, e = o, o = u, u = e), + t[r] = n.floor(o), + t[i] = n.ceil(u), + t + }, + Kv = 1e3, + t_ = 60 * Kv, + n_ = 60 * t_, + e_ = 24 * n_, + r_ = 7 * e_, + i_ = 30 * e_, + o_ = 365 * e_, + u_ = function () { + return qr($d, Vd, Pd, Cd, Ad, kd, Td, yd, t.timeFormat).domain([ + new Date(2e3, 0, 1), + new Date(2e3, 0, 2) + ]) + }, + a_ = function () { + return qr(gv, _v, ev, tv, Qd, Gd, Td, yd, t.utcFormat).domain([ + Date.UTC(2e3, 0, 1), + Date.UTC(2e3, 0, 2) + ]) + }, + c_ = function (t) { + return t + .match(/.{6}/g) + .map(function (t) { + return "#" + t + }) + }, + s_ = c_("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"), + f_ = c_("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad" + + "494ad6616be7969c7b4173a55194ce6dbdde9ed6"), + l_ = c_("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e" + + "9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"), + h_ = c_("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7" + + "b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"), + p_ = qp(ln(300, .5, 0), ln(-240, .5, 1)), + d_ = qp(ln(-100, .75, .35), ln(80, 1.5, .8)), + v_ = qp(ln(260, .75, .35), ln(80, 1.5, .8)), + __ = ln(), + y_ = function (t) { + (t < 0 || t > 1) && (t -= Math.floor(t)); + var n = Math.abs(t - .5); + return __.h = 360 * t - 100, + __.s = 1.5 - 1.5 * n, + __.l = .8 - .9 * n, + __ + "" + }, + g_ = Lr(c_("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548" + + "146748166848176948186a481a6c481b6d481c6e481d6f481f704820714821734823744824754825" + + "76482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581" + + "453781453882443983443a83443b84433d84433e85423f8542408642418641428741448740458840" + + "46883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a54" + + "8c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d" + + "33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d" + + "708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c" + + "8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e" + + "23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f" + + "958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1" + + "871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad81" + + "28ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773a" + + "ba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c5" + + "6954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece58" + + "70cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590" + + "d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd" + + "2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21a" + + "d8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8" + + "e621fbe723fde725")), + m_ = Lr(c_("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07" + + "061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e" + + "38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e221150241253251255271258" + + "29115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f" + + "0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c5413" + + "7d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c81" + + "6a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e" + + "24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b" + + "80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327d" + + "aa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf" + + "3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd343" + + "6ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064" + + "e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3" + + "655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d" + + "5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668" + + "fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77fe" + + "b078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec8" + + "8cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1" + + "fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fc" + + "f9bbfcfbbdfcfdbf")), + x_ = Lr(c_("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08" + + "051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c" + + "3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b59" + + "2f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a6845" + + "0a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a11" + + "6e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e" + + "71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85" + + "216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28" + + "659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305c" + + "b0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c3" + + "3b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d448" + + "42d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933" + + "e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef" + + "6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f784" + + "10f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06" + + "fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fb" + + "b61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf" + + "3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865" + + "f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9" + + "fc9dfafda1fcffa4")), + b_ = Lr(c_("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c" + + "05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d4303" + + "9e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a4" + + "5901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e" + + "00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104" + + "a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a2" + + "9511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a6" + + "2098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f" + + "8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80" + + "c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d0" + + "4d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c" + + "68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5d" + + "e66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef" + + "7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d" + + "45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3a" + + "fba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffd" + + "b42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc8" + + "27fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25" + + "f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1" + + "f525f0f724f0f921")), + w_ = "http://www.w3.org/1999/xhtml", + M_ = { + svg: "http://www.w3.org/2000/svg", + xhtml: w_, + xlink: "http://www.w3.org/1999/xlink", + xml: "http://www.w3.org/XML/1998/namespace", + xmlns: "http://www.w3.org/2000/xmlns/" + }, + T_ = function (t) { + var n = t += "", + e = n.indexOf(":"); + return e >= 0 && "xmlns" !== (n = t.slice(0, e)) && (t = t.slice(e + 1)), + M_.hasOwnProperty(n) + ? { + space: M_[n], + local: t + } + : t + }, + N_ = function (t) { + var n = T_(t); + return (n.local + ? Dr + : Ur)(n) + }, + k_ = 0; + Fr.prototype = Or.prototype = { + constructor: Fr, + get: function (t) { + for (var n = this._; !(n in t);) + if (!(t = t.parentNode)) + return; + return t[n] + }, + set: function (t, n) { + return t[this._] = n + }, + remove: function (t) { + return this._ in t && delete t[this._] + }, + toString: function () { + return this._ + } + }; + var S_ = function (t) { + return function () { + return this.matches(t) + } + }; + if ("undefined" != typeof document) { + var A_ = document.documentElement; + if (!A_.matches) { + var E_ = A_.webkitMatchesSelector || A_.msMatchesSelector || A_.mozMatchesSelector || A_.oMatchesSelector; + S_ = function (t) { + return function () { + return E_.call(this, t) + } + } + } + } + var C_ = S_, + z_ = {}; + if (t.event = null, "undefined" != typeof document) { + var P_ = document.documentElement; + "onmouseenter" in P_ || (z_ = { + mouseenter: "mouseover", + mouseleave: "mouseout" + }) + } + var q_ = function (t, n, e) { + var r, + i, + o = Br(t + ""), + u = o.length; + { + if (!(arguments.length < 2)) { + for (a = n + ? Hr + : jr, null == e && (e = !1), r = 0; r < u; ++r) + this.each(a(o[r], n, e)); + return this + } + var a = this + .node() + .__on; + if (a) + for (var c, s = 0, f = a.length; s < f; ++s) + for (r = 0, c = a[s]; r < u; ++r) + if ((i = o[r]).type === c.type && i.name === c.name) + return c.value + } + }, + L_ = function () { + for (var n, e = t.event; n = e.sourceEvent;) + e = n; + return e + }, + R_ = function (t, n) { + var e = t.ownerSVGElement || t; + if (e.createSVGPoint) { + var r = e.createSVGPoint(); + return r.x = n.clientX, + r.y = n.clientY, + r = r.matrixTransform(t.getScreenCTM().inverse()), + [r.x, r.y] + } + var i = t.getBoundingClientRect(); + return [ + n.clientX - i.left - t.clientLeft, + n.clientY - i.top - t.clientTop + ] + }, + U_ = function (t) { + var n = L_(); + return n.changedTouches && (n = n.changedTouches[0]), + R_(t, n) + }, + D_ = function (t) { + return null == t + ? Vr + : function () { + return this.querySelector(t) + } + }, + O_ = function (t) { + "function" != typeof t && (t = D_(t)); + for (var n = this._groups, e = n.length, r = new Array(e), i = 0; i < e; ++i) + for (var o, u, a = n[i], c = a.length, s = r[i] = new Array(c), f = 0; f < c; ++f) + (o = a[f]) && (u = t.call(o, o.__data__, f, a)) && ("__data__" in o && (u.__data__ = o.__data__), s[f] = u); + return new zi(r, this._parents) + }, + F_ = function (t) { + return null == t + ? Wr + : function () { + return this.querySelectorAll(t) + } + }, + I_ = function (t) { + "function" != typeof t && (t = F_(t)); + for (var n = this._groups, e = n.length, r = [], i = [], o = 0; o < e; ++o) + for (var u, a = n[o], c = a.length, s = 0; s < c; ++s) + (u = a[s]) && (r.push(t.call(u, u.__data__, s, a)), i.push(u)); + return new zi(r, i) + }, + Y_ = function (t) { + "function" != typeof t && (t = C_(t)); + for (var n = this._groups, e = n.length, r = new Array(e), i = 0; i < e; ++i) + for (var o, u = n[i], a = u.length, c = r[i] = [], s = 0; s < a; ++s) + (o = u[s]) && t.call(o, o.__data__, s, u) && c.push(o); + return new zi(r, this._parents) + }, + B_ = function (t) { + return new Array(t.length) + }, + j_ = function () { + return new zi(this._enter || this._groups.map(B_), this._parents) + }; + $r.prototype = { + constructor: $r, + appendChild: function (t) { + return this + ._parent + .insertBefore(t, this._next) + }, + insertBefore: function (t, n) { + return this + ._parent + .insertBefore(t, n) + }, + querySelector: function (t) { + return this + ._parent + .querySelector(t) + }, + querySelectorAll: function (t) { + return this + ._parent + .querySelectorAll(t) + } + }; + var H_ = function (t) { + return function () { + return t + } + }, + X_ = "$", + V_ = function (t, n) { + if (!t) + return p = new Array(this.size()), + s = -1, + this.each(function (t) { + p[++s] = t + }), + p; + var e = n + ? Gr + : Zr, + r = this._parents, + i = this._groups; + "function" != typeof t && (t = H_(t)); + for (var o = i.length, u = new Array(o), a = new Array(o), c = new Array(o), s = 0; s < o; ++s) { + var f = r[s], + l = i[s], + h = l.length, + p = t.call(f, f && f.__data__, s, r), + d = p.length, + v = a[s] = new Array(d), + _ = u[s] = new Array(d), + y = c[s] = new Array(h); + e(f, l, v, _, y, p, n); + for (var g, m, x = 0, b = 0; x < d; ++x) + if (g = v[x]) { + for (x >= b && (b = x + 1); !(m = _[b]) && ++b < d;) + ; + g._next = m || null + } + } + return u = new zi(u, r), + u._enter = a, + u._exit = c, + u + }, + W_ = function () { + return new zi(this._exit || this._groups.map(B_), this._parents) + }, + $_ = function (t) { + for (var n = this._groups, e = t._groups, r = n.length, i = e.length, o = Math.min(r, i), u = new Array(r), a = 0; a < o; ++a) + for (var c, s = n[a], f = e[a], l = s.length, h = u[a] = new Array(l), p = 0; p < l; ++p) + (c = s[p] || f[p]) && (h[p] = c); + for (; a < r; ++a) + u[a] = n[a]; + return new zi(u, this._parents) + }, + Z_ = function () { + for (var t = this._groups, n = -1, e = t.length; ++n < e;) + for (var r, i = t[n], o = i.length - 1, u = i[o]; --o >= 0;) + (r = i[o]) && (u && u !== r.nextSibling && u.parentNode.insertBefore(r, u), u = r); + return this + }, + G_ = function (t) { + function n(n, e) { + return n && e + ? t(n.__data__, e.__data__) + : !n - !e + } + t || (t = Jr); + for (var e = this._groups, r = e.length, i = new Array(r), o = 0; o < r; ++o) { + for (var u, a = e[o], c = a.length, s = i[o] = new Array(c), f = 0; f < c; ++f) + (u = a[f]) && (s[f] = u); + s.sort(n) + } + return new zi(i, this._parents).order() + }, + J_ = function () { + var t = arguments[0]; + return arguments[0] = this, + t.apply(null, arguments), + this + }, + Q_ = function () { + var t = new Array(this.size()), + n = -1; + return this.each(function () { + t[++n] = this + }), + t + }, + K_ = function () { + for (var t = this._groups, n = 0, e = t.length; n < e; ++n) + for (var r = t[n], i = 0, o = r.length; i < o; ++i) { + var u = r[i]; + if (u) + return u + } + return null + }, + ty = function () { + var t = 0; + return this.each(function () { + ++t + }), + t + }, + ny = function () { + return !this.node() + }, + ey = function (t) { + for (var n = this._groups, e = 0, r = n.length; e < r; ++e) + for (var i, o = n[e], u = 0, a = o.length; u < a; ++u) + (i = o[u]) && t.call(i, i.__data__, u, o); + return this + }, + ry = function (t, n) { + var e = T_(t); + if (arguments.length < 2) { + var r = this.node(); + return e.local + ? r.getAttributeNS(e.space, e.local) + : r.getAttribute(e) + } + return this.each((null == n + ? e.local + ? Kr + : Qr + : "function" == typeof n + ? e.local + ? ri + : ei + : e.local + ? ni + : ti)(e, n)) + }, + iy = function (t) { + return t.ownerDocument && t.ownerDocument.defaultView || t.document && t || t.defaultView + }, + oy = function (t, n, e) { + var r; + return arguments.length > 1 + ? this.each((null == n + ? ii + : "function" == typeof n + ? ui + : oi)(t, n, null == e + ? "" + : e)) + : iy(r = this.node()) + .getComputedStyle(r, null) + .getPropertyValue(t) + }, + uy = function (t, n) { + return arguments.length > 1 + ? this.each((null == n + ? ai + : "function" == typeof n + ? si + : ci)(t, n)) + : this.node()[t] + }; + hi.prototype = { + add: function (t) { + var n = this + ._names + .indexOf(t); + n < 0 && (this._names.push(t), this._node.setAttribute("class", this._names.join(" "))) + }, + remove: function (t) { + var n = this + ._names + .indexOf(t); + n >= 0 && (this._names.splice(n, 1), this._node.setAttribute("class", this._names.join(" "))) + }, + contains: function (t) { + return this + ._names + .indexOf(t) >= 0 + } + }; + var ay = function (t, n) { + var e = fi(t + ""); + if (arguments.length < 2) { + for (var r = li(this.node()), i = -1, o = e.length; ++i < o;) + if (!r.contains(e[i])) + return !1; + return !0 + } + return this.each(("function" == typeof n + ? yi + : n + ? vi + : _i)(e, n)) + }, + cy = function (t) { + return arguments.length + ? this.each(null == t + ? gi + : ("function" == typeof t + ? xi + : mi)(t)) + : this + .node() + .textContent + }, + sy = function (t) { + return arguments.length + ? this.each(null == t + ? bi + : ("function" == typeof t + ? Mi + : wi)(t)) + : this + .node() + .innerHTML + }, + fy = function () { + return this.each(Ti) + }, + ly = function () { + return this.each(Ni) + }, + hy = function (t) { + var n = "function" == typeof t + ? t + : N_(t); + return this.select(function () { + return this.appendChild(n.apply(this, arguments)) + }) + }, + py = function (t, n) { + var e = "function" == typeof t + ? t + : N_(t), + r = null == n + ? ki + : "function" == typeof n + ? n + : D_(n); + return this.select(function () { + return this.insertBefore(e.apply(this, arguments), r.apply(this, arguments) || null) + }) + }, + dy = function () { + return this.each(Si) + }, + vy = function (t) { + return arguments.length + ? this.property("__data__", t) + : this + .node() + .__data__ + }, + _y = function (t, n) { + return this.each(("function" == typeof n + ? Ci + : Ei)(t, n)) + }, + yy = [null]; + zi.prototype = Pi.prototype = { + constructor: zi, + select: O_, + selectAll: I_, + filter: Y_, + data: V_, + enter: j_, + exit: W_, + merge: $_, + order: Z_, + sort: G_, + call: J_, + nodes: Q_, + node: K_, + size: ty, + empty: ny, + each: ey, + attr: ry, + style: oy, + property: uy, + classed: ay, + text: cy, + html: sy, + raise: fy, + lower: ly, + append: hy, + insert: py, + remove: dy, + datum: vy, + on: q_, + dispatch: _y + }; + var gy = function (t) { + return "string" == typeof t + ? new zi([ + [document.querySelector(t)] + ], [document.documentElement]) + : new zi([ + [t] + ], yy) + }, + my = function (t) { + return "string" == typeof t + ? new zi([document.querySelectorAll(t)], [document.documentElement]) + : new zi([null == t + ? [] + : t], yy) + }, + xy = function (t, n, e) { + arguments.length < 3 && (e = n, n = L_().changedTouches); + for (var r, i = 0, o = n + ? n.length + : 0; i < o; ++i) + if ((r = n[i]).identifier === e) + return R_(t, r); + return null + }, + by = function (t, n) { + null == n && (n = L_().touches); + for (var e = 0, r = n + ? n.length + : 0, i = new Array(r); e < r; ++e) + i[e] = R_(t, n[e]); + return i + }, + wy = Pn("start", "end", "interrupt"), + My = [], + Ty = 0, + Ny = 1, + ky = 2, + Sy = 3, + Ay = 4, + Ey = 5, + Cy = 6, + zy = function (t, n, e, r, i, o) { + var u = t.__transition; + if (u) { + if (e in u) + return + } else + t.__transition = {}; + Ui(t, e, { + name: n, + index: r, + group: i, + on: wy, + tween: My, + time: o.time, + delay: o.delay, + duration: o.duration, + ease: o.ease, + timer: null, + state: Ty + }) + }, + Py = function (t, n) { + var e, + r, + i, + o = t.__transition, + u = !0; + if (o) { + n = null == n + ? null + : n + ""; + for (i in o) + (e = o[i]).name === n + ? (r = e.state > ky && e.state < Ey, e.state = Cy, e.timer.stop(), r && e.on.call("interrupt", t, t.__data__, e.index, e.group), delete o[i]) + : u = !1; + u && delete t.__transition + } + }, + qy = function (t) { + return this.each(function () { + Py(this, t) + }) + }, + Ly = function (t, n) { + var e = this._id; + if (t += "", arguments.length < 2) { + for (var r, i = Ri(this.node(), e).tween, o = 0, u = i.length; o < u; ++o) + if ((r = i[o]).name === t) + return r.value; + return null + } + return this.each((null == n + ? Di + : Oi)(e, t, n)) + }, + Ry = function (t, n) { + var e; + return ("number" == typeof n + ? lp + : n instanceof Bt + ? up + : (e = Bt(n)) + ? (n = e, up) + : vp)(t, n) + }, + Uy = function (t, n) { + var e = T_(t), + r = "transform" === e + ? wp + : Ry; + return this.attrTween(t, "function" == typeof n + ? (e.local + ? Xi + : Hi)(e, r, Fi(this, "attr." + t, n)) + : null == n + ? (e.local + ? Yi + : Ii)(e) + : (e.local + ? ji + : Bi)(e, r, n)) + }, + Dy = function (t, n) { + var e = "attr." + t; + if (arguments.length < 2) + return (e = this.tween(e)) && e._value; + if (null == n) + return this.tween(e, null); + if ("function" != typeof n) + throw new Error; + var r = T_(t); + return this.tween(e, (r.local + ? Vi + : Wi)(r, n)) + }, + Oy = function (t) { + var n = this._id; + return arguments.length + ? this.each(("function" == typeof t + ? $i + : Zi)(n, t)) + : Ri(this.node(), n).delay + }, + Fy = function (t) { + var n = this._id; + return arguments.length + ? this.each(("function" == typeof t + ? Gi + : Ji)(n, t)) + : Ri(this.node(), n).duration + }, + Iy = function (t) { + var n = this._id; + return arguments.length + ? this.each(Qi(n, t)) + : Ri(this.node(), n).ease + }, + Yy = function (t) { + "function" != typeof t && (t = C_(t)); + for (var n = this._groups, e = n.length, r = new Array(e), i = 0; i < e; ++i) + for (var o, u = n[i], a = u.length, c = r[i] = [], s = 0; s < a; ++s) + (o = u[s]) && t.call(o, o.__data__, s, u) && c.push(o); + return new so(r, this._parents, this._name, this._id) + }, + By = function (t) { + if (t._id !== this._id) + throw new Error; + for (var n = this._groups, e = t._groups, r = n.length, i = e.length, o = Math.min(r, i), u = new Array(r), a = 0; a < o; ++a) + for (var c, s = n[a], f = e[a], l = s.length, h = u[a] = new Array(l), p = 0; p < l; ++p) + (c = s[p] || f[p]) && (h[p] = c); + for (; a < r; ++a) + u[a] = n[a]; + return new so(u, this._parents, this._name, this._id) + }, + jy = function (t, n) { + var e = this._id; + return arguments.length < 2 + ? Ri(this.node(), e) + .on + .on(t) + : this.each(to(e, t, n)) + }, + Hy = function () { + return this.on("end.remove", no(this._id)) + }, + Xy = function (t) { + var n = this._name, + e = this._id; + "function" != typeof t && (t = D_(t)); + for (var r = this._groups, i = r.length, o = new Array(i), u = 0; u < i; ++u) + for (var a, c, s = r[u], f = s.length, l = o[u] = new Array(f), h = 0; h < f; ++h) + (a = s[h]) && (c = t.call(a, a.__data__, h, s)) && ("__data__" in a && (c.__data__ = a.__data__), l[h] = c, zy(l[h], n, e, h, l, Ri(a, e))); + return new so(o, this._parents, n, e) + }, + Vy = function (t) { + var n = this._name, + e = this._id; + "function" != typeof t && (t = F_(t)); + for (var r = this._groups, i = r.length, o = [], u = [], a = 0; a < i; ++a) + for (var c, s = r[a], f = s.length, l = 0; l < f; ++l) + if (c = s[l]) { + for (var h, p = t.call(c, c.__data__, l, s), d = Ri(c, e), v = 0, _ = p.length; v < _; ++v) + (h = p[v]) && zy(h, n, e, v, p, d); + o.push(p), + u.push(c) + } + return new so(o, u, n, e) + }, + Wy = Pi.prototype.constructor, + $y = function () { + return new Wy(this._groups, this._parents) + }, + Zy = function (t, n, e) { + var r = "transform" == (t += "") + ? bp + : Ry; + return null == n + ? this + .styleTween(t, eo(t, r)) + .on("end.style." + t, ro(t)) + : this.styleTween(t, "function" == typeof n + ? oo(t, r, Fi(this, "style." + t, n)) + : io(t, r, n), e) + }, + Gy = function (t, n, e) { + var r = "style." + (t += ""); + if (arguments.length < 2) + return (r = this.tween(r)) && r._value; + if (null == n) + return this.tween(r, null); + if ("function" != typeof n) + throw new Error; + return this.tween(r, uo(t, n, null == e + ? "" + : e)) + }, + Jy = function (t) { + return this.tween("text", "function" == typeof t + ? co(Fi(this, "text", t)) + : ao(null == t + ? "" + : t + "")) + }, + Qy = function () { + for (var t = this._name, n = this._id, e = lo(), r = this._groups, i = r.length, o = 0; o < i; ++o) + for (var u, a = r[o], c = a.length, s = 0; s < c; ++s) + if (u = a[s]) { + var f = Ri(u, n); + zy(u, t, e, s, a, { + time: f.time + f.delay + f.duration, + delay: 0, + duration: f.duration, + ease: f.ease + }) + } + return new so(r, this._parents, t, e) + }, + Ky = 0, + tg = Pi.prototype; + so.prototype = fo.prototype = { + constructor: so, + select: Xy, + selectAll: Vy, + filter: Yy, + merge: By, + selection: $y, + transition: Qy, + call: tg.call, + nodes: tg.nodes, + node: tg.node, + size: tg.size, + empty: tg.empty, + each: tg.each, + on: jy, + attr: Uy, + attrTween: Dy, + style: Zy, + styleTween: Gy, + text: Jy, + remove: Hy, + tween: Ly, + delay: Oy, + duration: Fy, + ease: Iy + }; + var ng = { + time: null, + delay: 0, + duration: 250, + ease: g + }, + eg = function (t) { + var n, + e; + t instanceof so + ? (n = t._id, t = t._name) + : (n = lo(), (e = ng).time = jn(), t = null == t + ? null + : t + ""); + for (var r = this._groups, i = r.length, o = 0; o < i; ++o) + for (var u, a = r[o], c = a.length, s = 0; s < c; ++s) + (u = a[s]) && zy(u, t, n, s, a, e || ho(u, n)); + return new so(r, this._parents, t, n) + }; + Pi.prototype.interrupt = qy, + Pi.prototype.transition = eg; + var rg = [null], + ig = function (t, n) { + var e, + r, + i = t.__transition; + if (i) { + n = null == n + ? null + : n + ""; + for (r in i) + if ((e = i[r]).state > Ny && e.name === n) + return new so([ + [t] + ], rg, n, + r) + } + return null + }, + og = Array.prototype.slice, + ug = function (t) { + return t + }, + ag = 1, + cg = 2, + sg = 3, + fg = 4, + lg = 1e-6, + hg = function () { + function t(t) { + var o, + u = 0; + t.eachAfter(function (t) { + var e = t.children; + e + ? (t.x = To(e), t.y = ko(e)) + : (t.x = o + ? u += n(t, o) + : 0, t.y = 0, o = t) + }); + var a = Ao(t), + c = Eo(t), + s = a.x - n(a, c) / 2, + f = c.x + n(c, a) / 2; + return t.eachAfter(i + ? function (n) { + n.x = (n.x - t.x) * e, + n.y = (t.y - n.y) * r + } + : function (n) { + n.x = (n.x - s) / (f - s) * e, + n.y = (1 - (t.y + ? n.y / t.y + : 1)) * r + }) + } + var n = Mo, + e = 1, + r = 1, + i = !1; + return t.separation = function (e) { + return arguments.length + ? (n = e, t) + : n + }, + t.size = function (n) { + return arguments.length + ? (i = !1, e =+ n[0], r =+ n[1], t) + : i + ? null + : [e, r] + }, + t.nodeSize = function (n) { + return arguments.length + ? (i = !0, e =+ n[0], r =+ n[1], t) + : i + ? [e, r] + : null + }, + t + }, + pg = function (t) { + var n, + e, + r, + i, + o = this, + u = [o]; + do + for (n = u.reverse(), u = []; o = n.pop();) + if (t(o), e = o.children) + for (r = 0, i = e.length; r < i; ++r) + u.push(e[r]); + while (u.length); + return this + }, + dg = function (t) { + for (var n, e, r = this, i = [r]; r = i.pop();) + if (t(r), n = r.children) + for (e = n.length - 1; e >= 0; --e) + i.push(n[e]); + return this + }, + vg = function (t) { + for (var n, e, r, i = this, o = [i], u = []; i = o.pop();) + if (u.push(i), n = i.children) + for (e = 0, r = n.length; e < r; ++e) + o.push(n[e]); + for (; i = u.pop();) + t(i); + return this + }, + _g = function (t) { + return this.eachAfter(function (n) { + for (var e =+ t(n.data) || 0, r = n.children, i = r && r.length; --i >= 0;) + e += r[i].value; + n.value = e + }) + }, + yg = function (t) { + return this.eachBefore(function (n) { + n.children && n + .children + .sort(t) + }) + }, + gg = function (t) { + for (var n = this, e = Co(n, t), r = [n]; n !== e;) + n = n.parent, + r.push(n); + for (var i = r.length; t !== e;) + r.splice(i, 0, t), + t = t.parent; + return r + }, + mg = function () { + for (var t = this, n = [t]; t = t.parent;) + n.push(t); + return n + }, + xg = function () { + var t = []; + return this.each(function (n) { + t.push(n) + }), + t + }, + bg = function () { + var t = []; + return this.eachBefore(function (n) { + n.children || t.push(n) + }), + t + }, + wg = function () { + var t = this, + n = []; + return t.each(function (e) { + e !== t && n.push({source: e.parent, target: e}) + }), + n + }; + Uo.prototype = zo.prototype = { + constructor: Uo, + each: pg, + eachAfter: vg, + eachBefore: dg, + sum: _g, + sort: yg, + path: gg, + ancestors: mg, + descendants: xg, + leaves: bg, + links: wg, + copy: Po + }; + var Mg = function (t) { + for (var n, e = (t = t.slice()).length, r = null, i = r; e;) { + var o = new Do(t[e - 1]); + i = i + ? i.next = o + : r = o, + t[n] = t[--e] + } + return {head: r, tail: i} + }, + Tg = function (t) { + return Fo(Mg(t), []) + }, + Ng = function (t) { + return Wo(t), + t + }, + kg = function (t) { + return function () { + return t + } + }, + Sg = function () { + function t(t) { + return t.x = e / 2, + t.y = r / 2, + n + ? t + .eachBefore(Qo(n)) + .eachAfter(Ko(i, .5)) + .eachBefore(tu(1)) + : t + .eachBefore(Qo(Jo)) + .eachAfter(Ko(Go, 1)) + .eachAfter(Ko(i, t.r / Math.min(e, r))) + .eachBefore(tu(Math.min(e, r) / (2 * t.r))), + t + } + var n = null, + e = 1, + r = 1, + i = Go; + return t.radius = function (e) { + return arguments.length + ? (n = $o(e), t) + : n + }, + t.size = function (n) { + return arguments.length + ? (e =+ n[0], r =+ n[1], t) + : [e, r] + }, + t.padding = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : kg(+ n), t) + : i + }, + t + }, + Ag = function (t) { + t.x0 = Math.round(t.x0), + t.y0 = Math.round(t.y0), + t.x1 = Math.round(t.x1), + t.y1 = Math.round(t.y1) + }, + Eg = function (t, n, e, r, i) { + for (var o, u = t.children, a = -1, c = u.length, s = t.value && (r - n) / t.value; ++a < c;) + o = u[a], + o.y0 = e, + o.y1 = i, + o.x0 = n, + o.x1 = n += o.value * s + }, + Cg = function () { + function t(t) { + var u = t.height + 1; + return t.x0 = t.y0 = i, + t.x1 = e, + t.y1 = r / u, + t.eachBefore(n(r, u)), + o && t.eachBefore(Ag), + t + } + function n(t, n) { + return function (e) { + e.children && Eg(e, e.x0, t * (e.depth + 1) / n, e.x1, t * (e.depth + 2) / n); + var r = e.x0, + o = e.y0, + u = e.x1 - i, + a = e.y1 - i; + u < r && (r = u = (r + u) / 2), + a < o && (o = a = (o + a) / 2), + e.x0 = r, + e.y0 = o, + e.x1 = u, + e.y1 = a + } + } + var e = 1, + r = 1, + i = 0, + o = !1; + return t.round = function (n) { + return arguments.length + ? (o = !!n, t) + : o + }, + t.size = function (n) { + return arguments.length + ? (e =+ n[0], r =+ n[1], t) + : [e, r] + }, + t.padding = function (n) { + return arguments.length + ? (i =+ n, t) + : i + }, + t + }, + zg = "$", + Pg = { + depth: -1 + }, + qg = {}, + Lg = function () { + function t(t) { + var r, + i, + o, + u, + a, + c, + s, + f = t.length, + l = new Array(f), + h = {}; + for (i = 0; i < f; ++i) + r = t[i], + a = l[i] = new Uo(r), + null != (c = n(r, i, t)) && (c += "") && (s = zg + (a.id = c), h[s] = s in h + ? qg + : a); + for (i = 0; i < f; ++i) + if (a = l[i], c = e(t[i], i, t), null != c && (c += "")) { + if (u = h[zg + c], !u) + throw new Error("missing: " + c); + if (u === qg) + throw new Error("ambiguous: " + c); + u.children + ? u + .children + .push(a) + : u.children = [a], + a.parent = u + } + else { + if (o) + throw new Error("multiple roots"); + o = a + } + if (!o) + throw new Error("no root"); + if (o.parent = Pg, o.eachBefore(function (t) { + t.depth = t.parent.depth + 1, + --f + }).eachBefore(Ro), o.parent = null, f > 0) + throw new Error("cycle"); + return o + } + var n = nu, + e = eu; + return t.id = function (e) { + return arguments.length + ? (n = Zo(e), t) + : n + }, + t.parentId = function (n) { + return arguments.length + ? (e = Zo(n), t) + : e + }, + t + }; + su.prototype = Object.create(Uo.prototype); + var Rg = function () { + function t(t) { + var r = fu(t); + if (r.eachAfter(n), r.parent.m = -r.z, r.eachBefore(e), c) + t.eachBefore(i); + else { + var s = t, + f = t, + l = t; + t.eachBefore(function (t) { + t.x < s.x && (s = t), + t.x > f.x && (f = t), + t.depth > l.depth && (l = t) + }); + var h = s === f + ? 1 + : o(s, f) / 2, + p = h - s.x, + d = u / (f.x + h + p), + v = a / (l.depth || 1); + t.eachBefore(function (t) { + t.x = (t.x + p) * d, + t.y = t.depth * v + }) + } + return t + } + function n(t) { + var n = t.children, + e = t.parent.children, + i = t.i + ? e[t.i - 1] + : null; + if (n) { + au(t); + var u = (n[0].z + n[n.length - 1].z) / 2; + i + ? (t.z = i.z + o(t._, i._), t.m = t.z - u) + : t.z = u + } else + i && (t.z = i.z + o(t._, i._)); + t.parent.A = r(t, i, t.parent.A || e[0]) + } + function e(t) { + t._.x = t.z + t.parent.m, + t.m += t.parent.m + } + function r(t, n, e) { + if (n) { + for (var r, i = t, u = t, a = n, c = i.parent.children[0], s = i.m, f = u.m, l = a.m, h = c.m; a = ou(a), i = iu(i), a && i;) + c = iu(c), + u = ou(u), + u.a = t, + r = a.z + l - i.z - s + o(a._, i._), + r > 0 && (uu(cu(a, t, e), t, r), s += r, f += r), + l += a.m, + s += i.m, + h += c.m, + f += u.m; + a && !ou(u) && (u.t = a, u.m += l - f), + i && !iu(c) && (c.t = i, c.m += s - h, e = t) + } + return e + } + function i(t) { + t.x *= u, + t.y = t.depth * a + } + var o = ru, + u = 1, + a = 1, + c = null; + return t.separation = function (n) { + return arguments.length + ? (o = n, t) + : o + }, + t.size = function (n) { + return arguments.length + ? (c = !1, u =+ n[0], a =+ n[1], t) + : c + ? null + : [u, a] + }, + t.nodeSize = function (n) { + return arguments.length + ? (c = !0, u =+ n[0], a =+ n[1], t) + : c + ? [u, a] + : null + }, + t + }, + Ug = function (t, n, e, r, i) { + for (var o, u = t.children, a = -1, c = u.length, s = t.value && (i - e) / t.value; ++a < c;) + o = u[a], + o.x0 = n, + o.x1 = r, + o.y0 = e, + o.y1 = e += o.value * s + }, + Dg = (1 + Math.sqrt(5)) / 2, + Og = function t(n) { + function e(t, e, r, i, o) { + lu(n, t, e, r, i, o) + } + return e.ratio = function (n) { + return t((n =+ n) > 1 + ? n + : 1) + }, + e + }(Dg), + Fg = function () { + function t(t) { + return t.x0 = t.y0 = 0, + t.x1 = i, + t.y1 = o, + t.eachBefore(n), + u = [0], + r && t.eachBefore(Ag), + t + } + function n(t) { + var n = u[t.depth], + r = t.x0 + n, + i = t.y0 + n, + o = t.x1 - n, + h = t.y1 - n; + o < r && (r = o = (r + o) / 2), + h < i && (i = h = (i + h) / 2), + t.x0 = r, + t.y0 = i, + t.x1 = o, + t.y1 = h, + t.children && (n = u[t.depth + 1] = a(t) / 2, r += l(t) - n, i += c(t) - n, o -= s(t) - n, h -= f(t) - n, o < r && (r = o = (r + o) / 2), h < i && (i = h = (i + h) / 2), e(t, r, i, o, h)) + } + var e = Og, + r = !1, + i = 1, + o = 1, + u = [0], + a = Go, + c = Go, + s = Go, + f = Go, + l = Go; + return t.round = function (n) { + return arguments.length + ? (r = !!n, t) + : r + }, + t.size = function (n) { + return arguments.length + ? (i =+ n[0], o =+ n[1], t) + : [i, o] + }, + t.tile = function (n) { + return arguments.length + ? (e = Zo(n), t) + : e + }, + t.padding = function (n) { + return arguments.length + ? t + .paddingInner(n) + .paddingOuter(n) + : t.paddingInner() + }, + t.paddingInner = function (n) { + return arguments.length + ? (a = "function" == typeof n + ? n + : kg(+ n), t) + : a + }, + t.paddingOuter = function (n) { + return arguments.length + ? t + .paddingTop(n) + .paddingRight(n) + .paddingBottom(n) + .paddingLeft(n) + : t.paddingTop() + }, + t.paddingTop = function (n) { + return arguments.length + ? (c = "function" == typeof n + ? n + : kg(+ n), t) + : c + }, + t.paddingRight = function (n) { + return arguments.length + ? (s = "function" == typeof n + ? n + : kg(+ n), t) + : s + }, + t.paddingBottom = function (n) { + return arguments.length + ? (f = "function" == typeof n + ? n + : kg(+ n), t) + : f + }, + t.paddingLeft = function (n) { + return arguments.length + ? (l = "function" == typeof n + ? n + : kg(+ n), t) + : l + }, + t + }, + Ig = function (t, n, e, r, i) { + function o(t, n, e, r, i, u, a) { + if (t >= n - 1) { + var s = c[t]; + return s.x0 = r, + s.y0 = i, + s.x1 = u, + s.y1 = a, + void 0 + } + for (var l = f[t], h = e / 2 + l, p = t + 1, d = n - 1; p < d;) { + var v = p + d >>> 1; + f[v] < h + ? p = v + 1 + : d = v + } + var _ = f[p] - l, + y = e - _; + if (a - i > u - r) { + var g = (i * y + a * _) / e; + o(t, p, _, r, i, u, g), + o(p, n, y, r, g, u, a) + } else { + var m = (r * y + u * _) / e; + o(t, p, _, r, i, m, a), + o(p, n, y, m, i, u, a) + } + } + var u, + a, + c = t.children, + s = c.length, + f = new Array(s + 1); + for (f[0] = a = u = 0; u < s; ++u) + f[u + 1] = a += c[u].value; + o(0, s, t.value, n, e, r, i) + }, + Yg = function (t, n, e, r, i) { + (1 & t.depth + ? Ug + : Eg)(t, n, e, r, i) + }, + Bg = function t(n) { + function e(t, e, r, i, o) { + if ((u = t._squarify) && u.ratio === n) + for (var u, a, c, s, f, l = -1, h = u.length, p = t.value; ++l < h;) { + for (a = u[l], c = a.children, s = a.value = 0, f = c.length; s < f; ++s) + a.value += c[s].value; + a.dice + ? Eg(a, e, r, i, r += (o - r) * a.value / p) + : Ug(a, e, r, e += (i - e) * a.value / p, o), + p -= a.value + } + else + t._squarify = u = lu(n, t, e, r, i, o), + u.ratio = n + } + return e.ratio = function (n) { + return t((n =+ n) > 1 + ? n + : 1) + }, + e + }(Dg), + jg = function (t, n) { + function e() { + var e, + i, + o = r.length, + u = 0, + a = 0; + for (e = 0; e < o; ++e) + i = r[e], + u += i.x, + a += i.y; + for (u = u / o - t, a = a / o - n, e = 0; e < o; ++e) + i = r[e], + i.x -= u, + i.y -= a + } + var r; + return null == t && (t = 0), + null == n && (n = 0), + e.initialize = function (t) { + r = t + }, + e.x = function (n) { + return arguments.length + ? (t =+ n, e) + : t + }, + e.y = function (t) { + return arguments.length + ? (n =+ t, e) + : n + }, + e + }, + Hg = function (t) { + return function () { + return t + } + }, + Xg = function () { + return 1e-6 * (Math.random() - .5) + }, + Vg = function (t) { + function n() { + function t(t, e, r, i, o) { + var a = t.data, + p = t.r, + d = l + p; + { + if (!a) + return e > s + d || i < s - d || r > f + d || o < f - d; + if (a.index > n) { + var v = s - a.x - a.vx, + _ = f - a.y - a.vy, + y = v * v + _ * _; + y < d * d && (0 === v && (v = Xg(), y += v * v), 0 === _ && (_ = Xg(), y += _ * _), y = (d - (y = Math.sqrt(y))) / y * u, c.vx += (v *= y) * (d = (p *= p) / (h + p)), c.vy += (_ *= y) * d, a.vx -= v * (d = 1 - d), a.vy -= _ * d) + } + } + } + for (var n, r, c, s, f, l, h, p = i.length, d = 0; d < a; ++d) + for (r = I(i, hu, pu).visitAfter(e), n = 0; n < p; ++n) + c = i[n], + l = o[n], + h = l * l, + s = c.x + c.vx, + f = c.y + c.vy, + r.visit(t) + } + function e(t) { + if (t.data) + return t.r = o[t.data.index]; + for (var n = t.r = 0; n < 4; ++n) + t[n] && t[n].r > t.r && (t.r = t[n].r) + } + function r() { + if (i) { + var n, + e = i.length; + for (o = new Array(e), n = 0; n < e; ++n) + o[n] =+ t(i[n], n, i) + } + } + var i, + o, + u = 1, + a = 1; + return "function" != typeof t && (t = Hg(null == t + ? 1 :+ t)), + n.initialize = function (t) { + i = t, + r() + }, + n.iterations = function (t) { + return arguments.length + ? (a =+ t, n) + : a + }, + n.strength = function (t) { + return arguments.length + ? (u =+ t, n) + : u + }, + n.radius = function (e) { + return arguments.length + ? (t = "function" == typeof e + ? e + : Hg(+ e), r(), n) + : t + }, + n + }, + Wg = function (t) { + function n(t) { + return 1 / Math.min(f[t.source.index], f[t.target.index]) + } + function e(n) { + for (var e = 0, r = t.length; e < v; ++e) + for (var i, o, u, s, f, h, p, d = 0; d < r; ++d) + i = t[d], + o = i.source, + u = i.target, + s = u.x + u.vx - o.x - o.vx || Xg(), + f = u.y + u.vy - o.y - o.vy || Xg(), + h = Math.sqrt(s * s + f * f), + h = (h - c[d]) / h * n * a[d], + s *= h, + f *= h, + u.vx -= s * (p = l[d]), + u.vy -= f * p, + o.vx += s * (p = 1 - p), + o.vy += f * p + } + function r() { + if (s) { + var n, + e, + r = s.length, + p = t.length, + d = o(s, h); + for (n = 0, f = new Array(r); n < r; ++n) + f[n] = 0; + for (n = 0; n < p; ++n) + e = t[n], + e.index = n, + "object" != typeof e.source && (e.source = vu(d, e.source)), + "object" != typeof e.target && (e.target = vu(d, e.target)), + ++f[e.source.index], + ++f[e.target.index]; + for (n = 0, l = new Array(p); n < p; ++n) + e = t[n], + l[n] = f[e.source.index] / (f[e.source.index] + f[e.target.index]); + a = new Array(p), + i(), + c = new Array(p), + u() + } + } + function i() { + if (s) + for (var n = 0, e = t.length; n < e; ++n) + a[n] =+ p(t[n], n, t) + } + function u() { + if (s) + for (var n = 0, e = t.length; n < e; ++n) + c[n] =+ d(t[n], n, t) + } + var a, + c, + s, + f, + l, + h = du, + p = n, + d = Hg(30), + v = 1; + return null == t && (t = []), + e.initialize = function (t) { + s = t, + r() + }, + e.links = function (n) { + return arguments.length + ? (t = n, r(), e) + : t + }, + e.id = function (t) { + return arguments.length + ? (h = t, e) + : h + }, + e.iterations = function (t) { + return arguments.length + ? (v =+ t, e) + : v + }, + e.strength = function (t) { + return arguments.length + ? (p = "function" == typeof t + ? t + : Hg(+ t), i(), e) + : p + }, + e.distance = function (t) { + return arguments.length + ? (d = "function" == typeof t + ? t + : Hg(+ t), u(), e) + : d + }, + e + }, + $g = 10, + Zg = Math.PI * (3 - Math.sqrt(5)), + Gg = function (t) { + function n() { + e(), + d.call("tick", u), + a < c && (p.stop(), d.call("end", u)) + } + function e() { + var n, + e, + r = t.length; + for (a += (f - a) * s, h.each(function (t) { + t(a) + }), n = 0; n < r; ++n) + e = t[n], + null == e.fx + ? e.x += e.vx *= l + : (e.x = e.fx, e.vx = 0), + null == e.fy + ? e.y += e.vy *= l + : (e.y = e.fy, e.vy = 0) + } + function r() { + for (var n, e = 0, r = t.length; e < r; ++e) { + if (n = t[e], n.index = e, isNaN(n.x) || isNaN(n.y)) { + var i = $g * Math.sqrt(e), + o = e * Zg; + n.x = i * Math.cos(o), + n.y = i * Math.sin(o) + } + (isNaN(n.vx) || isNaN(n.vy)) && (n.vx = n.vy = 0) + } + } + function i(n) { + return n.initialize && n.initialize(t), + n + } + var u, + a = 1, + c = .001, + s = 1 - Math.pow(c, 1 / 300), + f = 0, + l = .6, + h = o(), + p = Vn(n), + d = Pn("tick", "end"); + return null == t && (t = []), + r(), + u = { + tick: e, + restart: function () { + return p.restart(n), + u + }, + stop: function () { + return p.stop(), + u + }, + nodes: function (n) { + return arguments.length + ? (t = n, r(), h.each(i), u) + : t + }, + alpha: function (t) { + return arguments.length + ? (a =+ t, u) + : a + }, + alphaMin: function (t) { + return arguments.length + ? (c =+ t, u) + : c + }, + alphaDecay: function (t) { + return arguments.length + ? (s =+ t, u) :+ s + }, + alphaTarget: function (t) { + return arguments.length + ? (f =+ t, u) + : f + }, + velocityDecay: function (t) { + return arguments.length + ? (l = 1 - t, u) + : 1 - l + }, + force: function (t, n) { + return arguments.length > 1 + ? (null == n + ? h.remove(t) + : h.set(t, i(n)), u) + : h.get(t) + }, + find: function (n, e, r) { + var i, + o, + u, + a, + c, + s = 0, + f = t.length; + for (null == r + ? r = 1 / 0 + : r *= r, s = 0; s < f; ++s) + a = t[s], + i = n - a.x, + o = e - a.y, + u = i * i + o * o, + u < r && (c = a, r = u); + return c + }, + on: function (t, n) { + return arguments.length > 1 + ? (d.on(t, n), u) + : d.on(t) + } + } + }, + Jg = function () { + function t(t) { + var n, + a = i.length, + c = I(i, _u, yu).visitAfter(e); + for (u = t, n = 0; n < a; ++n) + o = i[n], + c.visit(r) + } + function n() { + if (i) { + var t, + n = i.length; + for (a = new Array(n), t = 0; t < n; ++t) + a[t] =+ c(i[t], t, i) + } + } + function e(t) { + var n, + e, + r, + i, + o, + u = 0; + if (t.length) { + for (r = i = o = 0; o < 4; ++o) + (n = t[o]) && (e = n.value) && (u += e, r += e * n.x, i += e * n.y); + t.x = r / u, + t.y = i / u + } else { + n = t, + n.x = n.data.x, + n.y = n.data.y; + do + u += a[n.data.index]; + while (n = n.next) + } + t.value = u + } + function r(t, n, e, r) { + if (!t.value) + return !0; + var i = t.x - o.x, + c = t.y - o.y, + h = r - n, + p = i * i + c * c; + if (h * h / l < p) + return p < f && (0 === i && (i = Xg(), p += i * i), 0 === c && (c = Xg(), p += c * c), p < s && (p = Math.sqrt(s * p)), o.vx += i * t.value * u / p, o.vy += c * t.value * u / p), + !0; + if (!(t.length || p >= f)) { + (t.data !== o || t.next) && (0 === i && (i = Xg(), p += i * i), 0 === c && (c = Xg(), p += c * c), p < s && (p = Math.sqrt(s * p))); + do + t.data !== o && (h = a[t.data.index] * u / p, o.vx += i * h, o.vy += c * h); + while (t = t.next) + } + } + var i, + o, + u, + a, + c = Hg(-30), + s = 1, + f = 1 / 0, + l = .81; + return t.initialize = function (t) { + i = t, + n() + }, + t.strength = function (e) { + return arguments.length + ? (c = "function" == typeof e + ? e + : Hg(+ e), n(), t) + : c + }, + t.distanceMin = function (n) { + return arguments.length + ? (s = n * n, t) + : Math.sqrt(s) + }, + t.distanceMax = function (n) { + return arguments.length + ? (f = n * n, t) + : Math.sqrt(f) + }, + t.theta = function (n) { + return arguments.length + ? (l = n * n, t) + : Math.sqrt(l) + }, + t + }, + Qg = function (t) { + function n(t) { + for (var n, e = 0, u = r.length; e < u; ++e) + n = r[e], + n.vx += (o[e] - n.x) * i[e] * t + } + function e() { + if (r) { + var n, + e = r.length; + for (i = new Array(e), o = new Array(e), n = 0; n < e; ++n) + i[n] = isNaN(o[n] =+ t(r[n], n, r)) + ? 0 :+ u(r[n], n, r) + } + } + var r, + i, + o, + u = Hg(.1); + return "function" != typeof t && (t = Hg(null == t + ? 0 :+ t)), + n.initialize = function (t) { + r = t, + e() + }, + n.strength = function (t) { + return arguments.length + ? (u = "function" == typeof t + ? t + : Hg(+ t), e(), n) + : u + }, + n.x = function (r) { + return arguments.length + ? (t = "function" == typeof r + ? r + : Hg(+ r), e(), n) + : t + }, + n + }, + Kg = function (t) { + function n(t) { + for (var n, e = 0, u = r.length; e < u; ++e) + n = r[e], + n.vy += (o[e] - n.y) * i[e] * t + } + function e() { + if (r) { + var n, + e = r.length; + for (i = new Array(e), o = new Array(e), n = 0; n < e; ++n) + i[n] = isNaN(o[n] =+ t(r[n], n, r)) + ? 0 :+ u(r[n], n, r) + } + } + var r, + i, + o, + u = Hg(.1); + return "function" != typeof t && (t = Hg(null == t + ? 0 :+ t)), + n.initialize = function (t) { + r = t, + e() + }, + n.strength = function (t) { + return arguments.length + ? (u = "function" == typeof t + ? t + : Hg(+ t), e(), n) + : u + }, + n.y = function (r) { + return arguments.length + ? (t = "function" == typeof r + ? r + : Hg(+ r), e(), n) + : t + }, + n + }, + tm = function () { + t + .event + .preventDefault(), + t + .event + .stopImmediatePropagation() + }, + nm = function (t) { + var n = t.document.documentElement, + e = gy(t).on("dragstart.drag", tm, !0); + "onselectstart" in n + ? e.on("selectstart.drag", tm, !0) + : (n.__noselect = n.style.MozUserSelect, n.style.MozUserSelect = "none") + }, + em = function (t) { + return function () { + return t + } + }; + xu.prototype.on = function () { + var t = this + ._ + .on + .apply(this._, arguments); + return t === this._ + ? this + : t + }; + var rm = function () { + function n(t) { + t + .on("mousedown.drag", e) + .on("touchstart.drag", o) + .on("touchmove.drag", u) + .on("touchend.drag touchcancel.drag", a) + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") + } + function e() { + if (!f && l.apply(this, arguments)) { + var n = c("mouse", h.apply(this, arguments), U_, this, arguments); + n && (gy(t.event.view).on("mousemove.drag", r, !0).on("mouseup.drag", i, !0), nm(t.event.view), gu(), s = !1, n("start")) + } + } + function r() { + tm(), + s = !0, + d.mouse("drag") + } + function i() { + gy(t.event.view).on("mousemove.drag mouseup.drag", null), + mu(t.event.view, s), + tm(), + d.mouse("end") + } + function o() { + if (l.apply(this, arguments)) { + var n, + e, + r = t.event.changedTouches, + i = h.apply(this, arguments), + o = r.length; + for (n = 0; n < o; ++n) + (e = c(r[n].identifier, i, xy, this, arguments)) && (gu(), e("start")) + } + } + function u() { + var n, + e, + r = t.event.changedTouches, + i = r.length; + for (n = 0; n < i; ++n) + (e = d[r[n].identifier]) && (tm(), e("drag")) + } + function a() { + var n, + e, + r = t.event.changedTouches, + i = r.length; + for (f && clearTimeout(f), f = setTimeout(function () { + f = null + }, 500), n = 0; n < i; ++n) + (e = d[r[n].identifier]) && (gu(), e("end")) + } + function c(e, r, i, o, u) { + var a, + c, + s, + f = i(r, e), + l = v.copy(); + if (Xr(new xu(n, "beforestart", a, e, _, f[0], f[1], 0, 0, l), function () { + return null != (t.event.subject = a = p.apply(o, u)) && (c = a.x - f[0] || 0, s = a.y - f[1] || 0, !0) + })) + return function t(h) { + var p, + v = f; + switch (h) { + case "start": + d[e] = t, + p = _++; + break; + case "end": + delete d[e], + --_; + case "drag": + f = i(r, e), + p = _ + } + Xr(new xu(n, h, a, e, p, f[0] + c, f[1] + s, f[0] - v[0], f[1] - v[1], l), l.apply, l, [h, o, u]) + } + } + var s, + f, + l = bu, + h = wu, + p = Mu, + d = {}, + v = Pn("start", "drag", "end"), + _ = 0; + return n.filter = function (t) { + return arguments.length + ? (l = "function" == typeof t + ? t + : em(!!t), n) + : l + }, + n.container = function (t) { + return arguments.length + ? (h = "function" == typeof t + ? t + : em(t), n) + : h + }, + n.subject = function (t) { + return arguments.length + ? (p = "function" == typeof t + ? t + : em(t), n) + : p + }, + n.on = function () { + var t = v + .on + .apply(v, arguments); + return t === v + ? n + : t + }, + n + }, + im = function (t) { + return function () { + return t + } + }; + ku.prototype = { + constructor: ku, + insert: function (t, n) { + var e, + r, + i; + if (t) { + if (n.P = t, n.N = t.N, t.N && (t.N.P = n), t.N = n, t.R) { + for (t = t.R; t.L;) + t = t.L; + t.L = n + } else + t.R = n; + e = t + } else + this._ + ? (t = Cu(this._), n.P = null, n.N = t, t.P = t.L = n, e = t) + : (n.P = n.N = null, this._ = n, e = null); + for (n.L = n.R = null, n.U = e, n.C = !0, t = n; e && e.C;) + r = e.U, + e === r.L + ? (i = r.R, i && i.C + ? (e.C = i.C = !1, r.C = !0, t = r) + : (t === e.R && (Au(this, e), t = e, e = t.U), e.C = !1, r.C = !0, Eu(this, r))) + : (i = r.L, i && i.C + ? (e.C = i.C = !1, r.C = !0, t = r) + : (t === e.L && (Eu(this, e), t = e, e = t.U), e.C = !1, r.C = !0, Au(this, r))), + e = t.U; + this._.C = !1 + }, + remove: function (t) { + t.N && (t.N.P = t.P), + t.P && (t.P.N = t.N), + t.N = t.P = null; + var n, + e, + r, + i = t.U, + o = t.L, + u = t.R; + if (e = o + ? u + ? Cu(u) + : o + : u, i + ? i.L === t + ? i.L = e + : i.R = e + : this._ = e, o && u + ? (r = e.C, e.C = t.C, e.L = o, o.U = e, e !== u + ? (i = e.U, e.U = t.U, t = e.R, i.L = t, e.R = u, u.U = e) + : (e.U = i, i = e, t = e.R)) + : (r = t.C, t = e), t && (t.U = i), !r) { + if (t && t.C) + return void(t.C = !1); + do { + if (t === this._) + break; + if (t === i.L) { + if (n = i.R, n.C && (n.C = !1, i.C = !0, Au(this, i), n = i.R), n.L && n.L.C || n.R && n.R.C) { + n.R && n.R.C || (n.L.C = !1, n.C = !0, Eu(this, n), n = i.R), + n.C = i.C, + i.C = n.R.C = !1, + Au(this, i), + t = this._; + break + } + } else if (n = i.L, n.C && (n.C = !1, i.C = !0, Eu(this, i), n = i.L), n.L && n.L.C || n.R && n.R.C) { + n.L && n.L.C || (n.R.C = !1, n.C = !0, Au(this, n), n = i.L), + n.C = i.C, + i.C = n.L.C = !1, + Eu(this, i), + t = this._; + break + } + n.C = !0, + t = i, + i = i.U + } while (!t.C); + t && (t.C = !1) + } + } + }; + var om, + um, + am, + cm, + sm, + fm = [], + lm = [], + hm = 1e-6, + pm = 1e-12; + na.prototype = { + constructor: na, + polygons: function () { + var t = this.edges; + return this + .cells + .map(function (n) { + var e = n + .halfedges + .map(function (e) { + return Fu(n, t[e]) + }); + return e.data = n.site.data, + e + }) + }, + triangles: function () { + var t = [], + n = this.edges; + return this + .cells + .forEach(function (e, r) { + for (var i, o = e.site, u = e.halfedges, a = -1, c = u.length, s = n[u[c - 1]], f = s.left === o + ? s.right + : s.left; ++a < c;) + i = f, + s = n[u[a]], + f = s.left === o + ? s.right + : s.left, + i && f && r < i.index && r < f.index && Ku(o, i, f) < 0 && t.push([o.data, i.data, f.data]) + }), + t + }, + links: function () { + return this + .edges + .filter(function (t) { + return t.right + }) + .map(function (t) { + return {source: t.left.data, target: t.right.data} + }) + }, + find: function (t, n, e) { + var r, + i = this, + o = i._found || 0, + u = i.cells[o] || i.cells[o = 0], + a = t - u.site[0], + c = n - u.site[1], + s = a * a + c * c; + do + u = i.cells[r = o], + o = null, + u + .halfedges + .forEach(function (e) { + var r = i.edges[e], + a = r.left; + if (a !== u.site && a || (a = r.right)) { + var c = t - a[0], + f = n - a[1], + l = c * c + f * f; + l < s && (s = l, o = a.index) + } + }); + while (null !== o); + return i._found = r, + null == e || s <= e * e + ? u.site + : null + } + }; + var dm = function () { + function t(t) { + return new na(t.map(function (r, i) { + var o = [ + Math.round(n(r, i, t) / hm) * hm, + Math.round(e(r, i, t) / hm) * hm + ]; + return o.index = i, + o.data = r, + o + }), r) + } + var n = Tu, + e = Nu, + r = null; + return t.polygons = function (n) { + return t(n).polygons() + }, + t.links = function (n) { + return t(n).links() + }, + t.triangles = function (n) { + return t(n).triangles() + }, + t.x = function (e) { + return arguments.length + ? (n = "function" == typeof e + ? e + : im(+ e), t) + : n + }, + t.y = function (n) { + return arguments.length + ? (e = "function" == typeof n + ? n + : im(+ n), t) + : e + }, + t.extent = function (n) { + return arguments.length + ? (r = null == n + ? null + : [ + [ + n[0][0], + n[0][1] + ], + [ + n[1][0], + n[1][1] + ] + ], t) + : r && [ + [r[0][0], r[0][1] + ], + [r[1][0], r[1][1] + ] + ] + }, + t.size = function (n) { + return arguments.length + ? (r = null == n + ? null + : [ + [ + 0, 0 + ], + [ + n[0], + n[1] + ] + ], t) + : r && [r[1][0] - r[0][0], + r[1][1] - r[0][1] + ] + }, + t + }, + vm = function (t) { + return function () { + return t + } + }; + ra.prototype = { + constructor: ra, + scale: function (t) { + return 1 === t + ? this + : new ra(this.k * t, this.x, this.y) + }, + translate: function (t, n) { + return 0 === t & 0 === n + ? this + : new ra(this.k, this.x + this.k * t, this.y + this.k * n) + }, + apply: function (t) { + return [ + t[0] * this.k + this.x, + t[1] * this.k + this.y + ] + }, + applyX: function (t) { + return t * this.k + this.x + }, + applyY: function (t) { + return t * this.k + this.y + }, + invert: function (t) { + return [ + (t[0] - this.x) / this.k, + (t[1] - this.y) / this.k + ] + }, + invertX: function (t) { + return (t - this.x) / this.k + }, + invertY: function (t) { + return (t - this.y) / this.k + }, + rescaleX: function (t) { + return t + .copy() + .domain(t.range().map(this.invertX, this).map(t.invert, t)) + }, + rescaleY: function (t) { + return t + .copy() + .domain(t.range().map(this.invertY, this).map(t.invert, t)) + }, + toString: function () { + return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")" + } + }; + var _m = new ra(1, 0, 0); + ia.prototype = ra.prototype; + var ym = function () { + t + .event + .preventDefault(), + t + .event + .stopImmediatePropagation() + }, + gm = function () { + function n(t) { + t + .on("wheel.zoom", s) + .on("mousedown.zoom", f) + .on("dblclick.zoom", l) + .on("touchstart.zoom", h) + .on("touchmove.zoom", p) + .on("touchend.zoom touchcancel.zoom", d) + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") + .property("__zoom", ca) + } + function e(t, n) { + return n = Math.max(m, Math.min(x, n)), + n === t.k + ? t + : new ra(n, t.x, t.y) + } + function r(t, n, e) { + var r = n[0] - e[0] * t.k, + i = n[1] - e[1] * t.k; + return r === t.x && i === t.y + ? t + : new ra(t.k, r, i) + } + function i(t, n) { + var e = Math.min(0, t.invertX(n[0][0]) - b) || Math.max(0, t.invertX(n[1][0]) - w), + r = Math.min(0, t.invertY(n[0][1]) - M) || Math.max(0, t.invertY(n[1][1]) - T); + return e || r + ? t.translate(e, r) + : t + } + function o(t) { + return [ + ( + t[0][0] + + t[1][0]) / 2, + ( + t[0][1] + + t[1][1]) / 2 + ] + } + function u(t, n, e) { + t + .on("start.zoom", function () { + a(this, arguments).start() + }) + .on("interrupt.zoom end.zoom", function () { + a(this, arguments).end() + }) + .tween("zoom", function () { + var t = this, + r = arguments, + i = a(t, r), + u = g.apply(t, r), + c = e || o(u), + s = Math.max(u[1][0] - u[0][0], u[1][1] - u[0][1]), + f = t.__zoom, + l = "function" == typeof n + ? n.apply(t, r) + : n, + h = Sp(f.invert(c).concat(s / f.k), l.invert(c).concat(s / l.k)); + return function (t) { + if (1 === t) + t = l; + else { + var n = h(t), + e = s / n[2]; + t = new ra(e, c[0] - n[0] * e, c[1] - n[1] * e) + } + i.zoom(null, t) + } + }) + } + function a(t, n) { + for (var e, r = 0, i = k.length; r < i; ++r) + if ((e = k[r]).that === t) + return e; + return new c(t, n) + } + function c(t, n) { + this.that = t, + this.args = n, + this.index = -1, + this.active = 0, + this.extent = g.apply(t, n) + } + function s() { + function n() { + o.wheel = null, + o.end() + } + if (y.apply(this, arguments)) { + var o = a(this, arguments), + u = this.__zoom, + c = Math.max(m, Math.min(x, u.k * Math.pow(2, -t.event.deltaY * (t.event.deltaMode + ? 120 + : 1) / 500))), + s = U_(this); + if (o.wheel) + o.mouse[0][0] === s[0] && o.mouse[0][1] === s[1] || (o.mouse[1] = u.invert(o.mouse[0] = s)), + clearTimeout(o.wheel); + else { + if (u.k === c) + return; + o.mouse = [ + s, u.invert(s) + ], + Py(this), + o.start() + } + ym(), + o.wheel = setTimeout(n, E), + o.zoom("mouse", i(r(e(u, c), o.mouse[0], o.mouse[1]), o.extent)) + } + } + function f() { + function n() { + ym(), + o.moved = !0, + o.zoom("mouse", i(r(o.that.__zoom, o.mouse[0] = U_(o.that), o.mouse[1]), o.extent)) + } + function e() { + u.on("mousemove.zoom mouseup.zoom", null), + mu(t.event.view, o.moved), + ym(), + o.end() + } + if (!_ && y.apply(this, arguments)) { + var o = a(this, arguments), + u = gy(t.event.view) + .on("mousemove.zoom", n, !0) + .on("mouseup.zoom", e, !0), + c = U_(this); + nm(t.event.view), + oa(), + o.mouse = [ + c, + this + .__zoom + .invert(c) + ], + Py(this), + o.start() + } + } + function l() { + if (y.apply(this, arguments)) { + var o = this.__zoom, + a = U_(this), + c = o.invert(a), + s = o.k * (t.event.shiftKey + ? .5 + : 2), + f = i(r(e(o, s), a, c), g.apply(this, arguments)); + ym(), + N > 0 + ? gy(this) + .transition() + .duration(N) + .call(u, f, a) + : gy(this).call(n.transform, f) + } + } + function h() { + if (y.apply(this, arguments)) { + var n, + e, + r, + i = a(this, arguments), + o = t.event.changedTouches, + u = o.length; + for (oa(), n = 0; n < u; ++n) + e = o[n], + r = xy(this, o, e.identifier), + r = [ + r, + this + .__zoom + .invert(r), + e.identifier + ], + i.touch0 + ? i.touch1 || (i.touch1 = r) + : i.touch0 = r; + return v && (v = clearTimeout(v), !i.touch1) + ? (i.end(), l.apply(this, arguments)) + : void(t.event.touches.length === u && (v = setTimeout(function () { + v = null + }, A), Py(this), i.start())) + } + } + function p() { + var n, + o, + u, + c, + s = a(this, arguments), + f = t.event.changedTouches, + l = f.length; + for (ym(), v && (v = clearTimeout(v)), n = 0; n < l; ++n) + o = f[n], + u = xy(this, f, o.identifier), + s.touch0 && s.touch0[2] === o.identifier + ? s.touch0[0] = u + : s.touch1 && s.touch1[2] === o.identifier && (s.touch1[0] = u); + if (o = s.that.__zoom, s.touch1) { + var h = s.touch0[0], + p = s.touch0[1], + d = s.touch1[0], + _ = s.touch1[1], + y = (y = d[0] - h[0]) * y + (y = d[1] - h[1]) * y, + g = (g = _[0] - p[0]) * g + (g = _[1] - p[1]) * g; + o = e(o, Math.sqrt(y / g)), + u = [ + (h[0] + d[0]) / 2, + (h[1] + d[1]) / 2 + ], + c = [ + (p[0] + _[0]) / 2, + (p[1] + _[1]) / 2 + ] + } else { + if (!s.touch0) + return; + u = s.touch0[0], + c = s.touch0[1] + } + s.zoom("touch", i(r(o, u, c), s.extent)) + } + function d() { + var n, + e, + r = a(this, arguments), + i = t.event.changedTouches, + o = i.length; + for (oa(), _ && clearTimeout(_), _ = setTimeout(function () { + _ = null + }, A), n = 0; n < o; ++n) + e = i[n], + r.touch0 && r.touch0[2] === e.identifier + ? delete r.touch0 + : r.touch1 && r.touch1[2] === e.identifier && delete r.touch1; + r.touch1 && !r.touch0 && (r.touch0 = r.touch1, delete r.touch1), + r.touch0 || r.end() + } + var v, + _, + y = ua, + g = aa, + m = 0, + x = 1 / 0, + b = -x, + w = x, + M = b, + T = w, + N = 250, + k = [], + S = Pn("start", "zoom", "end"), + A = 500, + E = 150; + return n.transform = function (t, n) { + var e = t.selection + ? t.selection() + : t; + e.property("__zoom", ca), + t !== e + ? u(t, n) + : e + .interrupt() + .each(function () { + a(this, arguments) + .start() + .zoom(null, "function" == typeof n + ? n.apply(this, arguments) + : n) + .end() + }) + }, + n.scaleBy = function (t, e) { + n + .scaleTo(t, function () { + var t = this.__zoom.k, + n = "function" == typeof e + ? e.apply(this, arguments) + : e; + return t * n + }) + }, + n.scaleTo = function (t, u) { + n + .transform(t, function () { + var t = g.apply(this, arguments), + n = this.__zoom, + a = o(t), + c = n.invert(a), + s = "function" == typeof u + ? u.apply(this, arguments) + : u; + return i(r(e(n, s), a, c), t) + }) + }, + n.translateBy = function (t, e, r) { + n + .transform(t, function () { + return i(this.__zoom.translate("function" == typeof e + ? e.apply(this, arguments) + : e, "function" == typeof r + ? r.apply(this, arguments) + : r), g.apply(this, arguments)) + }) + }, + c.prototype = { + start: function () { + return 1 === ++this.active && (this.index = k.push(this) - 1, this.emit("start")), + this + }, + zoom: function (t, n) { + return this.mouse && "mouse" !== t && (this.mouse[1] = n.invert(this.mouse[0])), + this.touch0 && "touch" !== t && (this.touch0[1] = n.invert(this.touch0[0])), + this.touch1 && "touch" !== t && (this.touch1[1] = n.invert(this.touch1[0])), + this.that.__zoom = n, + this.emit("zoom"), + this + }, + end: function () { + return 0 === --this.active && (k.splice(this.index, 1), this.index = -1, this.emit("end")), + this + }, + emit: function (t) { + Xr(new ea(n, t, this.that.__zoom), S.apply, S, [t, this.that, this.args]) + } + }, + n.filter = function (t) { + return arguments.length + ? (y = "function" == typeof t + ? t + : vm(!!t), n) + : y + }, + n.extent = function (t) { + return arguments.length + ? (g = "function" == typeof t + ? t + : vm([ + [ + t[0][0], + t[0][1] + ], + [ + t[1][0], + t[1][1] + ] + ]), n) + : g + }, + n.scaleExtent = function (t) { + return arguments.length + ? (m =+ t[0], x =+ t[1], n) + : [m, x] + }, + n.translateExtent = function (t) { + return arguments.length + ? (b =+ t[0][0], w =+ t[1][0], M =+ t[0][1], T =+ t[1][1], n) + : [ + [ + b, M + ], + [w, T] + ] + }, + n.duration = function (t) { + return arguments.length + ? (N =+ t, n) + : N + }, + n.on = function () { + var t = S + .on + .apply(S, arguments); + return t === S + ? n + : t + }, + n + }, + mm = function (t) { + return function () { + return t + } + }, + xm = function (t, n, e) { + this.target = t, + this.type = n, + this.selection = e + }, + bm = function () { + t + .event + .preventDefault(), + t + .event + .stopImmediatePropagation() + }, + wm = { + name: "drag" + }, + Mm = { + name: "space" + }, + Tm = { + name: "handle" + }, + Nm = { + name: "center" + }, + km = { + name: "x", + handles: ["e", "w"].map(fa), + input: function (t, n) { + return t && [ + [t[0], n[0][1] + ], + [t[1], n[1][1] + ] + ] + }, + output: function (t) { + return t && [t[0][0], t[1][0] + ] + } + }, + Sm = { + name: "y", + handles: ["n", "s"].map(fa), + input: function (t, n) { + return t && [ + [ + n[0][0], t[0] + ], + [n[1][0], t[1]] + ] + }, + output: function (t) { + return t && [t[0][1], t[1][1] + ] + } + }, + Am = { + name: "xy", + handles: [ + "n", + "e", + "s", + "w", + "nw", + "ne", + "se", + "sw" + ].map(fa), + input: function (t) { + return t + }, + output: function (t) { + return t + } + }, + Em = { + overlay: "crosshair", + selection: "move", + n: "ns-resize", + e: "ew-resize", + s: "ns-resize", + w: "ew-resize", + nw: "nwse-resize", + ne: "nesw-resize", + se: "nwse-resize", + sw: "nesw-resize" + }, + Cm = { + e: "w", + w: "e", + nw: "ne", + ne: "nw", + se: "sw", + sw: "se" + }, + zm = { + n: "s", + s: "n", + nw: "sw", + ne: "se", + se: "ne", + sw: "nw" + }, + Pm = { + overlay: 1, + selection: 1, + n: null, + e: 1, + s: null, + w: -1, + nw: -1, + ne: 1, + se: 1, + sw: -1 + }, + qm = { + overlay: 1, + selection: 1, + n: -1, + e: null, + s: 1, + w: null, + nw: -1, + ne: -1, + se: 1, + sw: 1 + }, + Lm = function () { + return ga(Am) + }, + Rm = Math.cos, + Um = Math.sin, + Dm = Math.PI, + Om = Dm / 2, + Fm = 2 * Dm, + Im = Math.max, + Ym = function () { + function t(t) { + var o, + u, + a, + c, + s, + f, + l = t.length, + h = [], + p = Os(l), + d = [], + v = [], + _ = v.groups = new Array(l), + y = new Array(l * l); + for (o = 0, s = -1; ++s < l;) { + for (u = 0, f = -1; ++f < l;) + u += t[s][f]; + h.push(u), + d.push(Os(l)), + o += u + } + for (e && p.sort(function (t, n) { + return e(h[t], h[n]) + }), r && d.forEach(function (n, e) { + n + .sort(function (n, i) { + return r(t[e][n], t[e][i]) + }) + }), o = Im(0, Fm - n * l) / o, c = o + ? n + : Fm / l, u = 0, s = -1; ++s < l;) { + for (a = u, f = -1; ++f < l;) { + var g = p[s], + m = d[g][f], + x = t[g][m], + b = u, + w = u += x * o; + y[m * l + g] = { + index: g, + subindex: m, + startAngle: b, + endAngle: w, + value: x + } + } + _[g] = { + index: g, + startAngle: a, + endAngle: u, + value: h[g] + }, + u += c + } + for (s = -1; ++s < l;) + for (f = s - 1; ++f < l;) { + var M = y[f * l + s], + T = y[s * l + f]; + (M.value || T.value) && v.push(M.value < T.value + ? { + source: T, + target: M + } + : { + source: M, + target: T + }) + } + return i + ? v.sort(i) + : v + } + var n = 0, + e = null, + r = null, + i = null; + return t.padAngle = function (e) { + return arguments.length + ? (n = Im(0, e), t) + : n + }, + t.sortGroups = function (n) { + return arguments.length + ? (e = n, t) + : e + }, + t.sortSubgroups = function (n) { + return arguments.length + ? (r = n, t) + : r + }, + t.sortChords = function (n) { + return arguments.length + ? (null == n + ? i = null + : (i = ma(n))._ = n, t) + : i && i._ + }, + t + }, + Bm = Array.prototype.slice, + jm = function (t) { + return function () { + return t + } + }, + Hm = function () { + function t() { + var t, + a = Bm.call(arguments), + c = n.apply(this, a), + s = e.apply(this, a), + f =+ r.apply(this, (a[0] = c, a)), + l = i.apply(this, a) - Om, + h = o.apply(this, a) - Om, + p = f * Rm(l), + d = f * Um(l), + v =+ r.apply(this, (a[0] = s, a)), + _ = i.apply(this, a) - Om, + y = o.apply(this, a) - Om; + if (u || (u = t = L()), u.moveTo(p, d), u.arc(0, 0, f, l, h), l === _ && h === y || (u.quadraticCurveTo(0, 0, v * Rm(_), v * Um(_)), u.arc(0, 0, v, _, y)), u.quadraticCurveTo(0, 0, p, d), u.closePath(), t) + return u = null, + t + "" || null + } + var n = xa, + e = ba, + r = wa, + i = Ma, + o = Ta, + u = null; + return t.radius = function (n) { + return arguments.length + ? (r = "function" == typeof n + ? n + : jm(+ n), t) + : r + }, + t.startAngle = function (n) { + return arguments.length + ? (i = "function" == typeof n + ? n + : jm(+ n), t) + : i + }, + t.endAngle = function (n) { + return arguments.length + ? (o = "function" == typeof n + ? n + : jm(+ n), t) + : o + }, + t.source = function (e) { + return arguments.length + ? (n = e, t) + : n + }, + t.target = function (n) { + return arguments.length + ? (e = n, t) + : e + }, + t.context = function (n) { + return arguments.length + ? (u = null == n + ? null + : n, t) + : u + }, + t + }, + Xm = function () { + return new Na + }; + Na.prototype = { + constructor: Na, + reset: function () { + this.s = this.t = 0 + }, + add: function (t) { + ka(Mx, t, this.t), + ka(this, Mx.s, this.s), + this.s + ? this.t += Mx.t + : this.s = Mx.t + }, + valueOf: function () { + return this.s + } + }; + var Vm, + Wm, + $m, + Zm, + Gm, + Jm, + Qm, + Km, + tx, + nx, + ex, + rx, + ix, + ox, + ux, + ax, + cx, + sx, + fx, + lx, + hx, + px, + dx, + vx, + _x, + yx, + gx, + mx, + xx, + bx, + wx, + Mx = new Na, + Tx = 1e-6, + Nx = 1e-12, + kx = Math.PI, + Sx = kx / 2, + Ax = kx / 4, + Ex = 2 * kx, + Cx = 180 / kx, + zx = kx / 180, + Px = Math.abs, + qx = Math.atan, + Lx = Math.atan2, + Rx = Math.cos, + Ux = Math.ceil, + Dx = Math.exp, + Ox = Math.log, + Fx = Math.pow, + Ix = Math.sin, + Yx = Math.sign || function (t) { + return t > 0 + ? 1 + : t < 0 + ? -1 + : 0; + }, + Bx = Math.sqrt, + jx = Math.tan, + Hx = { + Feature: function (t, n) { + za(t.geometry, n) + }, + FeatureCollection: function (t, n) { + for (var e = t.features, r = -1, i = e.length; ++r < i;) + za(e[r].geometry, n) + } + }, + Xx = { + Sphere: function (t, n) { + n.sphere() + }, + Point: function (t, n) { + t = t.coordinates, + n.point(t[0], t[1], t[2]) + }, + MultiPoint: function (t, n) { + for (var e = t.coordinates, r = -1, i = e.length; ++r < i;) + t = e[r], + n.point(t[0], t[1], t[2]) + }, + LineString: function (t, n) { + Pa(t.coordinates, n, 0) + }, + MultiLineString: function (t, n) { + for (var e = t.coordinates, r = -1, i = e.length; ++r < i;) + Pa(e[r], n, 0) + }, + Polygon: function (t, n) { + qa(t.coordinates, n) + }, + MultiPolygon: function (t, n) { + for (var e = t.coordinates, r = -1, i = e.length; ++r < i;) + qa(e[r], n) + }, + GeometryCollection: function (t, n) { + for (var e = t.geometries, r = -1, i = e.length; ++r < i;) + za(e[r], n) + } + }, + Vx = function (t, n) { + t && Hx.hasOwnProperty(t.type) + ? Hx[t.type](t, n) + : za(t, n) + }, + Wx = Xm(), + $x = Xm(), + Zx = { + point: Ca, + lineStart: Ca, + lineEnd: Ca, + polygonStart: function () { + Wx.reset(), + Zx.lineStart = La, + Zx.lineEnd = Ra + }, + polygonEnd: function () { + var t =+ Wx; + $x.add(t < 0 + ? Ex + t + : t), + this.lineStart = this.lineEnd = this.point = Ca + }, + sphere: function () { + $x.add(Ex) + } + }, + Gx = function (t) { + return $x.reset(), + Vx(t, Zx), + 2 * $x + }, + Jx = Xm(), + Qx = { + point: Xa, + lineStart: Wa, + lineEnd: $a, + polygonStart: function () { + Qx.point = Za, + Qx.lineStart = Ga, + Qx.lineEnd = Ja, + Jx.reset(), + Zx.polygonStart() + }, + polygonEnd: function () { + Zx.polygonEnd(), + Qx.point = Xa, + Qx.lineStart = Wa, + Qx.lineEnd = $a, + Wx < 0 + ? (Jm = -(Km = 180), Qm = -(tx = 90)) + : Jx > Tx + ? tx = 90 + : Jx < -Tx && (Qm = -90), + ux[0] = Jm, + ux[1] = Km + } + }, + Kx = function (t) { + var n, + e, + r, + i, + o, + u, + a; + if (tx = Km = -(Jm = Qm = 1 / 0), ox = [], Vx(t, Qx), e = ox.length) { + for (ox.sort(Ka), n = 1, r = ox[0], o = [r]; n < e; ++n) + i = ox[n], + tc(r, i[0]) || tc(r, i[1]) + ? (Qa(r[0], i[1]) > Qa(r[0], r[1]) && (r[1] = i[1]), Qa(i[0], r[1]) > Qa(r[0], r[1]) && (r[0] = i[0])) + : o.push(r = i); + for (u = -(1 / 0), e = o.length - 1, n = 0, r = o[e]; n <= e; r = i, ++n) + i = o[n], + (a = Qa(r[1], i[0])) > u && (u = a, Jm = i[0], Km = r[1]) + } + return ox = ux = null, + Jm === 1 / 0 || Qm === 1 / 0 + ? [ + [ + NaN, NaN + ], + [NaN, NaN] + ] + : [ + [ + Jm, Qm + ], + [Km, tx] + ] + }, + tb = { + sphere: Ca, + point: nc, + lineStart: rc, + lineEnd: uc, + polygonStart: function () { + tb.lineStart = ac, + tb.lineEnd = cc + }, + polygonEnd: function () { + tb.lineStart = rc, + tb.lineEnd = uc + } + }, + nb = function (t) { + ax = cx = sx = fx = lx = hx = px = dx = vx = _x = yx = 0, + Vx(t, tb); + var n = vx, + e = _x, + r = yx, + i = n * n + e * e + r * r; + return i < Nx && (n = hx, e = px, r = dx, cx < Tx && (n = sx, e = fx, r = lx), i = n * n + e * e + r * r, i < Nx) + ? [NaN, NaN] + : [ + Lx(e, n) * Cx, + Aa(r / Bx(i)) * Cx + ] + }, + eb = function (t) { + return function () { + return t + } + }, + rb = function (t, n) { + function e(e, r) { + return e = t(e, r), + n(e[0], e[1]) + } + return t.invert && n.invert && (e.invert = function (e, r) { + return e = n.invert(e, r), + e && t.invert(e[0], e[1]) + }), + e + }; + lc.invert = lc; + var ib, + ob, + ub, + ab, + cb, + sb, + fb, + lb, + hb, + pb, + db, + vb = function (t) { + function n(n) { + return n = t(n[0] * zx, n[1] * zx), + n[0] *= Cx, + n[1] *= Cx, + n + } + return t = hc(t[0] * zx, t[1] * zx, t.length > 2 + ? t[2] * zx + : 0), + n.invert = function (n) { + return n = t.invert(n[0] * zx, n[1] * zx), + n[0] *= Cx, + n[1] *= Cx, + n + }, + n + }, + _b = function () { + function t(t, n) { + e.push(t = r(t, n)), + t[0] *= Cx, + t[1] *= Cx + } + function n() { + var t = i.apply(this, arguments), + n = o.apply(this, arguments) * zx, + c = u.apply(this, arguments) * zx; + return e = [], + r = hc(-t[0] * zx, -t[1] * zx, 0).invert, + _c(a, n, c, 1), + t = { + type: "Polygon", + coordinates: [e] + }, + e = r = null, + t + } + var e, + r, + i = eb([0, 0]), + o = eb(90), + u = eb(6), + a = { + point: t + }; + return n.center = function (t) { + return arguments.length + ? (i = "function" == typeof t + ? t + : eb([ + t[0], + t[1] + ]), n) + : i + }, + n.radius = function (t) { + return arguments.length + ? (o = "function" == typeof t + ? t + : eb(+ t), n) + : o + }, + n.precision = function (t) { + return arguments.length + ? (u = "function" == typeof t + ? t + : eb(+ t), n) + : u + }, + n + }, + yb = function () { + var t, + n = []; + return { + point: function (n, e) { + t.push([n, e]) + }, + lineStart: function () { + n.push(t = []) + }, + lineEnd: Ca, + rejoin: function () { + n.length > 1 && n.push(n.pop().concat(n.shift())) + }, + result: function () { + var e = n; + return n = [], + t = null, + e + } + } + }, + gb = function (t, n, e, r, i, o) { + var u, + a = t[0], + c = t[1], + s = n[0], + f = n[1], + l = 0, + h = 1, + p = s - a, + d = f - c; + if (u = e - a, p || !(u > 0)) { + if (u /= p, p < 0) { + if (u < l) + return; + u < h && (h = u) + } else if (p > 0) { + if (u > h) + return; + u > l && (l = u) + } + if (u = i - a, p || !(u < 0)) { + if (u /= p, p < 0) { + if (u > h) + return; + u > l && (l = u) + } else if (p > 0) { + if (u < l) + return; + u < h && (h = u) + } + if (u = r - c, d || !(u > 0)) { + if (u /= d, d < 0) { + if (u < l) + return; + u < h && (h = u) + } else if (d > 0) { + if (u > h) + return; + u > l && (l = u) + } + if (u = o - c, d || !(u < 0)) { + if (u /= d, d < 0) { + if (u > h) + return; + u > l && (l = u) + } else if (d > 0) { + if (u < l) + return; + u < h && (h = u) + } + return l > 0 && (t[0] = a + l * p, t[1] = c + l * d), + h < 1 && (n[0] = a + h * p, n[1] = c + h * d), + !0 + } + } + } + } + }, + mb = function (t, n) { + return Px(t[0] - n[0]) < Tx && Px(t[1] - n[1]) < Tx + }, + xb = function (t, n, e, r, i) { + var o, + u, + a = [], + c = []; + if (t.forEach(function (t) { + if (!((n = t.length - 1) <= 0)) { + var n, + e, + r = t[0], + u = t[n]; + if (mb(r, u)) { + for (i.lineStart(), o = 0; o < n; ++o) + i.point((r = t[o])[0], r[1]); + return void i.lineEnd() + } + a.push(e = new gc(r, t, null, !0)), + c.push(e.o = new gc(r, null, e, !1)), + a.push(e = new gc(u, t, null, !1)), + c.push(e.o = new gc(u, null, e, !0)) + } + }), a.length) { + for (c.sort(n), mc(a), mc(c), o = 0, u = c.length; o < u; ++o) + c[o].e = e = !e; + for (var s, f, l = a[0];;) { + for (var h = l, p = !0; h.v;) + if ((h = h.n) === l) + return; + s = h.z, + i.lineStart(); + do { + if (h.v = h.o.v = !0, h.e) { + if (p) + for (o = 0, u = s.length; o < u; ++o) + i.point((f = s[o])[0], f[1]); + else + r(h.x, h.n.x, 1, i); + h = h.n + } else { + if (p) + for (s = h.p.z, o = s.length - 1; o >= 0; --o) + i.point((f = s[o])[0], f[1]); + else + r(h.x, h.p.x, -1, i); + h = h.p + } + h = h.o, + s = h.z, + p = !p + } while (!h.v); + i.lineEnd() + } + } + }, + bb = 1e9, + wb = -bb, + Mb = function () { + var t, + n, + e, + r = 0, + i = 0, + o = 960, + u = 500; + return e = { + stream: function (e) { + return t && n === e + ? t + : t = xc(r, i, o, u)(n = e) + }, + extent: function (a) { + return arguments.length + ? (r =+ a[0][0], i =+ a[0][1], o =+ a[1][0], u =+ a[1][1], t = n = null, e) + : [ + [ + r, i + ], + [o, u] + ] + } + } + }, + Tb = Xm(), + Nb = { + sphere: Ca, + point: Ca, + lineStart: bc, + lineEnd: Ca, + polygonStart: Ca, + polygonEnd: Ca + }, + kb = function (t) { + return Tb.reset(), + Vx(t, Nb), + Tb + }, + Sb = [ + null, null + ], + Ab = { + type: "LineString", + coordinates: Sb + }, + Eb = function (t, n) { + return Sb[0] = t, + Sb[1] = n, + kb(Ab) + }, + Cb = function (t, n) { + var e = t[0] * zx, + r = t[1] * zx, + i = n[0] * zx, + o = n[1] * zx, + u = Rx(r), + a = Ix(r), + c = Rx(o), + s = Ix(o), + f = u * Rx(e), + l = u * Ix(e), + h = c * Rx(i), + p = c * Ix(i), + d = 2 * Aa(Bx(Ea(o - r) + u * c * Ea(i - e))), + v = Ix(d), + _ = d + ? function (t) { + var n = Ix(t *= d) / v, + e = Ix(d - t) / v, + r = e * f + n * h, + i = e * l + n * p, + o = e * a + n * s; + return [ + Lx(i, r) * Cx, + Lx(o, Bx(r * r + i * i)) * Cx + ] + } + : function () { + return [ + e * Cx, + r * Cx + ] + }; + return _.distance = d, + _ + }, + zb = function (t) { + return t + }, + Pb = Xm(), + qb = Xm(), + Lb = { + point: Ca, + lineStart: Ca, + lineEnd: Ca, + polygonStart: function () { + Lb.lineStart = Ec, + Lb.lineEnd = Pc + }, + polygonEnd: function () { + Lb.lineStart = Lb.lineEnd = Lb.point = Ca, + Pb.add(Px(qb)), + qb.reset() + }, + result: function () { + var t = Pb / 2; + return Pb.reset(), + t + } + }, + Rb = 1 / 0, + Ub = Rb, + Db = -Rb, + Ob = Db, + Fb = { + point: qc, + lineStart: Ca, + lineEnd: Ca, + polygonStart: Ca, + polygonEnd: Ca, + result: function () { + var t = [ + [ + Rb, Ub + ], + [Db, Ob] + ]; + return Db = Ob = -(Ub = Rb = 1 / 0), + t + } + }, + Ib = 0, + Yb = 0, + Bb = 0, + jb = 0, + Hb = 0, + Xb = 0, + Vb = 0, + Wb = 0, + $b = 0, + Zb = { + point: Lc, + lineStart: Rc, + lineEnd: Oc, + polygonStart: function () { + Zb.lineStart = Fc, + Zb.lineEnd = Ic + }, + polygonEnd: function () { + Zb.point = Lc, + Zb.lineStart = Rc, + Zb.lineEnd = Oc + }, + result: function () { + var t = $b + ? [ + Vb / $b, + Wb / $b + ] + : Xb + ? [ + jb / Xb, + Hb / Xb + ] + : Bb + ? [ + Ib / Bb, + Yb / Bb + ] + : [NaN, NaN]; + return Ib = Yb = Bb = jb = Hb = Xb = Vb = Wb = $b = 0, + t + } + }; + jc.prototype = { + _radius: 4.5, + pointRadius: function (t) { + return this._radius = t, + this + }, + polygonStart: function () { + this._line = 0 + }, + polygonEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._point = 0 + }, + lineEnd: function () { + 0 === this._line && this + ._context + .closePath(), + this._point = NaN + }, + point: function (t, n) { + switch (this._point) { + case 0: + this + ._context + .moveTo(t, n), + this._point = 1; + break; + case 1: + this + ._context + .lineTo(t, n); + break; + default: + this + ._context + .moveTo(t + this._radius, n), + this + ._context + .arc(t, n, this._radius, 0, Ex) + } + }, + result: Ca + }, + Hc.prototype = { + _circle: Xc(4.5), + pointRadius: function (t) { + return this._circle = Xc(t), + this + }, + polygonStart: function () { + this._line = 0 + }, + polygonEnd: function () { + this._line = NaN + }, + lineStart: function () { + this._point = 0 + }, + lineEnd: function () { + 0 === this._line && this + ._string + .push("Z"), + this._point = NaN + }, + point: function (t, n) { + switch (this._point) { + case 0: + this + ._string + .push("M", t, ",", n), + this._point = 1; + break; + case 1: + this + ._string + .push("L", t, ",", n); + break; + default: + this + ._string + .push("M", t, ",", n, this._circle) + } + }, + result: function () { + if (this._string.length) { + var t = this + ._string + .join(""); + return this._string = [], + t + } + } + }; + var Gb = function (t, n) { + function e(t) { + return t && ("function" == typeof o && i.pointRadius(+ o.apply(this, arguments)), Vx(t, r(i))), + i.result() + } + var r, + i, + o = 4.5; + return e.area = function (t) { + return Vx(t, r(Lb)), + Lb.result() + }, + e.bounds = function (t) { + return Vx(t, r(Fb)), + Fb.result() + }, + e.centroid = function (t) { + return Vx(t, r(Zb)), + Zb.result() + }, + e.projection = function (n) { + return arguments.length + ? (r = null == (t = n) + ? zb + : n.stream, e) + : t + }, + e.context = function (t) { + return arguments.length + ? (i = null == (n = t) + ? new Hc + : new jc(t), "function" != typeof o && i.pointRadius(o), e) + : n + }, + e.pointRadius = function (t) { + return arguments.length + ? (o = "function" == typeof t + ? t + : (i.pointRadius(+ t), + t), e) + : o + }, + e + .projection(t) + .context(n) + }, + Jb = Xm(), + Qb = function (t, n) { + var e = n[0], + r = n[1], + i = [ + Ix(e), -Rx(e), + 0 + ], + o = 0, + u = 0; + Jb.reset(); + for (var a = 0, c = t.length; a < c; ++a) + if (f = (s = t[a]).length) + for (var s, f, l = s[f - 1], h = l[0], p = l[1] / 2 + Ax, d = Ix(p), v = Rx(p), _ = 0; _ < f; ++_, h = g, d = x, v = b, l = y) { + var y = s[_], + g = y[0], + m = y[1] / 2 + Ax, + x = Ix(m), + b = Rx(m), + w = g - h, + M = w >= 0 + ? 1 + : -1, + T = M * w, + N = T > kx, + k = d * x; + if (Jb.add(Lx(k * M * Ix(T), v * b + k * Rx(T))), o += N + ? w + M * Ex + : w, N ^ h >= e ^ g >= e) { + var S = Ya(Fa(l), Fa(y)); + Ha(S); + var A = Ya(i, S); + Ha(A); + var E = (N ^ w >= 0 + ? -1 + : 1) * Aa(A[2]); + (r > E || r === E && (S[0] || S[1])) && (u += N ^ w >= 0 + ? 1 + : -1) + } + } + return (o < -Tx || o < Tx && Jb < -Tx) ^ 1 & u + }, + Kb = function (t, n, e, r) { + return function (i, o) { + function u(n, e) { + var r = i(n, e); + t(n = r[0], e = r[1]) && o.point(n, e) + } + function a(t, n) { + var e = i(t, n); + _.point(e[0], e[1]) + } + function c() { + b.point = a, + _.lineStart() + } + function s() { + b.point = u, + _.lineEnd() + } + function f(t, n) { + v.push([t, n]); + var e = i(t, n); + m.point(e[0], e[1]) + } + function l() { + m.lineStart(), + v = [] + } + function h() { + f(v[0][0], v[0][1]), + m.lineEnd(); + var t, + n, + e, + r, + i = m.clean(), + u = g.result(), + a = u.length; + if (v.pop(), p.push(v), v = null, a) + if (1 & i) { + if (e = u[0], (n = e.length - 1) > 0) { + for (x || (o.polygonStart(), x = !0), o.lineStart(), t = 0; t < n; ++t) + o.point((r = e[t])[0], r[1]); + o.lineEnd() + } + } else + a > 1 && 2 & i && u.push(u.pop().concat(u.shift())), + d.push(u.filter(Vc)) + } + var p, + d, + v, + _ = n(o), + y = i.invert(r[0], r[1]), + g = yb(), + m = n(g), + x = !1, + b = { + point: u, + lineStart: c, + lineEnd: s, + polygonStart: function () { + b.point = f, + b.lineStart = l, + b.lineEnd = h, + d = [], + p = [] + }, + polygonEnd: function () { + b.point = u, + b.lineStart = c, + b.lineEnd = s, + d = Js(d); + var t = Qb(p, y); + d.length + ? (x || (o.polygonStart(), x = !0), xb(d, Wc, t, e, o)) + : t && (x || (o.polygonStart(), x = !0), o.lineStart(), e(null, null, 1, o), o.lineEnd()), + x && (o.polygonEnd(), x = !1), + d = p = null + }, + sphere: function () { + o.polygonStart(), + o.lineStart(), + e(null, null, 1, o), + o.lineEnd(), + o.polygonEnd() + } + }; + return b + } + }, + tw = Kb(function () { + return !0 + }, $c, Gc, [-kx, -Sx + ]), + nw = function (t, n) { + function e(e, r, i, o) { + _c(o, t, n, i, e, r) + } + function r(t, n) { + return Rx(t) * Rx(n) > a + } + function i(t) { + var n, + e, + i, + a, + f; + return { + lineStart: function () { + a = i = !1, + f = 1 + }, + point: function (l, h) { + var p, + d = [ + l, h + ], + v = r(l, h), + _ = c + ? v + ? 0 + : u(l, h) + : v + ? u(l + (l < 0 + ? kx + : -kx), h) + : 0; + if (!n && (a = i = v) && t.lineStart(), v !== i && (p = o(n, d), (mb(n, p) || mb(d, p)) && (d[0] += Tx, d[1] += Tx, v = r(d[0], d[1]))), v !== i) + f = 0, + v + ? (t.lineStart(), p = o(d, n), t.point(p[0], p[1])) + : (p = o(n, d), t.point(p[0], p[1]), t.lineEnd()), + n = p; + else if (s && n && c ^ v) { + var y; + _ & e || !(y = o(d, n, !0)) || (f = 0, c + ? (t.lineStart(), t.point(y[0][0], y[0][1]), t.point(y[1][0], y[1][1]), t.lineEnd()) + : (t.point(y[1][0], y[1][1]), t.lineEnd(), t.lineStart(), t.point(y[0][0], y[0][1]))) + } + !v || n && mb(n, d) || t.point(d[0], d[1]), + n = d, + i = v, + e = _ + }, + lineEnd: function () { + i && t.lineEnd(), + n = null + }, + clean: function () { + return f | (a && i) << 1 + } + } + } + function o(t, n, e) { + var r = Fa(t), + i = Fa(n), + o = [ + 1, 0, 0 + ], + u = Ya(r, i), + c = Ia(u, u), + s = u[0], + f = c - s * s; + if (!f) + return !e && t; + var l = a * c / f, + h = -a * s / f, + p = Ya(o, u), + d = ja(o, l), + v = ja(u, h); + Ba(d, v); + var _ = p, + y = Ia(d, _), + g = Ia(_, _), + m = y * y - g * (Ia(d, d) - 1); + if (!(m < 0)) { + var x = Bx(m), + b = ja(_, (-y - x) / g); + if (Ba(b, d), b = Oa(b), !e) + return b; + var w, + M = t[0], + T = n[0], + N = t[1], + k = n[1]; + T < M && (w = M, M = T, T = w); + var S = T - M, + A = Px(S - kx) < Tx, + E = A || S < Tx; + if (!A && k < N && (w = N, N = k, k = w), E + ? A + ? N + k > 0 ^ b[1] < (Px(b[0] - M) < Tx + ? N + : k) + : N <= b[1] && b[1] <= k + : S > kx ^ (M <= b[0] && b[0] <= T)) { + var C = ja(_, (-y + x) / g); + return Ba(C, d), + [b, Oa(C)] + } + } + } + function u(n, e) { + var r = c + ? t + : kx - t, + i = 0; + return n < -r + ? i |= 1 + : n > r && (i |= 2), + e < -r + ? i |= 4 + : e > r && (i |= 8), + i + } + var a = Rx(t), + c = a > 0, + s = Px(a) > Tx; + return Kb(r, i, e, c + ? [ + 0, -t + ] + : [-kx, + t - kx + ]) + }, + ew = function (t) { + return {stream: Jc(t)} + }; + Qc.prototype = { + constructor: Qc, + point: function (t, n) { + this + .stream + .point(t, n) + }, + sphere: function () { + this + .stream + .sphere() + }, + lineStart: function () { + this + .stream + .lineStart() + }, + lineEnd: function () { + this + .stream + .lineEnd() + }, + polygonStart: function () { + this + .stream + .polygonStart() + }, + polygonEnd: function () { + this + .stream + .polygonEnd() + } + }; + var rw = 16, + iw = Rx(30 * zx), + ow = function (t, n) { + return + n + ? es(t, n) + : ns(t) + }, + uw = Jc({ + point: function (t, n) { + this + .stream + .point(t * zx, n * zx) + } + }), + aw = function () { + return os(as) + .scale(155.424) + .center([0, 33.6442]) + }, + cw = function () { + return aw() + .parallels([29.5, 45.5]) + .scale(1070) + .translate([480, 250]) + .rotate([96, 0]) + .center([-.6, 38.7]) + }, + sw = function () { + function t(t) { + var n = t[0], + e = t[1]; + return a = null, + i.point(n, e), + a || (o.point(n, e), a) || (u.point(n, e), a) + } + function n() { + return e = r = null, + t + } + var e, + r, + i, + o, + u, + a, + c = cw(), + s = aw() + .rotate([154, 0]) + .center([-2, 58.5]) + .parallels([55, 65]), + f = aw() + .rotate([157, 0]) + .center([-3, 19.9]) + .parallels([8, 18]), + l = { + point: function (t, n) { + a = [t, n] + } + }; + return t.invert = function (t) { + var n = c.scale(), + e = c.translate(), + r = (t[0] - e[0]) / n, + i = (t[1] - e[1]) / n; + return (i >= .12 && i < .234 && r >= -.425 && r < -.214 + ? s + : i >= .166 && i < .234 && r >= -.214 && r < -.115 + ? f + : c).invert(t) + }, + t.stream = function (t) { + return e && r === t + ? e + : e = cs([ + c.stream(r = t), + s.stream(t), + f.stream(t) + ]) + }, + t.precision = function (t) { + return arguments.length + ? (c.precision(t), s.precision(t), f.precision(t), n()) + : c.precision() + }, + t.scale = function (n) { + return arguments.length + ? (c.scale(n), s.scale(.35 * n), f.scale(n), t.translate(c.translate())) + : c.scale() + }, + t.translate = function (t) { + if (!arguments.length) + return c.translate(); + var e = c.scale(), + r =+ t[0], + a =+ t[1]; + return i = c + .translate(t) + .clipExtent([ + [ + r - .455 * e, + a - .238 * e + ], + [ + r + .455 * e, + a + .238 * e + ] + ]) + .stream(l), + o = s + .translate([ + r - .307 * e, + a + .201 * e + ]) + .clipExtent([ + [ + r - .425 * e + Tx, + a + .12 * e + Tx + ], + [ + r - .214 * e - Tx, + a + .234 * e - Tx + ] + ]) + .stream(l), + u = f + .translate([ + r - .205 * e, + a + .212 * e + ]) + .clipExtent([ + [ + r - .214 * e + Tx, + a + .166 * e + Tx + ], + [ + r - .115 * e - Tx, + a + .234 * e - Tx + ] + ]) + .stream(l), + n() + }, + t.fitExtent = function (n, e) { + return Kc(t, n, e) + }, + t.fitSize = function (n, e) { + return ts(t, n, e) + }, + t.scale(1070) + }, + fw = ss(function (t) { + return Bx(2 / (1 + t)) + }); + fw.invert = fs(function (t) { + return 2 * Aa(t / 2) + }); + var lw = function () { + return rs(fw) + .scale(124.75) + .clipAngle(179.999) + }, + hw = ss(function (t) { + return (t = Sa(t)) && t / Ix(t) + }); + hw.invert = fs(function (t) { + return t + }); + var pw = function () { + return rs(hw) + .scale(79.4188) + .clipAngle(179.999) + }; + ls.invert = function (t, n) { + return [ + t, 2 * qx(Dx(n)) - Sx + ] + }; + var dw = function () { + return hs(ls).scale(961 / Ex) + }, + vw = function () { + return os(ds) + .scale(109.5) + .parallels([30, 30]) + }; + vs.invert = vs; + var _w = function () { + return rs(vs).scale(152.63) + }, + yw = function () { + return os(_s) + .scale(131.154) + .center([0, 13.9389]) + }; + ys.invert = fs(qx); + var gw = function () { + return rs(ys) + .scale(144.049) + .clipAngle(60) + }, + mw = function () { + function t() { + return i = o = null, + u + } + var n, + e, + r, + i, + o, + u, + a = 1, + c = 0, + s = 0, + f = zb, + l = null, + h = zb; + return u = { + stream: function (t) { + return i && o === t + ? i + : i = f(h(o = t)) + }, + clipExtent: function (i) { + return arguments.length + ? (h = null == i + ? (l = n = e = r = null, zb) + : xc(l =+ i[0][0], n =+ i[0][1], e =+ i[1][0], r =+ i[1][1]), t()) + : null == l + ? null + : [ + [ + l, n + ], + [e, r] + ] + }, + scale: function (n) { + return arguments.length + ? (f = gs(a =+ n, c, s), t()) + : a + }, + translate: function (n) { + return arguments.length + ? (f = gs(a, c =+ n[0], s =+ n[1]), t()) + : [c, s] + }, + fitExtent: function (t, n) { + return Kc(u, t, n) + }, + fitSize: function (t, n) { + return ts(u, t, n) + } + } + }; + ms.invert = fs(Aa); + var xw = function () { + return rs(ms) + .scale(249.5) + .clipAngle(90 + Tx) + }; + xs.invert = fs(function (t) { + return 2 * qx(t) + }); + var bw = function () { + return rs(xs) + .scale(250) + .clipAngle(142) + }; + bs.invert = function (t, n) { + return [-n, + 2 * qx(Dx(t)) - Sx + ] + }; + var ww = function () { + var t = hs(bs), + n = t.center, + e = t.rotate; + return t.center = function (t) { + return arguments.length + ? n([-t[1], + t[0] + ]) + : (t = n(), [ + t[1], -t[0] + ]) + }, + t.rotate = function (t) { + return arguments.length + ? e([ + t[0], t[1], t.length > 2 + ? t[2] + 90 + : 90 + ]) + : (t = e(), [ + t[0], t[1], t[2] - 90 + ]) + }, + e([0, 0, 90]).scale(159.155) + }; + t.version = ws, + t.bisect = ks, + t.bisectRight = ks, + t.bisectLeft = Ss, + t.ascending = Ms, + t.bisector = Ts, + t.descending = As, + t.deviation = zs, + t.extent = Ps, + t.histogram = Hs, + t.thresholdFreedmanDiaconis = Vs, + t.thresholdScott = Ws, + t.thresholdSturges = js, + t.max = $s, + t.mean = Zs, + t.median = Gs, + t.merge = Js, + t.min = Qs, + t.pairs = Ks, + t.permute = tf, + t.quantile = Xs, + t.range = Os, + t.scan = nf, + t.shuffle = ef, + t.sum = rf, + t.ticks = Bs, + t.tickStep = e, + t.transpose = of, + t.variance = Cs, + t.zip = uf, + t.entries = hf, + t.keys = ff, + t.values = lf, + t.map = o, + t.set = l, + t.nest = cf, + t.randomUniform = pf, + t.randomNormal = df, + t.randomLogNormal = vf, + t.randomBates = yf, + t.randomIrwinHall = _f, + t.randomExponential = gf, + t.easeLinear = h, + t.easeQuad = v, + t.easeQuadIn = p, + t.easeQuadOut = d, + t.easeQuadInOut = v, + t.easeCubic = g, + t.easeCubicIn = _, + t.easeCubicOut = y, + t.easeCubicInOut = g, + t.easePoly = wf, + t.easePolyIn = xf, + t.easePolyOut = bf, + t.easePolyInOut = wf, + t.easeSin = b, + t.easeSinIn = m, + t.easeSinOut = x, + t.easeSinInOut = b, + t.easeExp = T, + t.easeExpIn = w, + t.easeExpOut = M, + t.easeExpInOut = T, + t.easeCircle = S, + t.easeCircleIn = N, + t.easeCircleOut = k, + t.easeCircleInOut = S, + t.easeBounce = E, + t.easeBounceIn = A, + t.easeBounceOut = E, + t.easeBounceInOut = C, + t.easeBack = Of, + t.easeBackIn = Uf, + t.easeBackOut = Df, + t.easeBackInOut = Of, + t.easeElastic = jf, + t.easeElasticIn = Bf, + t.easeElasticOut = jf, + t.easeElasticInOut = Hf, + t.polygonArea = Xf, + t.polygonCentroid = Vf, + t.polygonHull = $f, + t.polygonContains = Zf, + t.polygonLength = Gf, + t.path = L, + t.quadtree = I, + t.queue = Z, + t.arc = wl, + t.area = Nl, + t.line = Tl, + t.pie = Al, + t.radialArea = zl, + t.radialLine = Cl, + t.symbol = Jl, + t.symbols = Gl, + t.symbolCircle = Pl, + t.symbolCross = ql, + t.symbolDiamond = Ul, + t.symbolSquare = Bl, + t.symbolStar = Yl, + t.symbolTriangle = Hl, + t.symbolWye = Zl, + t.curveBasisClosed = th, + t.curveBasisOpen = nh, + t.curveBasis = Kl, + t.curveBundle = eh, + t.curveCardinalClosed = ih, + t.curveCardinalOpen = oh, + t.curveCardinal = rh, + t.curveCatmullRomClosed = ah, + t.curveCatmullRomOpen = ch, + t.curveCatmullRom = uh, + t.curveLinearClosed = sh, + t.curveLinear = Ml, + t.curveMonotoneX = zt, + t.curveMonotoneY = Pt, + t.curveNatural = fh, + t.curveStep = lh, + t.curveStepAfter = Dt, + t.curveStepBefore = Ut, + t.stack = vh, + t.stackOffsetExpand = _h, + t.stackOffsetNone = ph, + t.stackOffsetSilhouette = yh, + t.stackOffsetWiggle = gh, + t.stackOrderAscending = mh, + t.stackOrderDescending = xh, + t.stackOrderInsideOut = bh, + t.stackOrderNone = dh, + t.stackOrderReverse = wh, + t.color = Bt, + t.rgb = Vt, + t.hsl = Gt, + t.lab = tn, + t.hcl = cn, + t.cubehelix = ln, + t.interpolate = _p, + t.interpolateArray = sp, + t.interpolateDate = fp, + t.interpolateNumber = lp, + t.interpolateObject = hp, + t.interpolateRound = yp, + t.interpolateString = vp, + t.interpolateTransformCss = bp, + t.interpolateTransformSvg = wp, + t.interpolateZoom = Sp, + t.interpolateRgb = up, + t.interpolateRgbBasis = ap, + t.interpolateRgbBasisClosed = cp, + t.interpolateHsl = Ap, + t.interpolateHslLong = Ep, + t.interpolateLab = En, + t.interpolateHcl = Cp, + t.interpolateHclLong = zp, + t.interpolateCubehelix = Pp, + t.interpolateCubehelixLong = qp, + t.interpolateBasis = rp, + t.interpolateBasisClosed = ip, + t.quantize = Lp, + t.dispatch = Pn, + t.dsvFormat = Op, + t.csvParse = Ip, + t.csvParseRows = Yp, + t.csvFormat = Bp, + t.csvFormatRows = jp, + t.tsvParse = Xp, + t.tsvParseRows = Vp, + t.tsvFormat = Wp, + t.tsvFormatRows = $p, + t.request = Zp, + t.html = Jp, + t.json = Qp, + t.text = Kp, + t.xml = td, + t.csv = ed, + t.tsv = rd, + t.now = jn, + t.timer = Vn, + t.timerFlush = Wn, + t.timeout = pd, + t.interval = dd, + t.timeInterval = Qn, + t.timeMillisecond = yd, + t.timeMilliseconds = gd, + t.timeSecond = Td, + t.timeSeconds = Nd, + t.timeMinute = kd, + t.timeMinutes = Sd, + t.timeHour = Ad, + t.timeHours = Ed, + t.timeDay = Cd, + t.timeDays = zd, + t.timeWeek = Pd, + t.timeWeeks = Fd, + t.timeSunday = Pd, + t.timeSundays = Fd, + t.timeMonday = qd, + t.timeMondays = Id, + t.timeTuesday = Ld, + t.timeTuesdays = Yd; + t.timeWednesday = Rd; + t.timeWednesdays = Bd, + t.timeThursday = Ud, + t.timeThursdays = jd, + t.timeFriday = Dd, + t.timeFridays = Hd, + t.timeSaturday = Od, + t.timeSaturdays = Xd, + t.timeMonth = Vd, + t.timeMonths = Wd, + t.timeYear = $d, + t.timeYears = Zd, + t.utcMillisecond = yd, + t.utcMilliseconds = gd, + t.utcSecond = Td, + t.utcSeconds = Nd, + t.utcMinute = Gd, + t.utcMinutes = Jd, + t.utcHour = Qd, + t.utcHours = Kd, + t.utcDay = tv, + t.utcDays = nv, + t.utcWeek = ev, + t.utcWeeks = sv, + t.utcSunday = ev, + t.utcSundays = sv, + t.utcMonday = rv, + t.utcMondays = fv, + t.utcTuesday = iv, + t.utcTuesdays = lv, + t.utcWednesday = ov, + t.utcWednesdays = hv, + t.utcThursday = uv, + t.utcThursdays = pv, + t.utcFriday = av, + t.utcFridays = dv, + t.utcSaturday = cv, + t.utcSaturdays = vv, + t.utcMonth = _v, + t.utcMonths = yv, + t.utcYear = gv, + t.utcYears = xv, + t.formatLocale = Pv, + t.formatDefaultLocale = re, + t.formatSpecifier = Ev, + t.precisionFixed = Lv, + t.precisionPrefix = Rv, + t.precisionRound = Uv, + t.isoFormat = Bv, + t.isoParse = jv, + t.timeFormatLocale = ae, + t.timeFormatDefaultLocale = nr, + t.scaleBand = or, + t.scalePoint = ar, + t.scaleIdentity = yr, + t.scaleLinear = _r, + t.scaleLog = Tr, + t.scaleOrdinal = ir, + t.scaleImplicit = Wv, + t.scalePow = kr, + t.scaleSqrt = Sr, + t.scaleQuantile = Ar, + t.scaleQuantize = Er, + t.scaleThreshold = Cr, + t.scaleTime = u_, + t.scaleUtc = a_, + t.schemeCategory10 = s_, + t.schemeCategory20b = f_, + t.schemeCategory20c = l_, + t.schemeCategory20 = h_, + t.scaleSequential = Rr, + t.interpolateCubehelixDefault = p_, + t.interpolateRainbow = y_, + t.interpolateWarm = d_, + t.interpolateCool = v_, + t.interpolateViridis = g_, + t.interpolateMagma = m_, + t.interpolateInferno = x_, + t.interpolatePlasma = b_, + t.creator = N_, + t.customEvent = Xr, + t.local = Or, + t.matcher = C_, + t.mouse = U_, + t.namespace = T_, + t.namespaces = M_, + t.select = gy, + t.selectAll = my, + t.selection = Pi, + t.selector = D_, + t.selectorAll = F_, + t.touch = xy, + t.touches = by, + t.window = iy, + t.active = ig, + t.interrupt = Py, + t.transition = fo, + t.axisTop = mo, + t.axisRight = xo, + t.axisBottom = bo, + t.axisLeft = wo, + t.cluster = hg, + t.hierarchy = zo, + t.pack = Sg, + t.packSiblings = Ng, + t.packEnclose = Tg, + t.partition = Cg, + t.stratify = Lg, + t.tree = Rg, + t.treemap = Fg, + t.treemapBinary = Ig, + t.treemapDice = Eg, + t.treemapSlice = Ug, + t.treemapSliceDice = Yg, + t.treemapSquarify = Og, + t.treemapResquarify = Bg, + t.forceCenter = jg, + t.forceCollide = Vg, + t.forceLink = Wg, + t.forceManyBody = Jg, + t.forceSimulation = Gg, + t.forceX = Qg, + t.forceY = Kg, + t.drag = rm, + t.dragDisable = nm, + t.dragEnable = mu, + t.voronoi = dm, + t.zoom = gm, + t.zoomIdentity = _m, + t.zoomTransform = ia, + t.brush = Lm, + t.brushX = _a, + t.brushY = ya, + t.brushSelection = va, + t.chord = Ym, + t.ribbon = Hm, + t.geoAlbers = cw, + t.geoAlbersUsa = sw, + t.geoArea = Gx, + t.geoAzimuthalEqualArea = lw, + t.geoAzimuthalEqualAreaRaw = fw, + t.geoAzimuthalEquidistant = pw, + t.geoAzimuthalEquidistantRaw = hw, + t.geoBounds = Kx, + t.geoCentroid = nb, + t.geoCircle = _b, + t.geoClipExtent = Mb, + t.geoConicConformal = vw, + t.geoConicConformalRaw = ds, + t.geoConicEqualArea = aw, + t.geoConicEqualAreaRaw = as, + t.geoConicEquidistant = yw, + t.geoConicEquidistantRaw = _s, + t.geoDistance = Eb, + t.geoEquirectangular = _w, + t.geoEquirectangularRaw = vs, + t.geoGnomonic = gw, + t.geoGnomonicRaw = ys, + t.geoGraticule = Sc, + t.geoGraticule10 = Ac, + t.geoIdentity = mw, + t.geoInterpolate = Cb, + t.geoLength = kb, + t.geoMercator = dw, + t.geoMercatorRaw = ls, + t.geoOrthographic = xw, + t.geoOrthographicRaw = ms, + t.geoPath = Gb, + t.geoProjection = rs, + t.geoProjectionMutator = is, + t.geoRotation = vb, + t.geoStereographic = bw, + t.geoStereographicRaw = xs, + t.geoStream = Vx, + t.geoTransform = ew, + t.geoTransverseMercator = ww, + t.geoTransverseMercatorRaw = bs, + Object.defineProperty(t, "__esModule", { + value: !0 + }) + }); \ No newline at end of file diff --git a/assets/js/jquery.min.js b/assets/js/jquery.min.js new file mode 100644 index 0000000..ac35a19 --- /dev/null +++ b/assets/js/jquery.min.js @@ -0,0 +1,5315 @@ +/*! jQuery v3.1.1 | (c) jQuery Foundation | jquery.org/license */ +!function (a, b) { + "use strict"; + "object" == typeof module && "object" == typeof module.exports + ? module.exports = a.document + ? b(a, !0) + : function (a) { + if (!a.document) + throw new Error("jQuery requires a window with a document"); + return b(a) + } + : b(a) +}("undefined" != typeof window + ? window + : this, function (a, b) { + "use strict"; + var c = [], + d = a.document, + e = Object.getPrototypeOf, + f = c.slice, + g = c.concat, + h = c.push, + i = c.indexOf, + j = {}, + k = j.toString, + l = j.hasOwnProperty, + m = l.toString, + n = m.call(Object), + o = {}; + function p(a, b) { + b = b || d; + var c = b.createElement("script"); + c.text = a, + b + .head + .appendChild(c) + .parentNode + .removeChild(c) + } + var q = "3.1.1", + r = function (a, b) { + return new r + .fn + .init(a, b) + }, + s = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, + t = /^-ms-/, + u = /-([a-z])/g, + v = function (a, b) { + return b.toUpperCase() + }; + r.fn = r.prototype = { + jquery: q, + constructor: r, + length: 0, + toArray: function () { + return f.call(this) + }, + get: function (a) { + return null == a + ? f.call(this) + : a < 0 + ? this[a + this.length] + : this[a] + }, + pushStack: function (a) { + var b = r.merge(this.constructor(), a); + return b.prevObject = this, + b + }, + each: function (a) { + return r.each(this, a) + }, + map: function (a) { + return this.pushStack(r.map(this, function (b, c) { + return a.call(b, c, b) + })) + }, + slice: function () { + return this.pushStack(f.apply(this, arguments)) + }, + first: function () { + return this.eq(0) + }, + last: function () { + return this.eq(-1) + }, + eq: function (a) { + var b = this.length, + c =+ a + (a < 0 + ? b + : 0); + return this.pushStack(c >= 0 && c < b + ? [this[c]] + : []) + }, + end: function () { + return this.prevObject || this.constructor() + }, + push: h, + sort: c.sort, + splice: c.splice + }, + r.extend = r.fn.extend = function () { + var a, + b, + c, + d, + e, + f, + g = arguments[0] || {}, + h = 1, + i = arguments.length, + j = !1; + for ("boolean" == typeof g && (j = g, g = arguments[h] || {}, h++), "object" == typeof g || r.isFunction(g) || (g = {}), h === i && (g = this, h--); h < i; h++) + if (null != (a = arguments[h])) + for (b in a) + c = g[b], + d = a[b], + g !== d && (j && d && (r.isPlainObject(d) || (e = r.isArray(d))) + ? (e + ? (e = !1, f = c && r.isArray(c) + ? c + : []) + : f = c && r.isPlainObject(c) + ? c + : {}, g[b] = r.extend(j, f, d)) + : void 0 !== d && (g[b] = d)); + return g + }, + r.extend({ + expando: "jQuery" + (q + Math.random()).replace(/\D/g, ""), + isReady: !0, + error: function (a) { + throw new Error(a) + }, + noop: function () {}, + isFunction: function (a) { + return "function" === r.type(a) + }, + isArray: Array.isArray, + isWindow: function (a) { + return null != a && a === a.window + }, + isNumeric: function (a) { + var b = r.type(a); + return ("number" === b || "string" === b) && !isNaN(a - parseFloat(a)) + }, + isPlainObject: function (a) { + var b, + c; + return !(!a || "[object Object]" !== k.call(a)) && (!(b = e(a)) || (c = l.call(b, "constructor") && b.constructor, "function" == typeof c && m.call(c) === n)) + }, + isEmptyObject: function (a) { + var b; + for (b in a) + return !1; + return !0 + }, + type: function (a) { + return null == a + ? a + "" + : "object" == typeof a || "function" == typeof a + ? j[k.call(a)] || "object" + : typeof a + }, + globalEval: function (a) { + p(a) + }, + camelCase: function (a) { + return a + .replace(t, "ms-") + .replace(u, v) + }, + nodeName: function (a, b) { + return a.nodeName && a + .nodeName + .toLowerCase() === b.toLowerCase() + }, + each: function (a, b) { + var c, + d = 0; + if (w(a)) { + for (c = a.length; d < c; d++) + if (b.call(a[d], d, a[d]) === !1) + break + } + else + for (d in a) + if (b.call(a[d], d, a[d]) === !1) + break; + return a + }, + trim: function (a) { + return null == a + ? "" + : (a + "").replace(s, "") + }, + makeArray: function (a, b) { + var c = b || []; + return null != a && (w(Object(a)) + ? r.merge(c, "string" == typeof a + ? [a] + : a) + : h.call(c, a)), + c + }, + inArray: function (a, b, c) { + return null == b + ? -1 + : i.call(b, a, c) + }, + merge: function (a, b) { + for (var c =+ b.length, d = 0, e = a.length; d < c; d++) + a[e++] = b[d]; + return a.length = e, + a + }, + grep: function (a, b, c) { + for (var d, e = [], f = 0, g = a.length, h = !c; f < g; f++) + d = !b(a[f], f), + d !== h && e.push(a[f]); + return e + }, + map: function (a, b, c) { + var d, + e, + f = 0, + h = []; + if (w(a)) + for (d = a.length; f < d; f++) + e = b(a[f], f, c), + null != e && h.push(e); + else + for (f in a) + e = b(a[f], f, c), + null != e && h.push(e); + return g.apply([], h) + }, + guid: 1, + proxy: function (a, b) { + var c, + d, + e; + if ("string" == typeof b && (c = a[b], b = a, a = c), r.isFunction(a)) + return d = f.call(arguments, 2), + e = function () { + return a.apply(b || this, d.concat(f.call(arguments))) + } + , + e.guid = a.guid = a.guid || r.guid++, + e + }, + now: Date.now, + support: o + }), + "function" == typeof Symbol && (r.fn[Symbol.iterator] = c[Symbol.iterator]), + r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (a, b) { + j["[object " + b + "]"] = b.toLowerCase() + }); + function w(a) { + var b = !!a && "length" in a && a.length, + c = r.type(a); + return "function" !== c && !r.isWindow(a) && ("array" === c || 0 === b || "number" == typeof b && b > 0 && b - 1 in a) + } + var x = function (a) { + var b, + c, + d, + e, + f, + g, + h, + i, + j, + k, + l, + m, + n, + o, + p, + q, + r, + s, + t, + u = "sizzle" + 1 * new Date, + v = a.document, + w = 0, + x = 0, + y = ha(), + z = ha(), + A = ha(), + B = function (a, b) { + return a === b && (l = !0), + 0 + }, + C = {}.hasOwnProperty, + D = [], + E = D.pop, + F = D.push, + G = D.push, + H = D.slice, + I = function (a, b) { + for (var c = 0, d = a.length; c < d; c++) + if (a[c] === b) + return c; + return -1 + }, + J = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|l" + + "oop|multiple|open|readonly|required|scoped", + K = "[\\x20\\t\\r\\n\\f]", + L = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", + M = "\\[" + K + "*(" + L + ")(?:" + K + "*([*^$|!~]?=)" + K + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + L + "))|)" + K + "*\\]", + N = ":(" + L + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[" + + "\\]]|" + M + ")*)|.*)\\)|)", + O = new RegExp(K + "+", "g"), + P = new RegExp("^" + K + "+|((?:^|[^\\\\])(?:\\\\.)*)" + K + "+$", "g"), + Q = new RegExp("^" + K + "*," + K + "*"), + R = new RegExp("^" + K + "*([>+~]|" + K + ")" + K + "*"), + S = new RegExp("=" + K + "*([^\\]'\"]*?)" + K + "*\\]", "g"), + T = new RegExp(N), + U = new RegExp("^" + L + "$"), + V = { + ID: new RegExp("^#(" + L + ")"), + CLASS: new RegExp("^\\.(" + L + ")"), + TAG: new RegExp("^(" + L + "|[*])"), + ATTR: new RegExp("^" + M), + PSEUDO: new RegExp("^" + N), + CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + K + "*(even|odd|(([+-]|)(\\d*)n|)" + K + "*(?:([+-]|)" + K + "*(\\d+)|))" + K + "*\\)|)", "i"), + bool: new RegExp("^(?:" + J + ")$", "i"), + needsContext: new RegExp("^" + K + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + K + "*((?:-\\d)?\\d*)" + K + "*\\)|)(?=[^-]|$)", "i") + }, + W = /^(?:input|select|textarea|button)$/i, + X = /^h\d$/i, + Y = /^[^{]+\{\s*\[native \w/, + Z = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + $ = /[+~]/, + _ = new RegExp("\\\\([\\da-f]{1,6}" + K + "?|(" + K + ")|.)", "ig"), + aa = function (a, b, c) { + var d = "0x" + b - 65536; + return d !== d || c + ? b + : d < 0 + ? String.fromCharCode(d + 65536) + : String.fromCharCode(d >> 10 | 55296, 1023 & d | 56320) + }, + ba = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, + ca = function (a, b) { + return b + ? "\0" === a + ? "\ufffd" + : a.slice(0, -1) + "\\" + a + .charCodeAt(a.length - 1) + .toString(16) + " " + : "\\" + a + }, + da = function () { + m() + }, + ea = ta(function (a) { + return a.disabled === !0 && ("form" in a || "label" in a) + }, { + dir: "parentNode", + next: "legend" + }); + try { + G.apply(D = H.call(v.childNodes), v.childNodes), + D[v.childNodes.length].nodeType + } catch (fa) { + G = { + apply: D.length + ? function (a, b) { + F.apply(a, H.call(b)) + } + : function (a, b) { + var c = a.length, + d = 0; + while (a[c++] = b[d++]) + ; + a.length = c - 1 + } + } + } + function ga(a, b, d, e) { + var f, + h, + j, + k, + l, + o, + r, + s = b && b.ownerDocument, + w = b + ? b.nodeType + : 9; + if (d = d || [], "string" != typeof a || !a || 1 !== w && 9 !== w && 11 !== w) + return d; + if (!e && ((b + ? b.ownerDocument || b + : v) !== n && m(b), b = b || n, p)) { + if (11 !== w && (l = Z.exec(a))) + if (f = l[1]) { + if (9 === w) { + if (!(j = b.getElementById(f))) + return d; + if (j.id === f) + return d.push(j), + d + } else if (s && (j = s.getElementById(f)) && t(b, j) && j.id === f) + return d.push(j), + d + } + else { + if (l[2]) + return G.apply(d, b.getElementsByTagName(a)), + d; + if ((f = l[3]) && c.getElementsByClassName && b.getElementsByClassName) + return G.apply(d, b.getElementsByClassName(f)), + d + } + if (c.qsa && !A[a + " "] && (!q || !q.test(a))) { + if (1 !== w) + s = b, + r = a; + else if ("object" !== b.nodeName.toLowerCase()) { + (k = b.getAttribute("id")) + ? k = k.replace(ba, ca) + : b.setAttribute("id", k = u), + o = g(a), + h = o.length; + while (h--) + o[h] = "#" + k + " " + sa(o[h]); + r = o.join(","), + s = $.test(a) && qa(b.parentNode) || b + } + if (r) + try { + return G.apply(d, s.querySelectorAll(r)), + d + } catch (x) {} + finally { + k === u && b.removeAttribute("id") + } + } + } + return i(a.replace(P, "$1"), b, d, e) + } + function ha() { + var a = []; + function b(c, e) { + return a.push(c + " ") > d.cacheLength && delete b[a.shift()], + b[c + " "] = e + } + return b + } + function ia(a) { + return a[u] = !0, + a + } + function ja(a) { + var b = n.createElement("fieldset"); + try { + return !!a(b) + } catch (c) { + return !1 + } finally { + b.parentNode && b + .parentNode + .removeChild(b), + b = null + } + } + function ka(a, b) { + var c = a.split("|"), + e = c.length; + while (e--) + d.attrHandle[c[e]] = b + } + function la(a, b) { + var c = b && a, + d = c && 1 === a.nodeType && 1 === b.nodeType && a.sourceIndex - b.sourceIndex; + if (d) + return d; + if (c) + while (c = c.nextSibling) + if (c === b) + return -1; + return a + ? 1 + : -1 + } + function ma(a) { + return function (b) { + var c = b + .nodeName + .toLowerCase(); + return "input" === c && b.type === a + } + } + function na(a) { + return function (b) { + var c = b + .nodeName + .toLowerCase(); + return ("input" === c || "button" === c) && b.type === a + } + } + function oa(a) { + return function (b) { + return "form" in b + ? b.parentNode && b.disabled === !1 + ? "label" in b + ? "label" in b.parentNode + ? b.parentNode.disabled === a + : b.disabled === a + : b.isDisabled === a || b.isDisabled !== !a && ea(b) === a + : b.disabled === a + : "label" in b && b.disabled === a + } + } + function pa(a) { + return ia(function (b) { + return b =+ b, + ia(function (c, d) { + var e, + f = a([], c.length, b), + g = f.length; + while (g--) + c[e = f[g]] && (c[e] = !(d[e] = c[e])) + }) + }) + } + function qa(a) { + return a && "undefined" != typeof a.getElementsByTagName && a + } + c = ga.support = {}, + f = ga.isXML = function (a) { + var b = a && (a.ownerDocument || a).documentElement; + return !!b && "HTML" !== b.nodeName + }, + m = ga.setDocument = function (a) { + var b, + e, + g = a + ? a.ownerDocument || a + : v; + return g !== n && 9 === g.nodeType && g.documentElement + ? (n = g, o = n.documentElement, p = !f(n), v !== n && (e = n.defaultView) && e.top !== e && (e.addEventListener + ? e.addEventListener("unload", da, !1) + : e.attachEvent && e.attachEvent("onunload", da)), c.attributes = ja(function (a) { + return a.className = "i", + !a.getAttribute("className") + }), c.getElementsByTagName = ja(function (a) { + return a.appendChild(n.createComment("")), + !a + .getElementsByTagName("*") + .length + }), c.getElementsByClassName = Y.test(n.getElementsByClassName), c.getById = ja(function (a) { + return o + .appendChild(a) + .id = u, + !n.getElementsByName || !n + .getElementsByName(u) + .length + }), c.getById + ? (d.filter.ID = function (a) { + var b = a.replace(_, aa); + return function (a) { + return a.getAttribute("id") === b + } + }, + d.find.ID = function (a, b) { + if ("undefined" != typeof b.getElementById && p) { + var c = b.getElementById(a); + return c + ? [c] + : [] + } + }) + : (d.filter.ID = function (a) { + var b = a.replace(_, aa); + return function (a) { + var c = "undefined" != typeof a.getAttributeNode && a.getAttributeNode("id"); + return c && c.value === b + } + }, + d.find.ID = function (a, b) { + if ("undefined" != typeof b.getElementById && p) { + var c, + d, + e, + f = b.getElementById(a); + if (f) { + if (c = f.getAttributeNode("id"), c && c.value === a) + return [f]; + e = b.getElementsByName(a), + d = 0; + while (f = e[d++]) + if (c = f.getAttributeNode("id"), c && c.value === a) + return [f] + } + return [] + } + }), d.find.TAG = c.getElementsByTagName + ? function (a, b) { + return "undefined" != typeof b.getElementsByTagName + ? b.getElementsByTagName(a) + : c.qsa + ? b.querySelectorAll(a) + : void 0 + } + : function (a, b) { + var c, + d = [], + e = 0, + f = b.getElementsByTagName(a); + if ("*" === a) { + while (c = f[e++]) + 1 === c.nodeType && d.push(c); + return d + } + return f + }, + d.find.CLASS = c.getElementsByClassName && function (a, b) { + if ("undefined" != typeof b.getElementsByClassName && p) + return b.getElementsByClassName(a) + }, + r = [], + q = [], + (c.qsa = Y.test(n.querySelectorAll)) && (ja(function (a) { + o + .appendChild(a) + .innerHTML = "", + a + .querySelectorAll("[msallowcapture^='']") + .length && q.push("[*^$]=" + K + "*(?:''|\"\")"), + a + .querySelectorAll("[selected]") + .length || q.push("\\[" + K + "*(?:value|" + J + ")"), + a + .querySelectorAll("[id~=" + u + "-]") + .length || q.push("~="), + a + .querySelectorAll(":checked") + .length || q.push(":checked"), + a + .querySelectorAll("a#" + u + "+*") + .length || q.push(".#.+[+~]") + }), ja(function (a) { + a.innerHTML = "", + a + .firstChild + .setAttribute("value", ""), + "" === a + .firstChild + .getAttribute("value") + }) || ka("value", function (a, b, c) { + if (!c && "input" === a.nodeName.toLowerCase()) + return a.defaultValue + }), + ja(function (a) { + return null == a.getAttribute("disabled") + }) || ka(J, function (a, b, c) { + var d; + if (!c) + return a[b] === !0 + ? b.toLowerCase() + : (d = a.getAttributeNode(b)) && d.specified + ? d.value + : null + }), + ga + }(a); + r.find = x, + r.expr = x.selectors, + r.expr[":"] = r.expr.pseudos, + r.uniqueSort = r.unique = x.uniqueSort, + r.text = x.getText, + r.isXMLDoc = x.isXML, + r.contains = x.contains, + r.escapeSelector = x.escape; + var y = function (a, b, c) { + var d = [], + e = void 0 !== c; + while ((a = a[b]) && 9 !== a.nodeType) + if (1 === a.nodeType) { + if (e && r(a).is(c)) + break; + d.push(a) + } + return d + }, + z = function (a, b) { + for (var c = []; a; a = a.nextSibling) + 1 === a.nodeType && a !== b && c.push(a); + return c + }, + A = r.expr.match.needsContext, + B = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i, + C = /^.[^:#\[\.,]*$/; + function D(a, b, c) { + return r.isFunction(b) + ? r.grep(a, function (a, d) { + return !!b.call(a, d, a) !== c + }) + : b.nodeType + ? r.grep(a, function (a) { + return a === b !== c + }) + : "string" != typeof b + ? r.grep(a, function (a) { + return i.call(b, a) > -1 !== c + }) + : C.test(b) + ? r.filter(b, a, c) + : (b = r.filter(b, a), r.grep(a, function (a) { + return i.call(b, a) > -1 !== c && 1 === a.nodeType + })) + } + r.filter = function (a, b, c) { + var d = b[0]; + return c && (a = ":not(" + a + ")"), + 1 === b.length && 1 === d.nodeType + ? r + .find + .matchesSelector(d, a) + ? [d] + : [] + : r + .find + .matches(a, r.grep(b, function (a) { + return 1 === a.nodeType + })) + }, + r + .fn + .extend({ + find: function (a) { + var b, + c, + d = this.length, + e = this; + if ("string" != typeof a) + return this.pushStack(r(a).filter(function () { + for (b = 0; b < d; b++) + if (r.contains(e[b], this)) + return !0 + })); + for (c = this.pushStack([]), b = 0; b < d; b++) + r.find(a, e[b], c); + return d > 1 + ? r.uniqueSort(c) + : c + }, + filter: function (a) { + return this.pushStack(D(this, a || [], !1)) + }, + not: function (a) { + return this.pushStack(D(this, a || [], !0)) + }, + is: function (a) { + return !!D(this, "string" == typeof a && A.test(a) + ? r(a) + : a || [], !1).length + } + }); + var E, + F = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, + G = r.fn.init = function (a, b, c) { + var e, + f; + if (!a) + return this; + if (c = c || E, "string" == typeof a) { + if (e = "<" === a[0] && ">" === a[a.length - 1] && a.length >= 3 + ? [null, a, null] + : F.exec(a), !e || !e[1] && b) + return !b || b.jquery + ? (b || c).find(a) + : this.constructor(b).find(a); + if (e[1]) { + if (b = b instanceof r + ? b[0] + : b, r.merge(this, r.parseHTML(e[1], b && b.nodeType + ? b.ownerDocument || b + : d, !0)), B.test(e[1]) && r.isPlainObject(b)) + for (e in b) + r.isFunction(this[e]) + ? this[e](b[e]) + : this.attr(e, b[e]); + return this + } + return f = d.getElementById(e[2]), + f && (this[0] = f, this.length = 1), + this + } + return a.nodeType + ? (this[0] = a, this.length = 1, this) + : r.isFunction(a) + ? void 0 !== c.ready + ? c.ready(a) + : a(r) + : r.makeArray(a, this) + }; + G.prototype = r.fn, + E = r(d); + var H = /^(?:parents|prev(?:Until|All))/, + I = { + children: !0, + contents: !0, + next: !0, + prev: !0 + }; + r + .fn + .extend({ + has: function (a) { + var b = r(a, this), + c = b.length; + return this.filter(function () { + for (var a = 0; a < c; a++) + if (r.contains(this, b[a])) + return !0 + }) + }, + closest: function (a, b) { + var c, + d = 0, + e = this.length, + f = [], + g = "string" != typeof a && r(a); + if (!A.test(a)) + for (; d < e; d++) + for (c = this[d]; c && c !== b; c = c.parentNode) + if (c.nodeType < 11 && (g + ? g.index(c) > -1 + : 1 === c.nodeType && r.find.matchesSelector(c, a))) { + f.push(c); + break + } + return this.pushStack(f.length > 1 + ? r.uniqueSort(f) + : f) + }, + index: function (a) { + return a + ? "string" == typeof a + ? i.call(r(a), this[0]) + : i.call(this, a.jquery + ? a[0] + : a) + : this[0] && this[0].parentNode + ? this + .first() + .prevAll() + .length + : -1 + }, + add: function (a, b) { + return this.pushStack(r.uniqueSort(r.merge(this.get(), r(a, b)))) + }, + addBack: function (a) { + return this.add(null == a + ? this.prevObject + : this.prevObject.filter(a)) + } + }); + function J(a, b) { + while ((a = a[b]) && 1 !== a.nodeType) + ; + return a + } + r + .each({ + parent: function (a) { + var b = a.parentNode; + return b && 11 !== b.nodeType + ? b + : null + }, + parents: function (a) { + return y(a, "parentNode") + }, + parentsUntil: function (a, b, c) { + return y(a, "parentNode", c) + }, + next: function (a) { + return J(a, "nextSibling") + }, + prev: function (a) { + return J(a, "previousSibling") + }, + nextAll: function (a) { + return y(a, "nextSibling") + }, + prevAll: function (a) { + return y(a, "previousSibling") + }, + nextUntil: function (a, b, c) { + return y(a, "nextSibling", c) + }, + prevUntil: function (a, b, c) { + return y(a, "previousSibling", c) + }, + siblings: function (a) { + return z((a.parentNode || {}).firstChild, a) + }, + children: function (a) { + return z(a.firstChild) + }, + contents: function (a) { + return a.contentDocument || r.merge([], a.childNodes) + } + }, function (a, b) { + r.fn[a] = function (c, d) { + var e = r.map(this, b, c); + return "Until" !== a.slice(-5) && (d = c), + d && "string" == typeof d && (e = r.filter(d, e)), + this.length > 1 && (I[a] || r.uniqueSort(e), H.test(a) && e.reverse()), + this.pushStack(e) + } + }); + var K = /[^\x20\t\r\n\f]+/g; + function L(a) { + var b = {}; + return r.each(a.match(K) || [], function (a, c) { + b[c] = !0 + }), + b + } + r.Callbacks = function (a) { + a = "string" == typeof a + ? L(a) + : r.extend({}, a); + var b, + c, + d, + e, + f = [], + g = [], + h = -1, + i = function () { + for (e = a.once, d = b = !0; g.length; h = -1) { + c = g.shift(); + while (++h < f.length) + f[h].apply(c[0], c[1]) === !1 && a.stopOnFalse && (h = f.length, c = !1) + } + a.memory || (c = !1), + b = !1, + e && (f = c + ? [] + : "") + }, + j = { + add: function () { + return f && (c && !b && (h = f.length - 1, g.push(c)), function d(b) { + r + .each(b, function (b, c) { + r.isFunction(c) + ? a.unique && j.has(c) || f.push(c) + : c && c.length && "string" !== r.type(c) && d(c) + }) + }(arguments), + c && !b && i()), + this + }, + remove: function () { + return r.each(arguments, function (a, b) { + var c; + while ((c = r.inArray(b, f, c)) > -1) + f.splice(c, 1), + c <= h && h-- + }), + this + }, + has: function (a) { + return a + ? r.inArray(a, f) > -1 + : f.length > 0 + }, + empty: function () { + return f && (f = []), + this + }, + disable: function () { + return e = g = [], + f = c = "", + this + }, + disabled: function () { + return !f + }, + lock: function () { + return e = g = [], + c || b || (f = c = ""), + this + }, + locked: function () { + return !!e + }, + fireWith: function (a, c) { + return e || (c = c || [], c = [ + a, c.slice + ? c.slice() + : c + ], g.push(c), b || i()), + this + }, + fire: function () { + return j.fireWith(this, arguments), + this + }, + fired: function () { + return !!d + } + }; + return j + }; + function M(a) { + return a + } + function N(a) { + throw a + } + function O(a, b, c) { + var d; + try { + a && r.isFunction(d = a.promise) + ? d + .call(a) + .done(b) + .fail(c) + : a && r.isFunction(d = a.then) + ? d.call(a, b, c) + : b.call(void 0, a) + } catch (a) { + c.call(void 0, a) + } + } + r.extend({ + Deferred: function (b) { + var c = [ + [ + "notify", "progress", r.Callbacks("memory"), + r.Callbacks("memory"), + 2 + ], + [ + "resolve", "done", r.Callbacks("once memory"), + r.Callbacks("once memory"), + 0, + "resolved" + ], + [ + "reject", "fail", r.Callbacks("once memory"), + r.Callbacks("once memory"), + 1, + "rejected" + ] + ], + d = "pending", + e = { + state: function () { + return d + }, + always: function () { + return f + .done(arguments) + .fail(arguments), + this + }, + "catch": function (a) { + return e.then(null, a) + }, + pipe: function () { + var a = arguments; + return r.Deferred(function (b) { + r + .each(c, function (c, d) { + var e = r.isFunction(a[d[4]]) && a[d[4]]; + f[d[1]](function () { + var a = e && e.apply(this, arguments); + a && r.isFunction(a.promise) + ? a + .promise() + .progress(b.notify) + .done(b.resolve) + .fail(b.reject) + : b[d[0] + "With"](this, e + ? [a] + : arguments) + }) + }), + a = null + }).promise() + }, + then: function (b, d, e) { + var f = 0; + function g(b, c, d, e) { + return function () { + var h = this, + i = arguments, + j = function () { + var a, + j; + if (!(b < f)) { + if (a = d.apply(h, i), a === c.promise()) + throw new TypeError("Thenable self-resolution"); + j = a && ("object" == typeof a || "function" == typeof a) && a.then, + r.isFunction(j) + ? e + ? j.call(a, g(f, c, M, e), g(f, c, N, e)) + : (f++, j.call(a, g(f, c, M, e), g(f, c, N, e), g(f, c, M, c.notifyWith))) + : (d !== M && (h = void 0, i = [a]), (e || c.resolveWith)(h, i)) + } + }, + k = e + ? j + : function () { + try { + j() + } catch (a) { + r.Deferred.exceptionHook && r + .Deferred + .exceptionHook(a, k.stackTrace), + b + 1 >= f && (d !== N && (h = void 0, i = [a]), c.rejectWith(h, i)) + } + }; + b + ? k() + : (r.Deferred.getStackHook && (k.stackTrace = r.Deferred.getStackHook()), a.setTimeout(k)) + } + } + return r.Deferred(function (a) { + c[0][3].add(g(0, a, r.isFunction(e) + ? e + : M, a.notifyWith)), + c[1][3].add(g(0, a, r.isFunction(b) + ? b + : M)), + c[2][3].add(g(0, a, r.isFunction(d) + ? d + : N)) + }).promise() + }, + promise: function (a) { + return null != a + ? r.extend(a, e) + : e + } + }, + f = {}; + return r.each(c, function (a, b) { + var g = b[2], + h = b[5]; + e[b[1]] = g.add, + h && g.add(function () { + d = h + }, c[3 - a][2].disable, c[0][2].lock), + g.add(b[3].fire), + f[b[0]] = function () { + return f[b[0] + "With"](this === f + ? void 0 + : this, arguments), + this + }, + f[b[0] + "With"] = g.fireWith + }), + e.promise(f), + b && b.call(f, f), + f + }, + when: function (a) { + var b = arguments.length, + c = b, + d = Array(c), + e = f.call(arguments), + g = r.Deferred(), + h = function (a) { + return function (c) { + d[a] = this, + e[a] = arguments.length > 1 + ? f.call(arguments) + : c, + --b || g.resolveWith(d, e) + } + }; + if (b <= 1 && (O(a, g.done(h(c)).resolve, g.reject), "pending" === g.state() || r.isFunction(e[c] && e[c].then))) + return g.then(); + while (c--) + O(e[c], h(c), g.reject); + return g.promise() + } + }); + var P = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + r.Deferred.exceptionHook = function (b, c) { + a.console && a.console.warn && b && P.test(b.name) && a + .console + .warn("jQuery.Deferred exception: " + b.message, b.stack, c) + }, + r.readyException = function (b) { + a + .setTimeout(function () { + throw b + }) + }; + var Q = r.Deferred(); + r.fn.ready = function (a) { + return Q.then(a)["catch"](function (a) { + r.readyException(a) + }), + this + }, + r.extend({ + isReady: !1, + readyWait: 1, + holdReady: function (a) { + a + ? r.readyWait++ + : r.ready(!0) + }, + ready: function (a) { + (a === !0 + ? --r.readyWait + : r.isReady) || (r.isReady = !0, a !== !0 && --r.readyWait > 0 || Q.resolveWith(d, [r])) + } + }), + r.ready.then = Q.then; + function R() { + d.removeEventListener("DOMContentLoaded", R), + a.removeEventListener("load", R), + r.ready() + } + "complete" === d.readyState || "loading" !== d.readyState && !d.documentElement.doScroll + ? a.setTimeout(r.ready) + : (d.addEventListener("DOMContentLoaded", R), a.addEventListener("load", R)); + var S = function (a, b, c, d, e, f, g) { + var h = 0, + i = a.length, + j = null == c; + if ("object" === r.type(c)) { + e = !0; + for (h in c) + S(a, b, h, c[h], !0, f, g) + } else if (void 0 !== d && (e = !0, r.isFunction(d) || (g = !0), j && (g + ? (b.call(a, d), b = null) + : (j = b, b = function (a, b, c) { + return j.call(r(a), c) + })), b)) + for (; h < i; h++) + b(a[h], c, g + ? d + : d.call(a[h], h, b(a[h], c))); + return e + ? a + : j + ? b.call(a) + : i + ? b(a[0], c) + : f + }, + T = function (a) { + return 1 === a.nodeType || 9 === a.nodeType || !+ a.nodeType + }; + function U() { + this.expando = r.expando + U.uid++ + } + U.uid = 1, + U.prototype = { + cache: function (a) { + var b = a[this.expando]; + return b || (b = {}, T(a) && (a.nodeType + ? a[this.expando] = b + : Object.defineProperty(a, this.expando, { + value: b, + configurable: !0 + }))), + b + }, + set: function (a, b, c) { + var d, + e = this.cache(a); + if ("string" == typeof b) + e[r.camelCase(b)] = c; + else + for (d in b) + e[r.camelCase(d)] = b[d]; + return e + }, + get: function (a, b) { + return void 0 === b + ? this.cache(a) + : a[this.expando] && a[this.expando][r.camelCase(b)] + }, + access: function (a, b, c) { + return void 0 === b || b && "string" == typeof b && void 0 === c + ? this.get(a, b) + : (this.set(a, b, c), void 0 !== c + ? c + : b) + }, + remove: function (a, b) { + var c, + d = a[this.expando]; + if (void 0 !== d) { + if (void 0 !== b) { + r.isArray(b) + ? b = b.map(r.camelCase) + : (b = r.camelCase(b), b = b in d + ? [b] + : b.match(K) || []), + c = b.length; + while (c--) + delete d[b[c]] + } + (void 0 === b || r.isEmptyObject(d)) && (a.nodeType + ? a[this.expando] = void 0 + : delete a[this.expando]) + } + }, + hasData: function (a) { + var b = a[this.expando]; + return void 0 !== b && !r.isEmptyObject(b) + } + }; + var V = new U, + W = new U, + X = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, + Y = /[A-Z]/g; + function Z(a) { + return "true" === a || "false" !== a && ("null" === a + ? null + : a ===+ a + "" ?+ a : X.test(a) + ? JSON.parse(a) + : a) + } + function $(a, b, c) { + var d; + if (void 0 === c && 1 === a.nodeType) + if (d = "data-" + b.replace(Y, "-$&").toLowerCase(), c = a.getAttribute(d), "string" == typeof c) { + try { + c = Z(c) + } catch (e) {} + W.set(a, b, c) + } else + c = void 0; + return c + } + r.extend({ + hasData: function (a) { + return W.hasData(a) || V.hasData(a) + }, + data: function (a, b, c) { + return W.access(a, b, c) + }, + removeData: function (a, b) { + W.remove(a, b) + }, + _data: function (a, b, c) { + return V.access(a, b, c) + }, + _removeData: function (a, b) { + V.remove(a, b) + } + }), + r + .fn + .extend({ + data: function (a, b) { + var c, + d, + e, + f = this[0], + g = f && f.attributes; + if (void 0 === a) { + if (this.length && (e = W.get(f), 1 === f.nodeType && !V.get(f, "hasDataAttrs"))) { + c = g.length; + while (c--) + g[c] && (d = g[c].name, 0 === d.indexOf("data-") && (d = r.camelCase(d.slice(5)), $(f, d, e[d]))); + V.set(f, "hasDataAttrs", !0) + } + return e + } + return "object" == typeof a + ? this.each(function () { + W.set(this, a) + }) + : S(this, function (b) { + var c; + if (f && void 0 === b) { + if (c = W.get(f, a), void 0 !== c) + return c; + if (c = $(f, a), void 0 !== c) + return c + } else + this + .each(function () { + W.set(this, a, b) + }) + }, null, b, arguments.length > 1, null, !0) + }, + removeData: function (a) { + return this.each(function () { + W.remove(this, a) + }) + } + }), + r.extend({ + queue: function (a, b, c) { + var d; + if (a) + return b = (b || "fx") + "queue", + d = V.get(a, b), + c && (!d || r.isArray(c) + ? d = V.access(a, b, r.makeArray(c)) + : d.push(c)), + d || [] + }, + dequeue: function (a, b) { + b = b || "fx"; + var c = r.queue(a, b), + d = c.length, + e = c.shift(), + f = r._queueHooks(a, b), + g = function () { + r.dequeue(a, b) + }; + "inprogress" === e && (e = c.shift(), d--), + e && ("fx" === b && c.unshift("inprogress"), delete f.stop, e.call(a, g, f)), + !d && f && f + .empty + .fire() + }, + _queueHooks: function (a, b) { + var c = b + "queueHooks"; + return V.get(a, c) || V.access(a, c, { + empty: r + .Callbacks("once memory") + .add(function () { + V.remove(a, [ + b + "queue", + c + ]) + }) + }) + } + }), + r + .fn + .extend({ + queue: function (a, b) { + var c = 2; + return "string" != typeof a && (b = a, a = "fx", c--), + arguments.length < c + ? r.queue(this[0], a) + : void 0 === b + ? this + : this.each(function () { + var c = r.queue(this, a, b); + r._queueHooks(this, a), + "fx" === a && "inprogress" !== c[0] && r.dequeue(this, a) + }) + }, + dequeue: function (a) { + return this.each(function () { + r.dequeue(this, a) + }) + }, + clearQueue: function (a) { + return this.queue(a || "fx", []) + }, + promise: function (a, b) { + var c, + d = 1, + e = r.Deferred(), + f = this, + g = this.length, + h = function () { + --d || e.resolveWith(f, [f]) + }; + "string" != typeof a && (b = a, a = void 0), + a = a || "fx"; + while (g--) + c = V.get(f[g], a + "queueHooks"), + c && c.empty && (d++, c.empty.add(h)); + return h(), + e.promise(b) + } + }); + var _ = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source, + aa = new RegExp("^(?:([+-])=|)(" + _ + ")([a-z%]*)$", "i"), + ba = [ + "Top", "Right", "Bottom", "Left" + ], + ca = function (a, b) { + return a = b || a, + "none" === a.style.display || "" === a.style.display && r.contains(a.ownerDocument, a) && "none" === r.css(a, "display") + }, + da = function (a, b, c, d) { + var e, + f, + g = {}; + for (f in b) + g[f] = a.style[f], + a.style[f] = b[f]; + e = c.apply(a, d || []); + for (f in b) + a.style[f] = g[f]; + return e + }; + function ea(a, b, c, d) { + var e, + f = 1, + g = 20, + h = d + ? function () { + return d.cur() + } + : function () { + return r.css(a, b, "") + }, + i = h(), + j = c && c[3] || (r.cssNumber[b] + ? "" + : "px"), + k = (r.cssNumber[b] || "px" !== j &&+ i) && aa.exec(r.css(a, b)); + if (k && k[3] !== j) { + j = j || k[3], + c = c || [], + k =+ i || 1; + do + f = f || ".5", + k /= f, + r.style(a, b, k + j); + while (f !== (f = h() / i) && 1 !== f && --g) + } + return c && (k =+ k ||+ i || 0, e = c[1] + ? k + (c[1] + 1) * c[2] :+ c[2], d && (d.unit = j, d.start = k, d.end = e)), + e + } + var fa = {}; + function ga(a) { + var b, + c = a.ownerDocument, + d = a.nodeName, + e = fa[d]; + return e + ? e + : (b = c.body.appendChild(c.createElement(d)), e = r.css(b, "display"), b.parentNode.removeChild(b), "none" === e && (e = "block"), fa[d] = e, e) + } + function ha(a, b) { + for (var c, d, e = [], f = 0, g = a.length; f < g; f++) + d = a[f], + d.style && (c = d.style.display, b + ? ("none" === c && (e[f] = V.get(d, "display") || null, e[f] || (d.style.display = "")), "" === d.style.display && ca(d) && (e[f] = ga(d))) + : "none" !== c && (e[f] = "none", V.set(d, "display", c))); + for (f = 0; f < g; f++) + null != e[f] && (a[f].style.display = e[f]); + return a + } + r + .fn + .extend({ + show: function () { + return ha(this, !0) + }, + hide: function () { + return ha(this) + }, + toggle: function (a) { + return "boolean" == typeof a + ? a + ? this.show() + : this.hide() + : this.each(function () { + ca(this) + ? r(this).show() + : r(this).hide() + }) + } + }); + var ia = /^(?:checkbox|radio)$/i, + ja = /<([a-z][^\/\0>\x20\t\r\n\f]+)/i, + ka = /^$|\/(?:java|ecma)script/i, + la = { + option: [ + 1, "" + ], + thead: [ + 1, "", "
" + ], + col: [ + 2, "", "
" + ], + tr: [ + 2, "", "
" + ], + td: [ + 3, "", "
" + ], + _default: [0, "", ""] + }; + la.optgroup = la.option, + la.tbody = la.tfoot = la.colgroup = la.caption = la.thead, + la.th = la.td; + function ma(a, b) { + var c; + return c = "undefined" != typeof a.getElementsByTagName + ? a.getElementsByTagName(b || "*") + : "undefined" != typeof a.querySelectorAll + ? a.querySelectorAll(b || "*") + : [], + void 0 === b || b && r.nodeName(a, b) + ? r.merge([a], c) + : c + } + function na(a, b) { + for (var c = 0, d = a.length; c < d; c++) + V.set(a[c], "globalEval", !b || V.get(b[c], "globalEval")) + } + var oa = /<|&#?\w+;/; + function pa(a, b, c, d, e) { + for (var f, g, h, i, j, k, l = b.createDocumentFragment(), m = [], n = 0, o = a.length; n < o; n++) + if (f = a[n], f || 0 === f) + if ("object" === r.type(f)) + r.merge(m, f.nodeType + ? [f] + : f); + else if (oa.test(f)) { + g = g || l.appendChild(b.createElement("div")), + h = (ja.exec(f) || ["", ""])[1].toLowerCase(), + i = la[h] || la._default, + g.innerHTML = i[1] + r.htmlPrefilter(f) + i[2], + k = i[0]; + while (k--) + g = g.lastChild; + r.merge(m, g.childNodes), + g = l.firstChild, + g.textContent = "" + } + else + m.push(b.createTextNode(f)); + l.textContent = "", + n = 0; + while (f = m[n++]) + if (d && r.inArray(f, d) > -1) + e && e.push(f); + else if (j = r.contains(f.ownerDocument, f), g = ma(l.appendChild(f), "script"), j && na(g), c) { + k = 0; + while (f = g[k++]) + ka.test(f.type || "") && c.push(f) + } + return l + } + !function () { + var a = d.createDocumentFragment(), + b = a.appendChild(d.createElement("div")), + c = d.createElement("input"); + c.setAttribute("type", "radio"), + c.setAttribute("checked", "checked"), + c.setAttribute("name", "t"), + b.appendChild(c), + o.checkClone = b + .cloneNode(!0) + .cloneNode(!0) + .lastChild + .checked, + b.innerHTML = "", + o.noCloneChecked = !!b + .cloneNode(!0) + .lastChild + .defaultValue + }(); + var qa = d.documentElement, + ra = /^key/, + sa = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, + ta = /^([^.]*)(?:\.(.+)|)/; + function ua() { + return !0 + } + function va() { + return !1 + } + function wa() { + try { + return d.activeElement + } catch (a) {} + } + function xa(a, b, c, d, e, f) { + var g, + h; + if ("object" == typeof b) { + "string" != typeof c && (d = d || c, c = void 0); + for (h in b) + xa(a, h, c, d, b[h], f); + return a + } + if (null == d && null == e + ? (e = c, d = c = void 0) + : null == e && ("string" == typeof c + ? (e = d, d = void 0) + : (e = d, d = c, c = void 0)), e === !1) + e = va; + else if (!e) + return a; + return 1 === f && (g = e, e = function (a) { + return r().off(a), + g.apply(this, arguments) + }, + e.guid = g.guid || (g.guid = r.guid++)), + a.each(function () { + r + .event + .add(this, b, e, d, c) + }) + } + r.event = { + global: {}, + add: function (a, b, c, d, e) { + var f, + g, + h, + i, + j, + k, + l, + m, + n, + o, + p, + q = V.get(a); + if (q) { + c.handler && (f = c, c = f.handler, e = f.selector), + e && r + .find + .matchesSelector(qa, e), + c.guid || (c.guid = r.guid++), + (i = q.events) || (i = q.events = {}), + (g = q.handle) || (g = q.handle = function (b) { + return "undefined" != typeof r && r.event.triggered !== b.type + ? r + .event + .dispatch + .apply(a, arguments) + : void 0 + }), + b = (b || "").match(K) || [""], + j = b.length; + while (j--) + h = ta.exec(b[j]) || [], + n = p = h[1], + o = (h[2] || "").split(".").sort(), + n && (l = r.event.special[n] || {}, n = (e + ? l.delegateType + : l.bindType) || n, l = r.event.special[n] || {}, k = r.extend({ + type: n, + origType: p, + data: d, + handler: c, + guid: c.guid, + selector: e, + needsContext: e && r + .expr + .match + .needsContext + .test(e), + namespace: o.join(".") + }, f), (m = i[n]) || (m = i[n] = [], m.delegateCount = 0, l.setup && l.setup.call(a, d, o, g) !== !1 || a.addEventListener && a.addEventListener(n, g)), l.add && (l.add.call(a, k), k.handler.guid || (k.handler.guid = c.guid)), e + ? m.splice(m.delegateCount++, 0, k) + : m.push(k), r.event.global[n] = !0) + } + }, + remove: function (a, b, c, d, e) { + var f, + g, + h, + i, + j, + k, + l, + m, + n, + o, + p, + q = V.hasData(a) && V.get(a); + if (q && (i = q.events)) { + b = (b || "").match(K) || [""], + j = b.length; + while (j--) + if (h = ta.exec(b[j]) || [], n = p = h[1], o = (h[2] || "").split(".").sort(), n) { + l = r.event.special[n] || {}, + n = (d + ? l.delegateType + : l.bindType) || n, + m = i[n] || [], + h = h[2] && new RegExp("(^|\\.)" + o.join("\\.(?:.*\\.|)") + "(\\.|$)"), + g = f = m.length; + while (f--) + k = m[f], + !e && p !== k.origType || c && c.guid !== k.guid || h && !h.test(k.namespace) || d && d !== k.selector && ("**" !== d || !k.selector) || (m.splice(f, 1), k.selector && m.delegateCount--, l.remove && l.remove.call(a, k)); + g && !m.length && (l.teardown && l.teardown.call(a, o, q.handle) !== !1 || r.removeEvent(a, n, q.handle), delete i[n]) + } + else + for (n in i) + r.event.remove(a, n + b[j], c, d, !0); + r.isEmptyObject(i) && V.remove(a, "handle events") + } + }, + dispatch: function (a) { + var b = r + .event + .fix(a), + c, + d, + e, + f, + g, + h, + i = new Array(arguments.length), + j = (V.get(this, "events") || {})[b.type] || [], + k = r.event.special[b.type] || {}; + for (i[0] = b, c = 1; c < arguments.length; c++) + i[c] = arguments[c]; + if (b.delegateTarget = this, !k.preDispatch || k.preDispatch.call(this, b) !== !1) { + h = r + .event + .handlers + .call(this, b, j), + c = 0; + while ((f = h[c++]) && !b.isPropagationStopped()) { + b.currentTarget = f.elem, + d = 0; + while ((g = f.handlers[d++]) && !b.isImmediatePropagationStopped()) + b.rnamespace && !b.rnamespace.test(g.namespace) || (b.handleObj = g, b.data = g.data, e = ((r.event.special[g.origType] || {}).handle || g.handler).apply(f.elem, i), void 0 !== e && (b.result = e) === !1 && (b.preventDefault(), b.stopPropagation())) + } + return k.postDispatch && k + .postDispatch + .call(this, b), + b.result + } + }, + handlers: function (a, b) { + var c, + d, + e, + f, + g, + h = [], + i = b.delegateCount, + j = a.target; + if (i && j.nodeType && !("click" === a.type && a.button >= 1)) + for (; j !== this; j = j.parentNode || this) + if (1 === j.nodeType && ("click" !== a.type || j.disabled !== !0)) { + for (f = [], g = {}, c = 0; c < i; c++) + d = b[c], + e = d.selector + " ", + void 0 === g[e] && (g[e] = d.needsContext + ? r(e, this).index(j) > -1 + : r.find(e, this, null, [j]).length), + g[e] && f.push(d); + f.length && h.push({elem: j, handlers: f}) + } + return j = this, + i < b.length && h.push({ + elem: j, + handlers: b.slice(i) + }), + h + }, + addProp: function (a, b) { + Object.defineProperty(r.Event.prototype, a, { + enumerable: !0, + configurable: !0, + get: r.isFunction(b) + ? function () { + if (this.originalEvent) + return b(this.originalEvent) + } + : function () { + if (this.originalEvent) + return this.originalEvent[a] + }, + set: function (b) { + Object.defineProperty(this, a, { + enumerable: !0, + configurable: !0, + writable: !0, + value: b + }) + } + }) + }, + fix: function (a) { + return a[r.expando] + ? a + : new r.Event(a) + }, + special: { + load: { + noBubble: !0 + }, + focus: { + trigger: function () { + if (this !== wa() && this.focus) + return this.focus(), + !1 + }, + delegateType: "focusin" + }, + blur: { + trigger: function () { + if (this === wa() && this.blur) + return this.blur(), + !1 + }, + delegateType: "focusout" + }, + click: { + trigger: function () { + if ("checkbox" === this.type && this.click && r.nodeName(this, "input")) + return this.click(), + !1 + }, + _default: function (a) { + return r.nodeName(a.target, "a") + } + }, + beforeunload: { + postDispatch: function (a) { + void 0 !== a.result && a.originalEvent && (a.originalEvent.returnValue = a.result) + } + } + } + }, + r.removeEvent = function (a, b, c) { + a.removeEventListener && a.removeEventListener(b, c) + }, + r.Event = function (a, b) { + return this instanceof r.Event + ? (a && a.type + ? (this.originalEvent = a, this.type = a.type, this.isDefaultPrevented = a.defaultPrevented || void 0 === a.defaultPrevented && a.returnValue === !1 + ? ua + : va, this.target = a.target && 3 === a.target.nodeType + ? a.target.parentNode + : a.target, this.currentTarget = a.currentTarget, this.relatedTarget = a.relatedTarget) + : this.type = a, b && r.extend(this, b), this.timeStamp = a && a.timeStamp || r.now(), void(this[r.expando] = !0)) + : new r.Event(a, b) + }, + r.Event.prototype = { + constructor: r.Event, + isDefaultPrevented: va, + isPropagationStopped: va, + isImmediatePropagationStopped: va, + isSimulated: !1, + preventDefault: function () { + var a = this.originalEvent; + this.isDefaultPrevented = ua, + a && !this.isSimulated && a.preventDefault() + }, + stopPropagation: function () { + var a = this.originalEvent; + this.isPropagationStopped = ua, + a && !this.isSimulated && a.stopPropagation() + }, + stopImmediatePropagation: function () { + var a = this.originalEvent; + this.isImmediatePropagationStopped = ua, + a && !this.isSimulated && a.stopImmediatePropagation(), + this.stopPropagation() + } + }, + r.each({ + altKey: !0, + bubbles: !0, + cancelable: !0, + changedTouches: !0, + ctrlKey: !0, + detail: !0, + eventPhase: !0, + metaKey: !0, + pageX: !0, + pageY: !0, + shiftKey: !0, + view: !0, + "char": !0, + charCode: !0, + key: !0, + keyCode: !0, + button: !0, + buttons: !0, + clientX: !0, + clientY: !0, + offsetX: !0, + offsetY: !0, + pointerId: !0, + pointerType: !0, + screenX: !0, + screenY: !0, + targetTouches: !0, + toElement: !0, + touches: !0, + which: function (a) { + var b = a.button; + return null == a.which && ra.test(a.type) + ? null != a.charCode + ? a.charCode + : a.keyCode + : !a.which && void 0 !== b && sa.test(a.type) + ? 1 & b + ? 1 + : 2 & b + ? 3 + : 4 & b + ? 2 + : 0 + : a.which + } + }, r.event.addProp), + r.each({ + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" + }, function (a, b) { + r.event.special[a] = { + delegateType: b, + bindType: b, + handle: function (a) { + var c, + d = this, + e = a.relatedTarget, + f = a.handleObj; + return e && (e === d || r.contains(d, e)) || (a.type = f.origType, c = f.handler.apply(this, arguments), a.type = b), + c + } + } + }), + r + .fn + .extend({ + on: function (a, b, c, d) { + return xa(this, a, b, c, d) + }, + one: function (a, b, c, d) { + return xa(this, a, b, c, d, 1) + }, + off: function (a, b, c) { + var d, + e; + if (a && a.preventDefault && a.handleObj) + return d = a.handleObj, + r(a.delegateTarget).off(d.namespace + ? d.origType + "." + d.namespace + : d.origType, d.selector, d.handler), + this; + if ("object" == typeof a) { + for (e in a) + this.off(e, b, a[e]); + return this + } + return b !== !1 && "function" != typeof b || (c = b, b = void 0), + c === !1 && (c = va), + this.each(function () { + r + .event + .remove(this, a, c, b) + }) + } + }); + var ya = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, + za = /\s*$/g; + function Da(a, b) { + return r.nodeName(a, "table") && r.nodeName(11 !== b.nodeType + ? b + : b.firstChild, "tr") + ? a.getElementsByTagName("tbody")[0] || a + : a + } + function Ea(a) { + return a.type = (null !== a.getAttribute("type")) + "/" + a.type, + a + } + function Fa(a) { + var b = Ba.exec(a.type); + return b + ? a.type = b[1] + : a.removeAttribute("type"), + a + } + function Ga(a, b) { + var c, + d, + e, + f, + g, + h, + i, + j; + if (1 === b.nodeType) { + if (V.hasData(a) && (f = V.access(a), g = V.set(b, f), j = f.events)) { + delete g.handle, + g.events = {}; + for (e in j) + for (c = 0, d = j[e].length; c < d; c++) + r.event.add(b, e, j[e][c]) + } + W.hasData(a) && (h = W.access(a), i = r.extend({}, h), W.set(b, i)) + } + } + function Ha(a, b) { + var c = b + .nodeName + .toLowerCase(); + "input" === c && ia.test(a.type) + ? b.checked = a.checked + : "input" !== c && "textarea" !== c || (b.defaultValue = a.defaultValue) + } + function Ia(a, b, c, d) { + b = g.apply([], b); + var e, + f, + h, + i, + j, + k, + l = 0, + m = a.length, + n = m - 1, + q = b[0], + s = r.isFunction(q); + if (s || m > 1 && "string" == typeof q && !o.checkClone && Aa.test(q)) + return a.each(function (e) { + var f = a.eq(e); + s && (b[0] = q.call(this, e, f.html())), + Ia(f, b, c, d) + }); + if (m && (e = pa(b, a[0].ownerDocument, !1, a, d), f = e.firstChild, 1 === e.childNodes.length && (e = f), f || d)) { + for (h = r.map(ma(e, "script"), Ea), i = h.length; l < m; l++) + j = e, + l !== n && (j = r.clone(j, !0, !0), i && r.merge(h, ma(j, "script"))), + c.call(a[l], j, l); + if (i) + for (k = h[h.length - 1].ownerDocument, r.map(h, Fa), l = 0; l < i; l++) + j = h[l], + ka.test(j.type || "") && !V.access(j, "globalEval") && r.contains(k, j) && (j.src + ? r._evalUrl && r._evalUrl(j.src) + : p(j.textContent.replace(Ca, ""), k)) + } + return a + } + function Ja(a, b, c) { + for (var d, e = b + ? r.filter(b, a) + : a, f = 0; null != (d = e[f]); f++) + c || 1 !== d.nodeType || r.cleanData(ma(d)), + d.parentNode && (c && r.contains(d.ownerDocument, d) && na(ma(d, "script")), d.parentNode.removeChild(d)); + return a + } + r.extend({ + htmlPrefilter: function (a) { + return a.replace(ya, "<$1>") + }, + clone: function (a, b, c) { + var d, + e, + f, + g, + h = a.cloneNode(!0), + i = r.contains(a.ownerDocument, a); + if (!(o.noCloneChecked || 1 !== a.nodeType && 11 !== a.nodeType || r.isXMLDoc(a))) + for (g = ma(h), f = ma(a), d = 0, e = f.length; d < e; d++) + Ha(f[d], g[d]); + if (b) + if (c) + for (f = f || ma(a), g = g || ma(h), d = 0, e = f.length; d < e; d++) + Ga(f[d], g[d]); + else + Ga(a, h); + return g = ma(h, "script"), + g.length > 0 && na(g, !i && ma(a, "script")), + h + }, + cleanData: function (a) { + for (var b, c, d, e = r.event.special, f = 0; void 0 !== (c = a[f]); f++) + if (T(c)) { + if (b = c[V.expando]) { + if (b.events) + for (d in b.events) + e[d] + ? r.event.remove(c, d) + : r.removeEvent(c, d, b.handle); + c[V.expando] = void 0 + } + c[W.expando] && (c[W.expando] = void 0) + } + } + }), + r + .fn + .extend({ + detach: function (a) { + return Ja(this, a, !0) + }, + remove: function (a) { + return Ja(this, a) + }, + text: function (a) { + return S(this, function (a) { + return void 0 === a + ? r.text(this) + : this + .empty() + .each(function () { + 1 !== this.nodeType && 11 !== this.nodeType && 9 !== this.nodeType || (this.textContent = a) + }) + }, null, a, arguments.length) + }, + append: function () { + return Ia(this, arguments, function (a) { + if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) { + var b = Da(this, a); + b.appendChild(a) + } + }) + }, + prepend: function () { + return Ia(this, arguments, function (a) { + if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) { + var b = Da(this, a); + b.insertBefore(a, b.firstChild) + } + }) + }, + before: function () { + return Ia(this, arguments, function (a) { + this.parentNode && this + .parentNode + .insertBefore(a, this) + }) + }, + after: function () { + return Ia(this, arguments, function (a) { + this.parentNode && this + .parentNode + .insertBefore(a, this.nextSibling) + }) + }, + empty: function () { + for (var a, b = 0; null != (a = this[b]); b++) + 1 === a.nodeType && (r.cleanData(ma(a, !1)), a.textContent = ""); + return this + }, + clone: function (a, b) { + return a = null != a && a, + b = null == b + ? a + : b, + this.map(function () { + return r.clone(this, a, b) + }) + }, + html: function (a) { + return S(this, function (a) { + var b = this[0] || {}, + c = 0, + d = this.length; + if (void 0 === a && 1 === b.nodeType) + return b.innerHTML; + if ("string" == typeof a && !za.test(a) && !la[(ja.exec(a) || ["", ""])[1].toLowerCase()]) { + a = r.htmlPrefilter(a); + try { + for (; c < d; c++) + b = this[c] || {} + , + 1 === b.nodeType && (r.cleanData(ma(b, !1)), b.innerHTML = a); + b = 0 + } catch (e) {} + } + b && this + .empty() + .append(a) + }, null, a, arguments.length) + }, + replaceWith: function () { + var a = []; + return Ia(this, arguments, function (b) { + var c = this.parentNode; + r.inArray(this, a) < 0 && (r.cleanData(ma(this)), c && c.replaceChild(b, this)) + }, a) + } + }), + r.each({ + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" + }, function (a, b) { + r.fn[a] = function (a) { + for (var c, d = [], e = r(a), f = e.length - 1, g = 0; g <= f; g++) + c = g === f + ? this + : this.clone(!0), + r(e[g])[b](c), + h.apply(d, c.get()); + return this.pushStack(d) + } + }); + var Ka = /^margin/, + La = new RegExp("^(" + _ + ")(?!px)[a-z%]+$", "i"), + Ma = function (b) { + var c = b.ownerDocument.defaultView; + return c && c.opener || (c = a), + c.getComputedStyle(b) + }; + !function () { + function b() { + if (i) { + i.style.cssText = "box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;pad" + + "ding:1px;top:1%;width:50%", + i.innerHTML = "", + qa.appendChild(h); + var b = a.getComputedStyle(i); + c = "1%" !== b.top, + g = "2px" === b.marginLeft, + e = "4px" === b.width, + i.style.marginRight = "50%", + f = "4px" === b.marginRight, + qa.removeChild(h), + i = null + } + } + var c, + e, + f, + g, + h = d.createElement("div"), + i = d.createElement("div"); + i.style && (i.style.backgroundClip = "content-box", i.cloneNode(!0).style.backgroundClip = "", o.clearCloneStyle = "content-box" === i.style.backgroundClip, h.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position" + + ":absolute", + h.appendChild(i), r.extend(o, { + pixelPosition: function () { + return b(), + c + }, + boxSizingReliable: function () { + return b(), + e + }, + pixelMarginRight: function () { + return b(), + f + }, + reliableMarginLeft: function () { + return b(), + g + } + })) + }(); + function Na(a, b, c) { + var d, + e, + f, + g, + h = a.style; + return c = c || Ma(a), + c && (g = c.getPropertyValue(b) || c[b], "" !== g || r.contains(a.ownerDocument, a) || (g = r.style(a, b)), !o.pixelMarginRight() && La.test(g) && Ka.test(b) && (d = h.width, e = h.minWidth, f = h.maxWidth, h.minWidth = h.maxWidth = h.width = g, g = c.width, h.width = d, h.minWidth = e, h.maxWidth = f)), + void 0 !== g + ? g + "" + : g + } + function Oa(a, b) { + return { + get: function () { + return a() + ? void delete this.get + : (this.get = b).apply(this, arguments) + } + } + } + var Pa = /^(none|table(?!-c[ea]).+)/, + Qa = { + position: "absolute", + visibility: "hidden", + display: "block" + }, + Ra = { + letterSpacing: "0", + fontWeight: "400" + }, + Sa = [ + "Webkit", "Moz", "ms" + ], + Ta = d + .createElement("div") + .style; + function Ua(a) { + if (a in Ta) + return a; + var b = a[0].toUpperCase() + a.slice(1), + c = Sa.length; + while (c--) + if (a = Sa[c] + b, a in Ta) + return a + } + function Va(a, b, c) { + var d = aa.exec(b); + return d + ? Math.max(0, d[2] - (c || 0)) + (d[3] || "px") + : b + } + function Wa(a, b, c, d, e) { + var f, + g = 0; + for (f = c === (d + ? "border" + : "content") + ? 4 + : "width" === b + ? 1 + : 0; f < 4; f += 2) + "margin" === c && (g += r.css(a, c + ba[f], !0, e)), + d + ? ("content" === c && (g -= r.css(a, "padding" + ba[f], !0, e)), "margin" !== c && (g -= r.css(a, "border" + ba[f] + "Width", !0, e))) + : (g += r.css(a, "padding" + ba[f], !0, e), "padding" !== c && (g += r.css(a, "border" + ba[f] + "Width", !0, e))); + return g + } + function Xa(a, b, c) { + var d, + e = !0, + f = Ma(a), + g = "border-box" === r.css(a, "boxSizing", !1, f); + if (a.getClientRects().length && (d = a.getBoundingClientRect()[b]), d <= 0 || null == d) { + if (d = Na(a, b, f), (d < 0 || null == d) && (d = a.style[b]), La.test(d)) + return d; + e = g && (o.boxSizingReliable() || d === a.style[b]), + d = parseFloat(d) || 0 + } + return d + Wa(a, b, c || (g + ? "border" + : "content"), e, f) + "px" + } + r.extend({ + cssHooks: { + opacity: { + get: function (a, b) { + if (b) { + var c = Na(a, "opacity"); + return "" === c + ? "1" + : c + } + } + } + }, + cssNumber: { + animationIterationCount: !0, + columnCount: !0, + fillOpacity: !0, + flexGrow: !0, + flexShrink: !0, + fontWeight: !0, + lineHeight: !0, + opacity: !0, + order: !0, + orphans: !0, + widows: !0, + zIndex: !0, + zoom: !0 + }, + cssProps: { + "float": "cssFloat" + }, + style: function (a, b, c, d) { + if (a && 3 !== a.nodeType && 8 !== a.nodeType && a.style) { + var e, + f, + g, + h = r.camelCase(b), + i = a.style; + return b = r.cssProps[h] || (r.cssProps[h] = Ua(h) || h), + g = r.cssHooks[b] || r.cssHooks[h], + void 0 === c + ? g && "get" in g && void 0 !== (e = g.get(a, !1, d)) + ? e + : i[b] + : (f = typeof c, "string" === f && (e = aa.exec(c)) && e[1] && (c = ea(a, b, e), f = "number"), null != c && c === c && ("number" === f && (c += e && e[3] || (r.cssNumber[h] + ? "" + : "px")), o.clearCloneStyle || "" !== c || 0 !== b.indexOf("background") || (i[b] = "inherit"), g && "set" in g && void 0 === (c = g.set(a, c, d)) || (i[b] = c)), void 0) + } + }, + css: function (a, b, c, d) { + var e, + f, + g, + h = r.camelCase(b); + return b = r.cssProps[h] || (r.cssProps[h] = Ua(h) || h), + g = r.cssHooks[b] || r.cssHooks[h], + g && "get" in g && (e = g.get(a, !0, c)), + void 0 === e && (e = Na(a, b, d)), + "normal" === e && b in Ra && (e = Ra[b]), + "" === c || c + ? (f = parseFloat(e), c === !0 || isFinite(f) + ? f || 0 + : e) + : e + } + }), + r.each([ + "height", "width" + ], function (a, b) { + r.cssHooks[b] = { + get: function (a, c, d) { + if (c) + return !Pa.test(r.css(a, "display")) || a.getClientRects().length && a.getBoundingClientRect().width + ? Xa(a, b, d) + : da(a, Qa, function () { + return Xa(a, b, d) + }) + }, + set: function (a, c, d) { + var e, + f = d && Ma(a), + g = d && Wa(a, b, d, "border-box" === r.css(a, "boxSizing", !1, f), f); + return g && (e = aa.exec(c)) && "px" !== (e[3] || "px") && (a.style[b] = c, c = r.css(a, b)), + Va(a, c, g) + } + } + }), + r.cssHooks.marginLeft = Oa(o.reliableMarginLeft, function (a, b) { + if (b) + return (parseFloat(Na(a, "marginLeft")) || a.getBoundingClientRect().left - da(a, { + marginLeft: 0 + }, function () { + return a + .getBoundingClientRect() + .left + })) + "px" + }), + r.each({ + margin: "", + padding: "", + border: "Width" + }, function (a, b) { + r.cssHooks[a + b] = { + expand: function (c) { + for (var d = 0, e = {}, f = "string" == typeof c + ? c.split(" ") + : [c]; d < 4; d++) + e[a + ba[d] + b] = f[d] || f[d - 2] || f[0]; + return e + } + }, + Ka.test(a) || (r.cssHooks[a + b].set = Va) + }), + r + .fn + .extend({ + css: function (a, b) { + return S(this, function (a, b, c) { + var d, + e, + f = {}, + g = 0; + if (r.isArray(b)) { + for (d = Ma(a), e = b.length; g < e; g++) + f[b[g]] = r.css(a, b[g], !1, d); + return f + } + return void 0 !== c + ? r.style(a, b, c) + : r.css(a, b) + }, a, b, arguments.length > 1) + } + }); + function Ya(a, b, c, d, e) { + return new Ya + .prototype + .init(a, b, c, d, e) + } + r.Tween = Ya, + Ya.prototype = { + constructor: Ya, + init: function (a, b, c, d, e, f) { + this.elem = a, + this.prop = c, + this.easing = e || r.easing._default, + this.options = b, + this.start = this.now = this.cur(), + this.end = d, + this.unit = f || (r.cssNumber[c] + ? "" + : "px") + }, + cur: function () { + var a = Ya.propHooks[this.prop]; + return a && a.get + ? a.get(this) + : Ya + .propHooks + ._default + .get(this) + }, + run: function (a) { + var b, + c = Ya.propHooks[this.prop]; + return this.options.duration + ? this.pos = b = r.easing[this.easing](a, this.options.duration * a, 0, 1, this.options.duration) + : this.pos = b = a, + this.now = (this.end - this.start) * b + this.start, + this.options.step && this + .options + .step + .call(this.elem, this.now, this), + c && c.set + ? c.set(this) + : Ya + .propHooks + ._default + .set(this), + this + } + }, + Ya.prototype.init.prototype = Ya.prototype, + Ya.propHooks = { + _default: { + get: function (a) { + var b; + return 1 !== a.elem.nodeType || null != a.elem[a.prop] && null == a.elem.style[a.prop] + ? a.elem[a.prop] + : (b = r.css(a.elem, a.prop, ""), b && "auto" !== b + ? b + : 0) + }, + set: function (a) { + r.fx.step[a.prop] + ? r.fx.step[a.prop](a) + : 1 !== a.elem.nodeType || null == a.elem.style[r.cssProps[a.prop]] && !r.cssHooks[a.prop] + ? a.elem[a.prop] = a.now + : r.style(a.elem, a.prop, a.now + a.unit) + } + } + }, + Ya.propHooks.scrollTop = Ya.propHooks.scrollLeft = { + set: function (a) { + a.elem.nodeType && a.elem.parentNode && (a.elem[a.prop] = a.now) + } + }, + r.easing = { + linear: function (a) { + return a + }, + swing: function (a) { + return.5 - Math.cos(a * Math.PI) / 2 + }, + _default: "swing" + }, + r.fx = Ya.prototype.init, + r.fx.step = {}; + var Za, + $a, + _a = /^(?:toggle|show|hide)$/, + ab = /queueHooks$/; + function bb() { + $a && (a.requestAnimationFrame(bb), r.fx.tick()) + } + function cb() { + return a.setTimeout(function () { + Za = void 0 + }), + Za = r.now() + } + function db(a, b) { + var c, + d = 0, + e = { + height: a + }; + for (b = b + ? 1 + : 0; d < 4; d += 2 - b) + c = ba[d], + e["margin" + c] = e["padding" + c] = a; + return b && (e.opacity = e.width = a), + e + } + function eb(a, b, c) { + for (var d, e = (hb.tweeners[b] || []).concat(hb.tweeners["*"]), f = 0, g = e.length; f < g; f++) + if (d = e[f].call(c, b, a)) + return d + } + function fb(a, b, c) { + var d, + e, + f, + g, + h, + i, + j, + k, + l = "width" in b || "height" in b, + m = this, + n = {}, + o = a.style, + p = a.nodeType && ca(a), + q = V.get(a, "fxshow"); + c.queue || (g = r._queueHooks(a, "fx"), null == g.unqueued && (g.unqueued = 0, h = g.empty.fire, g.empty.fire = function () { + g.unqueued || h() + }), g.unqueued++, m.always(function () { + m + .always(function () { + g.unqueued--, + r + .queue(a, "fx") + .length || g + .empty + .fire() + }) + })); + for (d in b) + if (e = b[d], _a.test(e)) { + if (delete b[d], f = f || "toggle" === e, e === (p + ? "hide" + : "show")) { + if ("show" !== e || !q || void 0 === q[d]) + continue; + p = !0 + } + n[d] = q && q[d] || r.style(a, d) + } + if (i = !r.isEmptyObject(b), i || !r.isEmptyObject(n)) { + l && 1 === a.nodeType && (c.overflow = [ + o.overflow, o.overflowX, o.overflowY + ], j = q && q.display, null == j && (j = V.get(a, "display")), k = r.css(a, "display"), "none" === k && (j + ? k = j + : (ha([a], !0), j = a.style.display || j, k = r.css(a, "display"), ha([a]))), ("inline" === k || "inline-block" === k && null != j) && "none" === r.css(a, "float") && (i || (m.done(function () { + o.display = j + }), null == j && (k = o.display, j = "none" === k + ? "" + : k)), o.display = "inline-block")), + c.overflow && (o.overflow = "hidden", m.always(function () { + o.overflow = c.overflow[0], + o.overflowX = c.overflow[1], + o.overflowY = c.overflow[2] + })), + i = !1; + for (d in n) + i || (q + ? "hidden" in q && (p = q.hidden) + : q = V.access(a, "fxshow", {display: j}), f && (q.hidden = !p), p && ha([a], !0), m.done(function () { + p || ha([a]), + V.remove(a, "fxshow"); + for (d in n) + r.style(a, d, n[d]) + })), + i = eb(p + ? q[d] + : 0, d, m), + d in q || (q[d] = i.start, p && (i.end = i.start, i.start = 0)) + } + } + function gb(a, b) { + var c, + d, + e, + f, + g; + for (c in a) + if (d = r.camelCase(c), e = b[d], f = a[c], r.isArray(f) && (e = f[1], f = a[c] = f[0]), c !== d && (a[d] = f, delete a[c]), g = r.cssHooks[d], g && "expand" in g) { + f = g.expand(f), + delete a[d]; + for (c in f) + c in a || (a[c] = f[c], b[c] = e) + } + else + b[d] = e + } + function hb(a, b, c) { + var d, + e, + f = 0, + g = hb.prefilters.length, + h = r + .Deferred() + .always(function () { + delete i.elem + }), + i = function () { + if (e) + return !1; + for (var b = Za || cb(), c = Math.max(0, j.startTime + j.duration - b), d = c / j.duration || 0, f = 1 - d, g = 0, i = j.tweens.length; g < i; g++) + j.tweens[g].run(f); + return h.notifyWith(a, [j, f, c]), + f < 1 && i + ? c + : (h.resolveWith(a, [j]), !1) + }, + j = h.promise({ + elem: a, + props: r.extend({}, b), + opts: r.extend(!0, { + specialEasing: {}, + easing: r.easing._default + }, c), + originalProperties: b, + originalOptions: c, + startTime: Za || cb(), + duration: c.duration, + tweens: [], + createTween: function (b, c) { + var d = r.Tween(a, j.opts, b, c, j.opts.specialEasing[b] || j.opts.easing); + return j + .tweens + .push(d), + d + }, + stop: function (b) { + var c = 0, + d = b + ? j.tweens.length + : 0; + if (e) + return this; + for (e = !0; c < d; c++) + j.tweens[c].run(1); + return b + ? (h.notifyWith(a, [j, 1, 0]), h.resolveWith(a, [j, b])) + : h.rejectWith(a, [j, b]), + this + } + }), + k = j.props; + for (gb(k, j.opts.specialEasing); f < g; f++) + if (d = hb.prefilters[f].call(j, a, k, j.opts)) + return r.isFunction(d.stop) && (r._queueHooks(j.elem, j.opts.queue).stop = r.proxy(d.stop, d)), + d; + return r.map(k, eb, j), + r.isFunction(j.opts.start) && j + .opts + .start + .call(a, j), + r + .fx + .timer(r.extend(i, { + elem: a, + anim: j, + queue: j.opts.queue + })), + j + .progress(j.opts.progress) + .done(j.opts.done, j.opts.complete) + .fail(j.opts.fail) + .always(j.opts.always) + } + r.Animation = r.extend(hb, { + tweeners: { + "*": [function (a, b) { + var c = this.createTween(a, b); + return ea(c.elem, a, aa.exec(b), c), + c + } + ] + }, + tweener: function (a, b) { + r.isFunction(a) + ? (b = a, a = ["*"]) + : a = a.match(K); + for (var c, d = 0, e = a.length; d < e; d++) + c = a[d], + hb.tweeners[c] = hb.tweeners[c] || [], + hb.tweeners[c].unshift(b) + }, + prefilters: [fb], + prefilter: function (a, b) { + b + ? hb + .prefilters + .unshift(a) + : hb + .prefilters + .push(a) + } + }), + r.speed = function (a, b, c) { + var e = a && "object" == typeof a + ? r.extend({}, a) + : { + complete: c || !c && b || r.isFunction(a) && a, + duration: a, + easing: c && b || b && !r.isFunction(b) && b + }; + return r.fx.off || d.hidden + ? e.duration = 0 + : "number" != typeof e.duration && (e.duration in r.fx.speeds + ? e.duration = r.fx.speeds[e.duration] + : e.duration = r.fx.speeds._default), + null != e.queue && e.queue !== !0 || (e.queue = "fx"), + e.old = e.complete, + e.complete = function () { + r.isFunction(e.old) && e + .old + .call(this), + e.queue && r.dequeue(this, e.queue) + }, + e + }, + r + .fn + .extend({ + fadeTo: function (a, b, c, d) { + return this + .filter(ca) + .css("opacity", 0) + .show() + .end() + .animate({ + opacity: b + }, a, c, d) + }, + animate: function (a, b, c, d) { + var e = r.isEmptyObject(a), + f = r.speed(b, c, d), + g = function () { + var b = hb(this, r.extend({}, a), f); + (e || V.get(this, "finish")) && b.stop(!0) + }; + return g.finish = g, + e || f.queue === !1 + ? this.each(g) + : this.queue(f.queue, g) + }, + stop: function (a, b, c) { + var d = function (a) { + var b = a.stop; + delete a.stop, + b(c) + }; + return "string" != typeof a && (c = b, b = a, a = void 0), + b && a !== !1 && this.queue(a || "fx", []), + this.each(function () { + var b = !0, + e = null != a && a + "queueHooks", + f = r.timers, + g = V.get(this); + if (e) + g[e] && g[e].stop && d(g[e]); + else + for (e in g) + g[e] && g[e].stop && ab.test(e) && d(g[e]); + for (e = f.length; e--;) + f[e].elem !== this || null != a && f[e].queue !== a || (f[e].anim.stop(c), b = !1, f.splice(e, 1)); + + !b && c || r.dequeue(this, a) + }) + }, + finish: function (a) { + return a !== !1 && (a = a || "fx"), + this.each(function () { + var b, + c = V.get(this), + d = c[a + "queue"], + e = c[a + "queueHooks"], + f = r.timers, + g = d + ? d.length + : 0; + for (c.finish = !0, r.queue(this, a, []), e && e.stop && e.stop.call(this, !0), b = f.length; b--;) + f[b].elem === this && f[b].queue === a && (f[b].anim.stop(!0), f.splice(b, 1)); + for (b = 0; b < g; b++) + d[b] && d[b].finish && d[b].finish.call(this); + delete c.finish + }) + } + }), + r.each([ + "toggle", "show", "hide" + ], function (a, b) { + var c = r.fn[b]; + r.fn[b] = function (a, d, e) { + return null == a || "boolean" == typeof a + ? c.apply(this, arguments) + : this.animate(db(b, !0), a, d, e) + } + }), + r.each({ + slideDown: db("show"), + slideUp: db("hide"), + slideToggle: db("toggle"), + fadeIn: { + opacity: "show" + }, + fadeOut: { + opacity: "hide" + }, + fadeToggle: { + opacity: "toggle" + } + }, function (a, b) { + r.fn[a] = function (a, c, d) { + return this.animate(b, a, c, d) + } + }), + r.timers = [], + r.fx.tick = function () { + var a, + b = 0, + c = r.timers; + for (Za = r.now(); b < c.length; b++) + a = c[b], + a() || c[b] !== a || c.splice(b--, 1); + c.length || r + .fx + .stop(), + Za = void 0 + }, + r.fx.timer = function (a) { + r + .timers + .push(a), + a() + ? r + .fx + .start() + : r + .timers + .pop() + }, + r.fx.interval = 13, + r.fx.start = function () { + $a || ($a = a.requestAnimationFrame + ? a.requestAnimationFrame(bb) + : a.setInterval(r.fx.tick, r.fx.interval)) + }, + r.fx.stop = function () { + a.cancelAnimationFrame + ? a.cancelAnimationFrame($a) + : a.clearInterval($a), + $a = null + }, + r.fx.speeds = { + slow: 600, + fast: 200, + _default: 400 + }, + r.fn.delay = function (b, c) { + return b = r.fx + ? r.fx.speeds[b] || b + : b, + c = c || "fx", + this.queue(c, function (c, d) { + var e = a.setTimeout(c, b); + d.stop = function () { + a.clearTimeout(e) + } + }) + }, + function () { + var a = d.createElement("input"), + b = d.createElement("select"), + c = b.appendChild(d.createElement("option")); + a.type = "checkbox", + o.checkOn = "" !== a.value, + o.optSelected = c.selected, + a = d.createElement("input"), + a.value = "t", + a.type = "radio", + o.radioValue = "t" === a.value + }(); + var ib, + jb = r.expr.attrHandle; + r + .fn + .extend({ + attr: function (a, b) { + return S(this, r.attr, a, b, arguments.length > 1) + }, + removeAttr: function (a) { + return this.each(function () { + r.removeAttr(this, a) + }) + } + }), + r.extend({ + attr: function (a, b, c) { + var d, + e, + f = a.nodeType; + if (3 !== f && 8 !== f && 2 !== f) + return "undefined" == typeof a.getAttribute + ? r.prop(a, b, c) + : (1 === f && r.isXMLDoc(a) || (e = r.attrHooks[b.toLowerCase()] || (r.expr.match.bool.test(b) + ? ib + : void 0)), void 0 !== c + ? null === c + ? void r.removeAttr(a, b) + : e && "set" in e && void 0 !== (d = e.set(a, c, b)) + ? d + : (a.setAttribute(b, c + ""), c) + : e && "get" in e && null !== (d = e.get(a, b)) + ? d + : (d = r.find.attr(a, b), null == d + ? void 0 + : d)) + }, + attrHooks: { + type: { + set: function (a, b) { + if (!o.radioValue && "radio" === b && r.nodeName(a, "input")) { + var c = a.value; + return a.setAttribute("type", b), + c && (a.value = c), + b + } + } + } + }, + removeAttr: function (a, b) { + var c, + d = 0, + e = b && b.match(K); + if (e && 1 === a.nodeType) + while (c = e[d++]) + a.removeAttribute(c) + } + }), + ib = { + set: function (a, b, c) { + return b === !1 + ? r.removeAttr(a, c) + : a.setAttribute(c, c), + c + } + }, + r.each(r.expr.match.bool.source.match(/\w+/g), function (a, b) { + var c = jb[b] || r.find.attr; + jb[b] = function (a, b, d) { + var e, + f, + g = b.toLowerCase(); + return d || (f = jb[g], jb[g] = e, e = null != c(a, b, d) + ? g + : null, jb[g] = f), + e + } + }); + var kb = /^(?:input|select|textarea|button)$/i, + lb = /^(?:a|area)$/i; + r + .fn + .extend({ + prop: function (a, b) { + return S(this, r.prop, a, b, arguments.length > 1) + }, + removeProp: function (a) { + return this.each(function () { + delete this[r.propFix[a] || a] + }) + } + }), + r.extend({ + prop: function (a, b, c) { + var d, + e, + f = a.nodeType; + if (3 !== f && 8 !== f && 2 !== f) + return 1 === f && r.isXMLDoc(a) || (b = r.propFix[b] || b, e = r.propHooks[b]), + void 0 !== c + ? e && "set" in e && void 0 !== (d = e.set(a, c, b)) + ? d + : a[b] = c + : e && "get" in e && null !== (d = e.get(a, b)) + ? d + : a[b] + }, + propHooks: { + tabIndex: { + get: function (a) { + var b = r + .find + .attr(a, "tabindex"); + return b + ? parseInt(b, 10) + : kb.test(a.nodeName) || lb.test(a.nodeName) && a.href + ? 0 + : -1 + } + } + }, + propFix: { + "for": "htmlFor", + "class": "className" + } + }), + o.optSelected || (r.propHooks.selected = { + get: function (a) { + var b = a.parentNode; + return b && b.parentNode && b.parentNode.selectedIndex, + null + }, + set: function (a) { + var b = a.parentNode; + b && (b.selectedIndex, b.parentNode && b.parentNode.selectedIndex) + } + }), + r.each([ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" + ], function () { + r.propFix[this.toLowerCase()] = this + }); + function mb(a) { + var b = a.match(K) || []; + return b.join(" ") + } + function nb(a) { + return a.getAttribute && a.getAttribute("class") || "" + } + r + .fn + .extend({ + addClass: function (a) { + var b, + c, + d, + e, + f, + g, + h, + i = 0; + if (r.isFunction(a)) + return this.each(function (b) { + r(this).addClass(a.call(this, b, nb(this))) + }); + if ("string" == typeof a && a) { + b = a.match(K) || []; + while (c = this[i++]) + if (e = nb(c), d = 1 === c.nodeType && " " + mb(e) + " ") { + g = 0; + while (f = b[g++]) + d.indexOf(" " + f + " ") < 0 && (d += f + " "); + h = mb(d), + e !== h && c.setAttribute("class", h) + } + } + return this + }, + removeClass: function (a) { + var b, + c, + d, + e, + f, + g, + h, + i = 0; + if (r.isFunction(a)) + return this.each(function (b) { + r(this).removeClass(a.call(this, b, nb(this))) + }); + if (!arguments.length) + return this.attr("class", ""); + if ("string" == typeof a && a) { + b = a.match(K) || []; + while (c = this[i++]) + if (e = nb(c), d = 1 === c.nodeType && " " + mb(e) + " ") { + g = 0; + while (f = b[g++]) + while (d.indexOf(" " + f + " ") > -1) + d = d.replace(" " + f + " ", " "); + h = mb(d), + e !== h && c.setAttribute("class", h) + } + } + return this + }, + toggleClass: function (a, b) { + var c = typeof a; + return "boolean" == typeof b && "string" === c + ? b + ? this.addClass(a) + : this.removeClass(a) + : r.isFunction(a) + ? this.each(function (c) { + r(this).toggleClass(a.call(this, c, nb(this), b), b) + }) + : this.each(function () { + var b, + d, + e, + f; + if ("string" === c) { + d = 0, + e = r(this), + f = a.match(K) || []; + while (b = f[d++]) + e.hasClass(b) + ? e.removeClass(b) + : e.addClass(b) + } else + void 0 !== a && "boolean" !== c || (b = nb(this), b && V.set(this, "__className__", b), this.setAttribute && this.setAttribute("class", b || a === !1 + ? "" + : V.get(this, "__className__") || "")) + }) + }, + hasClass: function (a) { + var b, + c, + d = 0; + b = " " + a + " "; + while (c = this[d++]) + if (1 === c.nodeType && (" " + mb(nb(c)) + " ").indexOf(b) > -1) + return !0; + return !1 + } + }); + var ob = /\r/g; + r + .fn + .extend({ + val: function (a) { + var b, + c, + d, + e = this[0]; + { + if (arguments.length) + return d = r.isFunction(a), + this.each(function (c) { + var e; + 1 === this.nodeType && (e = d + ? a.call(this, c, r(this).val()) + : a, null == e + ? e = "" + : "number" == typeof e + ? e += "" + : r.isArray(e) && (e = r.map(e, function (a) { + return null == a + ? "" + : a + "" + })), b = r.valHooks[this.type] || r.valHooks[ + this + .nodeName + .toLowerCase() + ], b && "set" in b && void 0 !== b.set(this, e, "value") || (this.value = e)) + }); + if (e) + return b = r.valHooks[e.type] || r.valHooks[ + e + .nodeName + .toLowerCase() + ], + b && "get" in b && void 0 !== (c = b.get(e, "value")) + ? c + : (c = e.value, "string" == typeof c + ? c.replace(ob, "") + : null == c + ? "" + : c) + } + } + }), + r.extend({ + valHooks: { + option: { + get: function (a) { + var b = r + .find + .attr(a, "value"); + return null != b + ? b + : mb(r.text(a)) + } + }, + select: { + get: function (a) { + var b, + c, + d, + e = a.options, + f = a.selectedIndex, + g = "select-one" === a.type, + h = g + ? null + : [], + i = g + ? f + 1 + : e.length; + for (d = f < 0 + ? i + : g + ? f + : 0; d < i; d++) + if (c = e[d], (c.selected || d === f) && !c.disabled && (!c.parentNode.disabled || !r.nodeName(c.parentNode, "optgroup"))) { + if (b = r(c).val(), g) + return b; + h.push(b) + } + return h + }, + set: function (a, b) { + var c, + d, + e = a.options, + f = r.makeArray(b), + g = e.length; + while (g--) + d = e[g], + (d.selected = r.inArray(r.valHooks.option.get(d), f) > -1) && (c = !0); + return c || (a.selectedIndex = -1), + f + } + } + } + }), + r.each([ + "radio", "checkbox" + ], function () { + r.valHooks[this] = { + set: function (a, b) { + if (r.isArray(b)) + return a.checked = r.inArray(r(a).val(), b) > -1 + } + }, + o.checkOn || (r.valHooks[this].get = function (a) { + return null === a.getAttribute("value") + ? "on" + : a.value + }) + }); + var pb = /^(?:focusinfocus|focusoutblur)$/; + r.extend(r.event, { + trigger: function (b, c, e, f) { + var g, + h, + i, + j, + k, + m, + n, + o = [e || d], + p = l.call(b, "type") + ? b.type + : b, + q = l.call(b, "namespace") + ? b + .namespace + .split(".") + : []; + if (h = i = e = e || d, 3 !== e.nodeType && 8 !== e.nodeType && !pb.test(p + r.event.triggered) && (p.indexOf(".") > -1 && (q = p.split("."), p = q.shift(), q.sort()), k = p.indexOf(":") < 0 && "on" + p, b = b[r.expando] + ? b + : new r.Event(p, "object" == typeof b && b), b.isTrigger = f + ? 2 + : 3, b.namespace = q.join("."), b.rnamespace = b.namespace + ? new RegExp("(^|\\.)" + q.join("\\.(?:.*\\.|)") + "(\\.|$)") + : null, b.result = void 0, b.target || (b.target = e), c = null == c + ? [b] + : r.makeArray(c, [b]), n = r.event.special[p] || {}, f || !n.trigger || n.trigger.apply(e, c) !== !1)) { + if (!f && !n.noBubble && !r.isWindow(e)) { + for (j = n.delegateType || p, pb.test(j + p) || (h = h.parentNode); h; h = h.parentNode) + o.push(h), + i = h; + i === (e.ownerDocument || d) && o.push(i.defaultView || i.parentWindow || a) + } + g = 0; + while ((h = o[g++]) && !b.isPropagationStopped()) + b.type = g > 1 + ? j + : n.bindType || p, + m = (V.get(h, "events") || {})[b.type] && V.get(h, "handle"), + m && m.apply(h, c), + m = k && h[k], + m && m.apply && T(h) && (b.result = m.apply(h, c), b.result === !1 && b.preventDefault()); + return b.type = p, + f || b.isDefaultPrevented() || n._default && n + ._default + .apply(o.pop(), c) !== !1 || !T(e) || k && r.isFunction(e[p]) && !r.isWindow(e) && (i = e[k], i && (e[k] = null), r.event.triggered = p, e[p](), r.event.triggered = void 0, i && (e[k] = i)), + b.result + } + }, + simulate: function (a, b, c) { + var d = r.extend(new r.Event, c, { + type: a, + isSimulated: !0 + }); + r + .event + .trigger(d, null, b) + } + }), + r + .fn + .extend({ + trigger: function (a, b) { + return this.each(function () { + r + .event + .trigger(a, b, this) + }) + }, + triggerHandler: function (a, b) { + var c = this[0]; + if (c) + return r.event.trigger(a, b, c, !0) + } + }), + r.each(("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mous" + + "emove mouseover mouseout mouseenter mouseleave change select submit keydown keyp" + + "ress keyup contextmenu").split(" "), function (a, b) { + r.fn[b] = function (a, c) { + return arguments.length > 0 + ? this.on(b, null, a, c) + : this.trigger(b) + } + }), + r + .fn + .extend({ + hover: function (a, b) { + return this + .mouseenter(a) + .mouseleave(b || a) + } + }), + o.focusin = "onfocusin" in a, + o.focusin || r.each({ + focus: "focusin", + blur: "focusout" + }, function (a, b) { + var c = function (a) { + r + .event + .simulate(b, a.target, r.event.fix(a)) + }; + r.event.special[b] = { + setup: function () { + var d = this.ownerDocument || this, + e = V.access(d, b); + e || d.addEventListener(a, c, !0), + V.access(d, b, (e || 0) + 1) + }, + teardown: function () { + var d = this.ownerDocument || this, + e = V.access(d, b) - 1; + e + ? V.access(d, b, e) + : (d.removeEventListener(a, c, !0), V.remove(d, b)) + } + } + }); + var qb = a.location, + rb = r.now(), + sb = /\?/; + r.parseXML = function (b) { + var c; + if (!b || "string" != typeof b) + return null; + try { + c = (new a.DOMParser).parseFromString(b, "text/xml") + } catch (d) { + c = void 0 + } + return c && !c + .getElementsByTagName("parsererror") + .length || r.error("Invalid XML: " + b), + c + }; + var tb = /\[\]$/, + ub = /\r?\n/g, + vb = /^(?:submit|button|image|reset|file)$/i, + wb = /^(?:input|select|textarea|keygen)/i; + function xb(a, b, c, d) { + var e; + if (r.isArray(b)) + r.each(b, function (b, e) { + c || tb.test(a) + ? d(a, e) + : xb(a + "[" + ("object" == typeof e && null != e + ? b + : "") + "]", e, c, d) + }); + else if (c || "object" !== r.type(b)) + d(a, b); + else + for (e in b) + xb(a + "[" + e + "]", b[e], c, d) + } + r.param = function (a, b) { + var c, + d = [], + e = function (a, b) { + var c = r.isFunction(b) + ? b() + : b; + d[d.length] = encodeURIComponent(a) + "=" + encodeURIComponent(null == c + ? "" + : c) + }; + if (r.isArray(a) || a.jquery && !r.isPlainObject(a)) + r.each(a, function () { + e(this.name, this.value) + }); + else + for (c in a) + xb(c, a[c], b, e); + return d.join("&") + }, + r + .fn + .extend({ + serialize: function () { + return r.param(this.serializeArray()) + }, + serializeArray: function () { + return this.map(function () { + var a = r.prop(this, "elements"); + return a + ? r.makeArray(a) + : this + }) + .filter(function () { + var a = this.type; + return this.name && !r(this).is(":disabled") && wb.test(this.nodeName) && !vb.test(a) && (this.checked || !ia.test(a)) + }) + .map(function (a, b) { + var c = r(this).val(); + return null == c + ? null + : r.isArray(c) + ? r.map(c, function (a) { + return { + name: b.name, + value: a.replace(ub, "\r\n") + } + }) + : { + name: b.name, + value: c.replace(ub, "\r\n") + } + }) + .get() + } + }); + var yb = /%20/g, + zb = /#.*$/, + Ab = /([?&])_=[^&]*/, + Bb = /^(.*?):[ \t]*([^\r\n]*)$/gm, + Cb = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + Db = /^(?:GET|HEAD)$/, + Eb = /^\/\//, + Fb = {}, + Gb = {}, + Hb = "*/".concat("*"), + Ib = d.createElement("a"); + Ib.href = qb.href; + function Jb(a) { + return function (b, c) { + "string" != typeof b && (c = b, b = "*"); + var d, + e = 0, + f = b + .toLowerCase() + .match(K) || []; + if (r.isFunction(c)) + while (d = f[e++]) + "+" === d[0] + ? (d = d.slice(1) || "*", (a[d] = a[d] || []).unshift(c)) + : (a[d] = a[d] || []).push(c) + } + } + function Kb(a, b, c, d) { + var e = {}, + f = a === Gb; + function g(h) { + var i; + return e[h] = !0, + r.each(a[h] || [], function (a, h) { + var j = h(b, c, d); + return "string" != typeof j || f || e[j] + ? f + ? !(i = j) + : void 0 + : (b.dataTypes.unshift(j), g(j), !1) + }), + i + } + return g(b.dataTypes[0]) || !e["*"] && g("*") + } + function Lb(a, b) { + var c, + d, + e = r.ajaxSettings.flatOptions || {}; + for (c in b) + void 0 !== b[c] && ((e[c] + ? a + : d || (d = {}))[c] = b[c]); + return d && r.extend(!0, a, d), + a + } + function Mb(a, b, c) { + var d, + e, + f, + g, + h = a.contents, + i = a.dataTypes; + while ("*" === i[0]) + i.shift(), + void 0 === d && (d = a.mimeType || b.getResponseHeader("Content-Type")); + if (d) + for (e in h) + if (h[e] && h[e].test(d)) { + i.unshift(e); + break + } + if (i[0] in c) + f = i[0]; + else { + for (e in c) { + if (!i[0] || a.converters[e + " " + i[0]]) { + f = e; + break + } + g || (g = e) + } + f = f || g + } + if (f) + return f !== i[0] && i.unshift(f), + c[f] + } + function Nb(a, b, c, d) { + var e, + f, + g, + h, + i, + j = {}, + k = a + .dataTypes + .slice(); + if (k[1]) + for (g in a.converters) + j[g.toLowerCase()] = a.converters[g]; + f = k.shift(); + while (f) + if (a.responseFields[f] && (c[a.responseFields[f]] = b), !i && d && a.dataFilter && (b = a.dataFilter(b, a.dataType)), i = f, f = k.shift()) + if ("*" === f) + f = i; + else if ("*" !== i && i !== f) { + if (g = j[i + " " + f] || j["* " + f], !g) + for (e in j) + if (h = e.split(" "), h[1] === f && (g = j[i + " " + h[0]] || j["* " + h[0]])) { + g === !0 + ? g = j[e] + : j[e] !== !0 && (f = h[0], k.unshift(h[1])); + break + } + if (g !== !0) + if (g && a["throws"]) + b = g(b); + else + try { + b = g(b) + } catch (l) { + return { + state: "parsererror", + error: g + ? l + : "No conversion from " + i + " to " + f + } + } + } + return {state: "success", data: b} + } + r.extend({ + active: 0, + lastModified: {}, + etag: {}, + ajaxSettings: { + url: qb.href, + type: "GET", + isLocal: Cb.test(qb.protocol), + global: !0, + processData: !0, + async: !0, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + accepts: { + "*": Hb, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + converters: { + "* text": String, + "text html": !0, + "text json": JSON.parse, + "text xml": r.parseXML + }, + flatOptions: { + url: !0, + context: !0 + } + }, + ajaxSetup: function (a, b) { + return b + ? Lb(Lb(a, r.ajaxSettings), b) + : Lb(r.ajaxSettings, a) + }, + ajaxPrefilter: Jb(Fb), + ajaxTransport: Jb(Gb), + ajax: function (b, c) { + "object" == typeof b && (c = b, b = void 0), + c = c || {}; + var e, + f, + g, + h, + i, + j, + k, + l, + m, + n, + o = r.ajaxSetup({}, c), + p = o.context || o, + q = o.context && (p.nodeType || p.jquery) + ? r(p) + : r.event, + s = r.Deferred(), + t = r.Callbacks("once memory"), + u = o.statusCode || {}, + v = {}, + w = {}, + x = "canceled", + y = { + readyState: 0, + getResponseHeader: function (a) { + var b; + if (k) { + if (!h) { + h = {}; + while (b = Bb.exec(g)) + h[b[1].toLowerCase()] = b[2] + } + b = h[a.toLowerCase()] + } + return null == b + ? null + : b + }, + getAllResponseHeaders: function () { + return k + ? g + : null + }, + setRequestHeader: function (a, b) { + return null == k && (a = w[a.toLowerCase()] = w[a.toLowerCase()] || a, v[a] = b), + this + }, + overrideMimeType: function (a) { + return null == k && (o.mimeType = a), + this + }, + statusCode: function (a) { + var b; + if (a) + if (k) + y.always(a[y.status]); + else + for (b in a) + u[b] = [u[b], a[b]]; + return this + }, + abort: function (a) { + var b = a || x; + return e && e.abort(b), + A(0, b), + this + } + }; + if (s.promise(y), o.url = ((b || o.url || qb.href) + "").replace(Eb, qb.protocol + "//"), o.type = c.method || c.type || o.method || o.type, o.dataTypes = (o.dataType || "*").toLowerCase().match(K) || [""], null == o.crossDomain) { + j = d.createElement("a"); + try { + j.href = o.url, + j.href = j.href, + o.crossDomain = Ib.protocol + "//" + Ib.host != j.protocol + "//" + j.host + } catch (z) { + o.crossDomain = !0 + } + } + if (o.data && o.processData && "string" != typeof o.data && (o.data = r.param(o.data, o.traditional)), Kb(Fb, o, c, y), k) + return y; + l = r.event && o.global, + l && 0 === r.active++ && r + .event + .trigger("ajaxStart"), + o.type = o + .type + .toUpperCase(), + o.hasContent = !Db.test(o.type), + f = o + .url + .replace(zb, ""), + o.hasContent + ? o.data && o.processData && 0 === (o.contentType || "").indexOf("application/x-www-form-urlencoded") && (o.data = o.data.replace(yb, "+")) + : (n = o.url.slice(f.length), o.data && (f += (sb.test(f) + ? "&" + : "?") + o.data, delete o.data), o.cache === !1 && (f = f.replace(Ab, "$1"), n = (sb.test(f) + ? "&" + : "?") + "_=" + rb++ + n), o.url = f + n), + o.ifModified && (r.lastModified[f] && y.setRequestHeader("If-Modified-Since", r.lastModified[f]), r.etag[f] && y.setRequestHeader("If-None-Match", r.etag[f])), + (o.data && o.hasContent && o.contentType !== !1 || c.contentType) && y.setRequestHeader("Content-Type", o.contentType), + y.setRequestHeader("Accept", o.dataTypes[0] && o.accepts[o.dataTypes[0]] + ? o.accepts[o.dataTypes[0]] + ("*" !== o.dataTypes[0] + ? ", " + Hb + "; q=0.01" + : "") + : o.accepts["*"]); + for (m in o.headers) + y.setRequestHeader(m, o.headers[m]); + if (o.beforeSend && (o.beforeSend.call(p, y, o) === !1 || k)) + return y.abort(); + if (x = "abort", t.add(o.complete), y.done(o.success), y.fail(o.error), e = Kb(Gb, o, c, y)) { + if (y.readyState = 1, l && q.trigger("ajaxSend", [y, o]), k) + return y; + o.async && o.timeout > 0 && (i = a.setTimeout(function () { + y.abort("timeout") + }, o.timeout)); + try { + k = !1, + e.send(v, A) + } catch (z) { + if (k) + throw z; + A(-1, z) + } + } else + A(-1, "No Transport"); + function A(b, c, d, h) { + var j, + m, + n, + v, + w, + x = c; + k || (k = !0, i && a.clearTimeout(i), e = void 0, g = h || "", y.readyState = b > 0 + ? 4 + : 0, j = b >= 200 && b < 300 || 304 === b, d && (v = Mb(o, y, d)), v = Nb(o, v, y, j), j + ? (o.ifModified && (w = y.getResponseHeader("Last-Modified"), w && (r.lastModified[f] = w), w = y.getResponseHeader("etag"), w && (r.etag[f] = w)), 204 === b || "HEAD" === o.type + ? x = "nocontent" + : 304 === b + ? x = "notmodified" + : (x = v.state, m = v.data, n = v.error, j = !n)) + : (n = x, !b && x || (x = "error", b < 0 && (b = 0))), y.status = b, y.statusText = (c || x) + "", j + ? s.resolveWith(p, [m, x, y]) + : s.rejectWith(p, [y, x, n]), y.statusCode(u), u = void 0, l && q.trigger(j + ? "ajaxSuccess" + : "ajaxError", [ + y, o, j + ? m + : n + ]), t.fireWith(p, [y, x]), l && (q.trigger("ajaxComplete", [y, o]), --r.active || r.event.trigger("ajaxStop"))) + } + return y + }, + getJSON: function (a, b, c) { + return r.get(a, b, c, "json") + }, + getScript: function (a, b) { + return r.get(a, void 0, b, "script") + } + }), + r.each([ + "get", "post" + ], function (a, b) { + r[b] = function (a, c, d, e) { + return r.isFunction(c) && (e = e || d, d = c, c = void 0), + r.ajax(r.extend({ + url: a, + type: b, + dataType: e, + data: c, + success: d + }, r.isPlainObject(a) && a)) + } + }), + r._evalUrl = function (a) { + return r.ajax({ + url: a, + type: "GET", + dataType: "script", + cache: !0, + async: !1, + global: !1, + "throws": !0 + }) + }, + r + .fn + .extend({ + wrapAll: function (a) { + var b; + return this[0] && (r.isFunction(a) && (a = a.call(this[0])), b = r(a, this[0].ownerDocument).eq(0).clone(!0), this[0].parentNode && b.insertBefore(this[0]), b.map(function () { + var a = this; + while (a.firstElementChild) + a = a.firstElementChild; + return a + }).append(this)), + this + }, + wrapInner: function (a) { + return r.isFunction(a) + ? this.each(function (b) { + r(this).wrapInner(a.call(this, b)) + }) + : this.each(function () { + var b = r(this), + c = b.contents(); + c.length + ? c.wrapAll(a) + : b.append(a) + }) + }, + wrap: function (a) { + var b = r.isFunction(a); + return this.each(function (c) { + r(this).wrapAll(b + ? a.call(this, c) + : a) + }) + }, + unwrap: function (a) { + return this + .parent(a) + .not("body") + .each(function () { + r(this).replaceWith(this.childNodes) + }), + this + } + }), + r.expr.pseudos.hidden = function (a) { + return !r + .expr + .pseudos + .visible(a) + }, + r.expr.pseudos.visible = function (a) { + return !!(a.offsetWidth || a.offsetHeight || a.getClientRects().length) + }, + r.ajaxSettings.xhr = function () { + try { + return new a.XMLHttpRequest + } catch (b) {} + }; + var Ob = { + 0: 200, + 1223: 204 + }, + Pb = r + .ajaxSettings + .xhr(); + o.cors = !!Pb && "withCredentials" in Pb, + o.ajax = Pb = !!Pb, + r.ajaxTransport(function (b) { + var c, + d; + if (o.cors || Pb && !b.crossDomain) + return { + send: function (e, f) { + var g, + h = b.xhr(); + if (h.open(b.type, b.url, b.async, b.username, b.password), b.xhrFields) + for (g in b.xhrFields) + h[g] = b.xhrFields[g]; + b.mimeType && h.overrideMimeType && h.overrideMimeType(b.mimeType), + b.crossDomain || e["X-Requested-With"] || (e["X-Requested-With"] = "XMLHttpRequest"); + for (g in e) + h.setRequestHeader(g, e[g]); + c = function (a) { + return function () { + c && (c = d = h.onload = h.onerror = h.onabort = h.onreadystatechange = null, "abort" === a + ? h.abort() + : "error" === a + ? "number" != typeof h.status + ? f(0, "error") + : f(h.status, h.statusText) + : f(Ob[h.status] || h.status, h.statusText, "text" !== (h.responseType || "text") || "string" != typeof h.responseText + ? { + binary: h.response + } + : { + text: h.responseText + }, h.getAllResponseHeaders())) + } + }, + h.onload = c(), + d = h.onerror = c("error"), + void 0 !== h.onabort + ? h.onabort = d + : h.onreadystatechange = function () { + 4 === h.readyState && a.setTimeout(function () { + c && d() + }) + }, + c = c("abort"); + try { + h.send(b.hasContent && b.data || null) + } catch (i) { + if (c) + throw i + } + }, + abort: function () { + c && c() + } + } + }), + r.ajaxPrefilter(function (a) { + a.crossDomain && (a.contents.script = !1) + }), + r.ajaxSetup({ + accepts: { + script: "text/javascript, application/javascript, application/ecmascript, application/x-e" + + "cmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function (a) { + return r.globalEval(a), + a + } + } + }), + r.ajaxPrefilter("script", function (a) { + void 0 === a.cache && (a.cache = !1), + a.crossDomain && (a.type = "GET") + }), + r.ajaxTransport("script", function (a) { + if (a.crossDomain) { + var b, + c; + return { + send: function (e, f) { + b = r("