diff options
| author |   ramverma <ram.krishna.verma@ericsson.com> | 2018-07-11 14:21:13 +0100 |
|---|---|---|
| committer | ramverma <ram.krishna.verma@ericsson.com> | 2018-07-12 17:40:19 +0100 |
| commit | c6d74e6cee17405b9d26506b06259ccb2f38c737 (patch) | |
| tree | 9f5dabe5ceffe0e6b99a2bf77be812657953ae9b | |
| parent | b461c6505afddacbef90e3dc0bfa9d49609a626b (diff) | |
Adding client deployment module to apex-pdp
Change-Id: Idd74e9846c3fa75d305a9dde98a98d92dd0520a9
Issue-ID: POLICY-864
Signed-off-by: ramverma <ram.krishna.verma@ericsson.com>
45 files changed, 19118 insertions, 18698 deletions
diff --git a/client/client-common/pom.xml b/client/client-common/pom.xml new file mode 100644 index 000000000..40a502770 --- /dev/null +++ b/client/client-common/pom.xml @@ -0,0 +1,55 @@ +<!-- + ============LICENSE_START======================================================= + Copyright (C) 2018 Ericsson. All rights reserved. + ================================================================================ + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + SPDX-License-Identifier: Apache-2.0 + ============LICENSE_END========================================================= +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.onap.policy.apex-pdp.client</groupId> + <artifactId>client</artifactId> + <version>2.0.0-SNAPSHOT</version> + </parent> + + <artifactId>client-common</artifactId> + <packaging>pom</packaging> + <name>${project.artifactId}</name> + + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-assembly-plugin</artifactId> + <executions> + <execution> + <id>make shared resources</id> + <goals> + <goal>single</goal> + </goals> + <phase>package</phase> + <configuration> + <descriptors> + <descriptor>src/main/assembly/assembly.xml</descriptor> + </descriptors> + </configuration> + </execution> + </executions> + </plugin> + </plugins> + </build> +</project>
\ No newline at end of file diff --git a/client/client-common/src/main/assembly/assembly.xml b/client/client-common/src/main/assembly/assembly.xml new file mode 100644 index 000000000..ddc56e57f --- /dev/null +++ b/client/client-common/src/main/assembly/assembly.xml @@ -0,0 +1,32 @@ +<!-- + ============LICENSE_START======================================================= + Copyright (C) 2016-2018 Ericsson. All rights reserved. + ================================================================================ + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + SPDX-License-Identifier: Apache-2.0 + ============LICENSE_END========================================================= +--> +<assembly> + <id>resources</id> + <formats> + <format>zip</format> + </formats> + <includeBaseDirectory>false</includeBaseDirectory> + <fileSets> + <fileSet> + <directory>src/main/resources</directory> + <outputDirectory></outputDirectory> + </fileSet> + </fileSets> +</assembly>
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/css/apexChartLib.css b/client/client-common/src/main/resources/css/apexChartLib.css index 628fc0eb9..da86f6d18 100644 --- a/client/client-monitoring/src/main/resources/webapp/css/apexChartLib.css +++ b/client/client-common/src/main/resources/css/apexChartLib.css @@ -18,57 +18,47 @@ * ============LICENSE_END========================================================= */ path { // - stroke: #5fbadd; - stroke-width: 2; - fill: none; + stroke: #5fbadd; + stroke-width: 2; + fill: none; } .axis path, .axis line { - fill: none; - stroke: grey; - stroke-width: 1; - shape-rendering: crispEdges; + fill: none; + stroke: grey; + stroke-width: 1; + shape-rendering: crispEdges; } .tooltip { - position: absolute; - text-align: center; - width: 90px; - height: 42px; - padding: 2px; - font: 12px sans-serif; - background: white; - border: 2px solid grey; - border-radius: 8px; - pointer-events: none; + position: absolute; + text-align: center; + width: 90px; + height: 42px; + padding: 2px; + font: 12px sans-serif; + background: white; + border: 2px solid grey; + border-radius: 8px; + pointer-events: none; } .apexChart { - display: inline-block; - position: relative; - width: 45%; - padding-bottom: 21%; - vertical-align: top; - overflow: hidden; + display: inline-block; + position: relative; + width: 45%; + padding-bottom: 21%; + vertical-align: top; + overflow: hidden; } .apexChart:nth-child(even) { - margin-left: 50px; + margin-left: 50px; } .svg-content-responsive { - display: inline-block; - position: absolute; - top: 10px; - left: 0; -} - -.apexChart_inline { - display: inline-block; - position: relative; - width: 45%; - padding-bottom: 21%; - vertical-align: top; - overflow: hidden; - margin-left: -25px; + display: inline-block; + position: absolute; + top: 10px; + left: 0; }
\ No newline at end of file diff --git a/client/client-common/src/main/resources/css/interfaceAssets.css b/client/client-common/src/main/resources/css/interfaceAssets.css new file mode 100644 index 000000000..af56e816a --- /dev/null +++ b/client/client-common/src/main/resources/css/interfaceAssets.css @@ -0,0 +1,3454 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ +@charset "utf-8"; + +html { + position: relative; + font-family: Arial, Helvetica, sans-serif; + font-size: 10px !important; + line-height: 10px !important; + margin: 0; + padding: 0; + width: 100%; + height: 100%; +} + +body { + font-size: 1.6rem; + line-height: 1.2rem; + color: #333333; + background-color: #ffffff; + margin: 0; + padding: 0; +} + +*:focus, .ebInput:focus, .ebIcon:focus, .ebCheckbox:focus+.ebCheckbox-inputStatus:after, + .ebRadioBtn:focus+.ebRadioBtn-inputStatus:after, textarea:focus, button:focus, + i:focus { + /** + * FF outline do not looks same as Chrome so adding box shadow + * FF outline is not working as expected + **/ + /* + * one way of outline + outline: #4d90fe auto 5px; + box-shadow: 0 0 0 1px #4d90fe; + -webkit-box-shadow: none; + */ + outline: none; // + box-shadow: 0 0 2px 1px #FFFFFF; +} + +h1, h2, h3, h4, h5, h6 { + color: #4d4d4d; + font-weight: bold; +} + +h1 { + line-height: 3.2rem; + font-size: 3.2rem; + font-weight: normal; + padding: 0.6rem 0; + margin: 0 0 0.6rem 0; +} + +h2 { + border-bottom: #000000 solid 1px; + line-height: 2.0rem; + font-size: 2.0rem; + font-weight: normal; + padding: 1.2rem 0 0.7rem 0; + margin: 0 0 0.4rem 0; +} + +h3 { + border-bottom: #7f7f7f solid 1px; + line-height: 1.6rem; + font-size: 1.6rem; + padding: 1.2rem 0 0.7rem 0; + margin: 0 0 0.4rem 0; + font-weight: normal; + color: #333333; +} + +h4 { + border-bottom: #b2b2b2 solid 1px; + line-height: 1.2rem; + font-size: 1.2rem; + padding: 0.6rem 0; + margin: 0 0 0.6rem 0; + font-weight: bold; + color: #333333; +} + +.ebLayout-SectionSubheading h3 { + float: left; + margin: 0; + border-bottom: none; +} + +/* System Bar */ +.ebSystemBar { + position: relative; + width: 100%; + height: 40px; + border-top: 4px solid #0066b3; + background-image: linear-gradient(180deg, #ffffff 0%, #f4f4f4 100%); + box-shadow: 0 1px 2px #D2D2D2; +} + +.ebSystemBar::before { + position: absolute; + top: -4px; + left: 0; + width: 100%; + height: 4px; + content: ""; + font-size: 0; + background: #0066b3; + background: -o-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 + 75%, #db0050 100%); + background: -moz-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, + #151f77 75%, #db0050 100%); + background: -webkit-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, + #151f77 75%, #db0050 100%); + background: -ms-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 + 75%, #db0050 100%); + background: -webkit-gradient(linear, left top, right top, color-stop(0.1, #a2c517), + color-stop(0.3, #009046), color-stop(0.5, #0082b6), + color-stop(0.75, #151f77), color-stop(1, #db0050)); + background: linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 75% + , #db0050 100%); +} + +.ebSystemBar-logo { + position: absolute; + top: 0; + bottom: 0; + left: 0; + height: 40px; + width: 20px; + padding: 0 10px; + background: url('../resources/systemBar/econ01.svg') no-repeat center + center transparent; + background-size: 20px; +} + +.ebSystemBar-topMenuName { + display: inline-block; + padding: 0 5px 0 40px; + margin: 0; + line-height: 40px; + font-size: 16.8px; + color: #58585A; +} + +.ebSystemBar-topMenu { + position: absolute; + top: 0; + bottom: 0; + left: 50px; + list-style: none; + height: 40px; + margin: 0; + padding: 0; +} + +.ebSystemBar-topMenu li { + display: inline-block; +} + +.ebSystemBar-topMenu a { + padding: 0 5px 0 15px; + margin: 0; + font-size: 1.6em; + line-height: 40px; + color: #58585a; + cursor: pointer; + text-decoration: none; +} + +.ebSystemBar-topMenu a:hover { + color: #0066B3; +} + +.ebSystemBar-rightButton { + float: right; + display: inline-block; + line-height: 40px; + vertical-align: middle; +} + +.ebSystemBar-rightButton a { + display: block; + padding: 0 18px 0 18px; + font-size: 1.3rem; + color: #0066B3; + background-color: transparent; + background-repeat: no-repeat; + background-position: 18px center; + border-left: solid 1px #D2D2D2; +} + +.ebSystemBar-rightButton a:hover { + text-decoration: underline; +} + +.ebSystemBar-rightButton:hover { + background-image: linear-gradient(180deg, #f2f2f2 0%, #e8e8e8 100%); +} + +@media screen and (max-width: 640px) { + .ebSystemBar-topBar-rightButton a { + width: 0; + padding-left: 34px; + text-indent: -9999px; + } +} + +/* Inline Message */ +.ebInlineMessage { + padding: 5px 15px 0px 7px; + font-size: 0; + position: fixed; + bottom: 0; + left: 2; + width: calc(100% - 30px); + height: 66px; + border: 3px solid #adadad; + background-color: #FFFFFF; +} + +.ebInlineMessage-iconHolder, .ebInlineMessage-contentHolder { + display: inline-block; + vertical-align: top; +} + +.ebInlineMessage-iconHolder { + width: 20px; + margin: 0 12px 0 0; +} + +.ebInlineMessage-contentHolder { + width: calc(100% - 32px); + font-size: 1.2rem; +} + +.ebInlineMessage-header { + margin-top: 3px; + font-size: 14px; + line-height: 14px; +} + +.ebInlineMessage-separator { + height: 1px; + margin: 12px 0; + background-color: #adadad; + opacity: 0.3; +} + +.ebInlineMessage-description { + color: #666666; + white-space: pre; +} + +/* Table */ +.ebTable { + margin: 0; + padding: 0; + table-layout: fixed; + border-left: 1px solid #cccccc; // + ewatkmi: added for visible border; + border-right: 1px solid #cccccc; // + ewatkmi: added for visible border; + border-bottom: 1px solid #cccccc; // + ewatkmi: added for visible border; + border-collapse: collapse; + border-spacing: 0; + color: #1a1a1a; +} + +.ebTable_fullW { + width: 100%; +} + +.ebTable-th_resizable, .ebTable-th_sortable { + position: relative; +} + +.ebTable-th_resizable .ebTable-headerResize { + position: absolute; + top: -20px; + bottom: -20px; + right: -12px; + width: 10px; + cursor: col-resize; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; +} + +.ebTable-th_sortable { + cursor: pointer !important; +} + +.ebTable-th_sortable .ebTable-header { + display: flex; + flex-wrap: nowrap; + flex-direction: row; + align-items: center; +} + +.ebTable-th_sortable .ebTable-headerText { + flex-shrink: 1; + flex-grow: 0; + margin-right: 8px; + box-sizing: border-box; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; +} + +.ebTable-th_sortable .ebTable-headerSort { + flex-grow: 0; + flex-shrink: 0; + flex-basis: 10px; + margin-left: 4px; +} + +.ebTable-th_sortable .ebTable-headerSortOrder { + flex-grow: 1; + color: #999999; + font-weight: normal; +} + +.ebTable-header { + position: relative; + display: block; + width: 100%; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.ebTable-headerText { + padding: 4px 0; + display: inline-block; + vertical-align: middle; + width: 100%; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.ebTable thead tr { + height: 3.2rem; + font-size: 1.2rem; + font-weight: bold; + text-align: left; +} + +.ebTable thead tr th { + padding-left: 1.2rem; + padding-right: 1.2rem; + text-align: left; + cursor: default; + border-top: #cccccc solid 1px; + border-bottom: #cccccc solid 1px; + border-right: #e6e6e6 solid 1px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.ebTable thead tr th:last-child { + border-right: none; +} + +.ebTable thead tr:hover { + background: none; +} + +.ebTable thead tr:active { + background: none; +} + +.ebTable tbody tr { + height: 3.2rem; + font-size: 1.2rem; + border-bottom: #e6e6e6 solid 1px; +} + +.ebTable tbody tr td { + margin: 0; + padding: 0 1.2rem; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + cursor: default; + border-right: #e6e6e6 solid 1px; +} + +.ebTable tbody tr td:last-child { + border-right: none; +} + +.ebTable_striped tbody tr { + border-bottom: none; +} + +.ebTable_striped tbody tr td { + border-right: none; +} + +.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #f2f2f2; +} + +.ebTable_striped tbody tr:nth-of-type(odd) { // + ewatkmi: added for nested tables; + background-color: #ffffff; +} + +.ebTable_compact tbody tr { + height: 2.6rem; +} + +.ebTable_expandableStriped { + border-collapse: separate; +} + +.ebTable_expandableStriped tbody tr { + border-bottom: none; +} + +.ebTable_expandableStriped tbody tr td { + border-right: none; +} + +.ebTable_expandableStriped tbody tr:nth-of-type(4n-1), + .ebTable_expandableStriped tbody tr:nth-of-type(4n) { + background-color: #f2f2f2; +} + +.ebTable_pinstripe tr td { + border-bottom: #e6e6e6 solid 1px; +} + +.ebTable_color_paleBlue.ebTable thead tr th { + background-color: #99ddee; + border-top: none; + border-bottom: none; +} + +.ebTable_color_paleBlue.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #e6f6fb; +} + +.ebTable_color_purple.ebTable thead tr th { + background-color: #ca9bc1; + border-top: none; + border-bottom: none; +} + +.ebTable_color_purple.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #f2e6ef; +} + +.ebTable_color_darkGreen.ebTable thead tr th { + background-color: #99c0bf; + border-top: none; + border-bottom: none; +} + +.ebTable_color_darkGreen.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #e6efef; +} + +.ebTable_color_green.ebTable thead tr th { + background-color: #d0e3a2; + border-top: none; + border-bottom: none; +} + +.ebTable_color_green.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #f3f8e8; +} + +.ebTable_color_yellow.ebTable thead tr th { + background-color: #fde499; + border-top: none; + border-bottom: none; +} + +.ebTable_color_yellow.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #fff8e6; +} + +.ebTable_color_orange.ebTable thead tr th { + background-color: #f9d099; + border-top: none; + border-bottom: none; +} + +.ebTable_color_orange.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #fef3e6; +} + +.ebTable_color_red.ebTable thead tr th { + background-color: #f4a6a3; + border-top: none; + border-bottom: none; +} + +.ebTable_color_red.ebTable_striped tbody tr:nth-of-type(even) { + background-color: #fce9e8; +} + +.ebTable_borderTop_none thead tr th { + border-top: none; +} + +.ebTable_verticalBorders_none thead tr th, .ebTable_verticalBorders_none tr td + { + border-right: none !important; + border-left: none !important; +} + +.ebTable_wrapHeaders th { + white-space: normal !important; + text-overflow: inherit !important; +} + +.ebTable_wrapHeaders th .ebTable-headerText { + white-space: normal !important; + text-overflow: inherit !important; +} + +.ebTable-expandableRow { + height: inherit !important; + display: none; +} + +.ebTable-expandableRow_expanded { + display: table-row; +} + +.ebTable-expandableRow>td { + padding: 0 !important; +} + +.ebTable-expandableRow>td>div { + overflow: hidden; + height: 0; + transition: height 0.3s ease-in-out; +} +/** + * Hover/Active/Selected Effects + * + * Modifiers: + * .ebTable_hoverActive_none (disables native hover and active selectors, primarily for pin columns plugin) + */ +.ebTable { + /** Hover effect **/ + +} + +.ebTable.ebTable:not (.ebTable_hoverActive_none ) tbody tr:not (.ebTable-expandableRow + ):not (.headerRow ):hover>*, .ebTable tbody tr:not (.ebTable-expandableRow + ):not (.headerRow ).ebTableRow_hover>* { + background-image: linear-gradient(0deg, rgba(0, 102, 179, 0.1), + rgba(0, 102, 179, 0.1)); +} + +.ebTable.ebTable_highlightedEffect_solid tbody tr:not (.ebTable-expandableRow + ).ebTableRow_highlighted>* { + background-color: #ffffff !important; +} + +/* Context Menu */ +.ebContextMenu { + position: relative; + width: 16px; + height: 16px; +} + +.ebContextMenu:focus { + outline: none; +} + +.ebContextMenu-ExpandBtn, .ebContextMenu-expandBtn { + width: 16px; + height: 16px; + position: relative; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; +} + +.ebContextMenu-ExpandBtn:focus, .ebContextMenu-expandBtn:focus { + outline: none; +} + +.ebContextMenu-Dropdown, .ebContextMenu-body { + position: absolute; + z-index: 1500; + min-width: 60px; + width: auto; + height: auto; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; + box-shadow: 5px 5px 5px #87888A; +} + +.ebContextMenu-Dropdown_corner_default, + .ebContextMenu-body_corner_default { + position: absolute; + top: 20px; + left: 0px; +} + +.ebContextMenu-Dropdown_corner_topRight, + .ebContextMenu-body_corner_topRight { + position: absolute; + top: 20px; + right: 0px; +} + +.ebContextMenu-Dropdown_corner_bottomLeft, + .ebContextMenu-body_corner_bottomLeft { + position: absolute; + bottom: 20px; + left: 0px; +} + +.ebContextMenu-Dropdown_corner_bottomRight, + .ebContextMenu-body_corner_bottomRight { + position: absolute; + bottom: 20px; + right: 0px; +} + +.ebContextMenu-Dropdown_visible_false, .ebContextMenu-body_visible_false + { + visibility: hidden; +} + +.ebContextMenu-Dropdown_visible_true, .ebContextMenu-body_visible_true { + display: block; +} + +/* Component List */ +.ebComponentList { + position: relative; + z-index: 1500; + padding: 4px 0; + margin: 0; + color: #333333; + list-style: none; + background-color: #ffffff; + border: #bfbfbf solid 1px; + box-shadow: 0 0 5px 0 rgba(0, 0, 0, 0.2); + border-radius: 3px; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +.ebComponentList-group, .ebComponentList-item { + padding: 0 0.8rem; + line-height: 2.4rem; + font-size: 1.2rem; + background-color: #ffffff; +} + +.ebComponentList-iconHolder { + display: inline-block; + vertical-align: middle; + width: 16px; + padding-right: 8px; +} + +.ebComponentList-item { + cursor: pointer; +} + +.ebComponentList-item-name { + display: inline-block; + font-size: 12px; + text-overflow: ellipsis; + overflow: hidden; + width: calc(100% - 24px); + vertical-align: middle; +} + +.ebComponentList-item_icon { + font-size: 0; +} + +.ebComponentList-link, .ebComponentList-item, .ebComponentList-item>*, + .ebComponentList-group-header { + white-space: nowrap; + text-overflow: ellipsis; + overflow: hidden; +} + +.ebComponentList-group { + display: block; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header, + .ebComponentList-group_expandable_expanded>.ebComponentList-group-header + { + font-size: 0; + cursor: pointer; + white-space: nowrap; + height: 24px; + vertical-align: middle; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header .ebComponentList-iconHolder+.ebComponentList-group-name, + .ebComponentList-group_expandable_expanded>.ebComponentList-group-header .ebComponentList-iconHolder+.ebComponentList-group-name + { + width: calc(100% - 40px); +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-inner, + .ebComponentList-group_expandable_expanded>.ebComponentList-inner { + padding: 0 0 0 24px; + margin: 0 -0.8rem; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header + { + border: none; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-item + { + overflow: hidden; + padding: 0; + margin: 0; + height: 0; + opacity: 0; + transition: height 0.2s linear, padding 0.075s 0.075s linear, margin + 0.075s 0.075s linear, opacity 0.075s linear; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group_expandable_collapsed .ebComponentList-group-header, + .ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group_expandable_expanded .ebComponentList-group-header + { + overflow: hidden; + padding: 0; + margin: 0; + height: 0; + opacity: 0; + transition: height 0.2s linear, padding 0.075s 0.075s linear, margin + 0.075s 0.075s linear, opacity 0.075s linear; +} + +.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group>.ebComponentList-inner + { + padding: 0; + margin: 0; + transition: padding 0.1s 0.1s linear, margin 0.1s 0.1s linear; +} + +.ebComponentList-group_expandable_expanded>.ebComponentList-group-header + { + border-bottom: 1px solid #999; +} + +.ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-item + { + overflow: hidden; + height: 24px; + transition: height 0.2s linear, padding 0.075s linear, margin 0.075s + linear, opacity 0.15s 0.15s linear; +} + +.ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-group_expandable_expanded>.ebComponentList-group-header, + .ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header + { + overflow: hidden; + height: 24px; + text-overflow: ellipsis; + transition: height 0.2s linear, padding 0.075s linear, margin 0.075s + linear, opacity 0.15s 0.15s linear; +} + +.ebComponentList-group:not (.ebComponentList-group_expandable_collapsed + ):not (.ebComponentList-group_expandable_expanded ) >.ebComponentList-group-header + { + cursor: default !important; + pointer-events: none !important; + -ms-touch-action: none !important; + touch-action: none !important; + -khtml-user-select: none !important; + -moz-user-select: none !important; + -o-user-select: none !important; + -webkit-user-select: none !important; + user-select: none; +} + +.ebComponentList-group-header { + font-size: 1.2rem; + font-weight: bold; + line-height: 2.4rem; + border-bottom: 1px solid #999; + background-color: #ffffff; +} + +.ebComponentList-group-header_icon { + font-size: 0; +} + +.ebComponentList-group-header_icon>.ebComponentList-group-name { + width: calc(100% - 24px); +} + +.ebComponentList-group-name { + display: inline-block; + width: calc(100% - 16px); + font-size: 1.2rem; + line-height: 2.4rem; + font-weight: bold; + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; + vertical-align: middle; +} + +.ebComponentList-inner { + margin: 0 -0.8rem; + padding: 4px 0 0 0; +} + +.ebComponentList-link { + display: block; +} + +.ebComponentList-link:hover { + text-decoration: none; +} + +.ebComponentList-separator { + height: 1px; + margin: 0.4rem; + background-color: #E6E6E6; +} + +.ebComponentList_focus_forced .ebComponentList-item:hover { + background-color: transparent; +} + +.ebComponentList_focus_forced .ebComponentList-item_focused:hover { + background-color: #e6f0f7; +} + +.ebComponentList:not (.ebComponentList_focus_forced ) .ebComponentList-item:hover + { + background-color: #e6f0f7; +} + +.ebComponentList_focus_forced .ebComponentList-item:active, + .ebComponentList:not (.ebComponentList_focus_forced ) .ebComponentList-item:active + { + background-color: #cce0f0; +} + +.ebComponentList-item { + /* Fixes MultiSelectBox ellipsis bug in Firefox */ + margin: 0px !important; + font-size: 1em !important; +} + +.ebComponentList-item_focused { + background-color: #e6f0f7; +} + +.ebComponentList-item_disabled { + color: #b0b0af; + cursor: not-allowed !important; +} + +.ebComponentList-item_disabled:hover, .ebComponentList-item_disabled:active + { + background-color: inherit !important; +} + +.ebComponentList-item_selected { + position: relative; + cursor: default; +} + +.ebComponentList-item_selected>.ebComponentList-link { + cursor: default; + color: #333333; + cursor: default !important; + pointer-events: none !important; + -ms-touch-action: none !important; + touch-action: none !important; + -khtml-user-select: none !important; + -moz-user-select: none !important; + -o-user-select: none !important; + -webkit-user-select: none !important; + user-select: none; +} + +.ebComponentList-item_selected:before { + position: absolute; + content: ""; + left: 0; + top: 0; + bottom: 0; + width: 100%; + opacity: .2; + background-color: #0967b2; +} + +.ebComponentList-item>.ebComponentList-checkboxHolder>.ebCheckbox { + margin-left: 1px; +} + +.ebComponentList-item>.ebComponentList-checkboxHolder>.ebCheckbox-label + { + padding-left: 3px; + overflow: hidden; + font-size: 12px; + line-height: 2.4rem; + text-overflow: ellipsis; + width: calc(100% - 24px); +} + +.ebComponentList-info { + color: #333333; + font-style: italic; + text-align: center; +} + +.ebComponentList-info:hover { + background-color: #ffffff; +} + +.ebComponentList-info:active { + background-color: #ffffff; +} + +.ebComponentList-info, .ebComponentList-loader { + display: none; + margin: 0.6rem; + cursor: default; +} + +.ebComponentList_info .ebComponentList-group, .ebComponentList_info .ebComponentList-separator, + .ebComponentList_info .ebComponentList-item { + display: none; +} + +.ebComponentList_info .ebComponentList-info { + display: block; +} + +.ebComponentList_loading { + min-height: 34px; +} + +.ebComponentList_loading .ebComponentList-loader { + display: block; +} + +.ebComponentList_loading .ebComponentList-item_selected:before { + display: none; +} + +.ebComponentList_loading>.ebComponentList-group, + .ebComponentList_loading>.ebComponentList-item, + .ebComponentList_loading>.ebComponentList-items>.ebComponentList-group, + .ebComponentList_loading>.ebComponentList-items>.ebComponentList-item { + opacity: 0.4; +} + +/* Scrollbar */ +.eb_scrollbar { + -webkit-overflow-scrolling: touch; + overflow: auto; +} + +.eb_scrollbar::-webkit-scrollbar { + width: 14px; + height: 14px; +} + +.eb_scrollbar::-webkit-scrollbar-track { + background-color: #f0f0f0; + background-clip: content-box; +} + +.eb_scrollbar::-webkit-scrollbar-thumb { + background-color: #cccccc; + border-radius: 3px; + transition: all 0.2s linear; + background-clip: content-box; +} + +.eb_scrollbar::-webkit-scrollbar-thumb:hover { + background-color: #999999; +} + +.eb_scrollbar::-webkit-scrollbar-button { + width: 14px; + height: 14px; + background-repeat: no-repeat; + background-color: #f0f0f0; + background-position: center; +} + +.eb_scrollbar::-webkit-scrollbar-button:hover { + background-color: #cccccc; +} + +.eb_scrollbar::-webkit-scrollbar-button:vertical:decrement { + background-position: center 4px; + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M0.293,3.293l3-3C3.488,0.098,3.744,0,4,0s0.512,0.098,0.707,0.293l3,3c0.391,0.391,0.391,1.023,0,1.414 s-1.023,0.391-1.414,0L4,2.414L1.707,4.707c-0.391,0.391-1.023,0.391-1.414,0S-0.098,3.684,0.293,3.293z'/></svg>"); + border-top-left-radius: 2px; + border-top-right-radius: 2px; +} + +.eb_scrollbar::-webkit-scrollbar-button:vertical:increment { + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M7.707,1.707l-3,3C4.512,4.902,4.255,5,4,5S3.488,4.902,3.292,4.707l-3-3c-0.391-0.391-0.391-1.023,0-1.414 s1.023-0.391,1.414,0L4,2.586l2.293-2.293c0.391-0.391,1.023-0.391,1.414,0S8.098,1.316,7.707,1.707z'/></svg>"); + border-bottom-left-radius: 2px; + border-bottom-right-radius: 2px; +} + +.eb_scrollbar::-webkit-scrollbar-button:horizontal:decrement { + background-position: 4px center; + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M4.707,6.293c0.391,0.391,0.391,1.023,0,1.414C4.512,7.902,4.256,8,4,8S3.488,7.902,3.293,7.707l-3-3 C0.105,4.52,0,4.266,0,4s0.105-0.52,0.293-0.707l3-3c0.391-0.391,1.023-0.391,1.414,0c0.391,0.39,0.391,1.023,0,1.414L2.414,4 L4.707,6.293z'/></svg>"); + border-bottom-left-radius: 2px; + border-top-left-radius: 2px; +} + +.eb_scrollbar::-webkit-scrollbar-button:horizontal:increment { + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M0.293,1.707c-0.391-0.391-0.391-1.023,0-1.414C0.488,0.098,0.744,0,1,0s0.512,0.098,0.707,0.293l3,3 C4.895,3.48,5,3.734,5,4s-0.105,0.52-0.293,0.707l-3,3c-0.391,0.391-1.023,0.391-1.414,0s-0.391-1.023,0-1.414L2.586,4L0.293,1.707z'/></svg>"); + border-bottom-right-radius: 2px; + border-top-right-radius: 2px; +} + +/* Input */ +.ebInput { + display: inline-block; + vertical-align: middle; + text-align: left; + font-size: 1.2rem; + width: 140px; + height: 2.4rem; + padding: 0.4rem 0.6rem; + border: 1px solid #b3b3b3; + -moz-box-sizing: border-box; + box-sizing: border-box; + border-radius: 3px; + box-shadow: inset 1px 1px 0 0 #cccccc; + -webkit-appearance: none; + -moz-appearance: none; + -ms-appearance: none; + appearance: none; +} + +.ebInput_wMargin { + margin: 6px; +} + +.ebInput_txtCenter { + text-align: center; +} + +.ebInput_miniW, .ebInput_width_mini { + width: 40px; +} + +.ebInput_smallW, .ebInput_width_small { + width: 80px; +} + +.ebInput_longW, .ebInput_width_long { + width: 180px; +} + +.ebInput_xLongW, .ebInput_width_xLong { + width: 220px; +} + +.ebInput_width_full { + min-width: 40px; + width: 100%; +} + +.ebInput_noRightSide { + border-width: 1px 0 1px 1px; + border-radius: 3px 0 0 3px; +} + +.ebInput_noLeftSide { + border-width: 1px 1px 1px 0; + border-radius: 0 3px 3px 0; + box-shadow: inset 0 1px 0 0 #cccccc; +} + +.ebInput:hover { + border-color: #666666; +} + +.ebInput[readonly] { + cursor: text; // + box-shadow: none; + border-color: #E3E3E3; + background-color: #f0f0f0; + color: #b2b2b2; +} + +.ebInput[readonly]:hover { // + border-color: #E3E3E3; +} + +.ebInput_disabled, .ebInput:disabled { + color: #B2B2B2; + border-color: #B2B2B2; + background-color: rgba(0, 0, 0, 0.05); + -webkit-text-fill-color: #b2b2b2; + opacity: 1; + -ms-touch-action: none !important; + touch-action: none !important; + box-shadow: inset 1px 1px 0 0 #cccccc; +} + +.ebInput_borderColor { + border-color: #b3b3b3; +} + +.ebInput_borderColor_red { + border-color: #e32119; +} + +.ebInput_status_none { + border-color: #b3b3b3; +} + +.ebInput_status_warning { + border-color: #f08a00; +} + +.ebInput_status_error { + border-color: #e32119; +} + +.ebInput.eb_wMargin+.ebInput-status { + margin: -0.2rem 0.8rem 0 0.6rem; +} + +.ebInput-status { + display: block; + margin: 0.4rem 0 0 0; + line-height: 1.2rem; + min-height: 1.8rem; + font-size: 1.2rem; + font-weight: normal; +} + +.ebInput-statusOk, .ebInput-statusError { + vertical-align: middle; +} + +.ebInput-statusOk:before, .ebInput-statusError:before { + display: inline-block; + vertical-align: middle; + margin: 0 0.6rem 0 0; + width: 1.2rem; + height: 1.2rem; + content: ''; + background-repeat: no-repeat; +} + +.ebInput-statusInfo { + vertical-align: middle; + color: #8d8d8d; +} + +.ebInput-statusOk { + color: #89ba17; + display: none; +} + +.ebInput-statusOk:before { + background-image: url('../resources/form/valid_icon.svg'); +} + +.ebInput-statusError { + color: #e32119; + display: none; +} + +.ebInput-statusError:before { + background-image: url('../resources/form/invalid_icon.svg'); +} + +.ebInput-status_none { + display: none; +} + +.ebInput-status_hide .ebInput-statusOk, .ebInput-status_hide .ebInput-statusError, + .ebInput-status_hide .ebInput-statusInfo { + display: none; +} + +.ebInput-status_info .ebInput-statusInfo { + display: inline-block; +} + +.ebInput-status_info .ebInput-statusOk, .ebInput-status_info .ebInput-statusError + { + display: none; +} + +.ebInput-status_ok .ebInput-statusOk { + display: inline-block; +} + +.ebInput-status_ok .ebInput-statusError, .ebInput-status_ok .ebInput-statusInfo + { + display: none; +} + +.ebInput-status_error .ebInput-statusError { + display: inline-block; +} + +.ebInput-status_error .ebInput-statusOk, .ebInput-status_error .ebInput-statusInfo + { + display: none; +} + +.ebInput:not (.ebInput_validation_focusLost ):valid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusOk { + display: inline-block; +} + +.ebInput:not (.ebInput_validation_focusLost ):invalid:not (.ebInput_borderColor + ):not (.ebInput_status_warning ):not (.ebInput_status_none ) { + border-color: #e32119; +} + +.ebInput:not (.ebInput_validation_focusLost ):invalid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusError { + display: inline-block; +} + +.ebInput:not (.ebInput_validation_focusLost ):invalid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusInfo { + display: none; +} + +.ebInput.ebInput_validation_focusLost:not (:focus ):valid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusOk { + display: inline-block; +} + +.ebInput.ebInput_validation_focusLost:not (:focus ):invalid:not (.ebInput_borderColor + ):not (.ebInput_status_warning ):not (.ebInput_status_none ) { + border-color: #e32119; +} + +.ebInput.ebInput_validation_focusLost:not (:focus ):invalid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusError { + display: inline-block; +} + +.ebInput.ebInput_validation_focusLost:not (:focus ):invalid+.ebInput-status:not + (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok + ):not (.ebInput-status_error ) .ebInput-statusInfo { + display: none; +} + +/* Textarea */ +.ebTextArea { + -webkit-overflow-scrolling: touch; + overflow: auto; + display: inline-block; + vertical-align: middle; + text-align: left; + font-size: 1.2rem; + width: 140px; + padding: 0.4rem 0.6rem; + margin: 0; + border: 1px solid #b3b3b3; + font-family: arial; + -moz-box-sizing: border-box; + box-sizing: border-box; + border-radius: 3px; + box-shadow: inset 1px 1px 0 0 #cccccc; + -webkit-appearance: none; + -moz-appearance: none; + -ms-appearance: none; + appearance: none; +} + +.ebTextArea::-webkit-scrollbar { + width: 14px; + height: 14px; +} + +.ebTextArea::-webkit-scrollbar-track { + background-color: #f0f0f0; + background-clip: content-box; +} + +.ebTextArea::-webkit-scrollbar-thumb { + background-color: #cccccc; + border-radius: 3px; + transition: all 0.2s linear; + background-clip: content-box; +} + +.ebTextArea::-webkit-scrollbar-thumb:hover { + background-color: #999999; +} + +.ebTextArea::-webkit-scrollbar-button { + width: 14px; + height: 14px; + background-repeat: no-repeat; + background-color: #f0f0f0; + background-position: center; +} + +.ebTextArea::-webkit-scrollbar-button:hover { + background-color: #cccccc; +} + +.ebTextArea::-webkit-scrollbar-button:vertical:decrement { + background-position: center 4px; + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M0.293,3.293l3-3C3.488,0.098,3.744,0,4,0s0.512,0.098,0.707,0.293l3,3c0.391,0.391,0.391,1.023,0,1.414 s-1.023,0.391-1.414,0L4,2.414L1.707,4.707c-0.391,0.391-1.023,0.391-1.414,0S-0.098,3.684,0.293,3.293z'/></svg>"); + border-top-left-radius: 2px; + border-top-right-radius: 2px; +} + +.ebTextArea::-webkit-scrollbar-button:vertical:increment { + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M7.707,1.707l-3,3C4.512,4.902,4.255,5,4,5S3.488,4.902,3.292,4.707l-3-3c-0.391-0.391-0.391-1.023,0-1.414 s1.023-0.391,1.414,0L4,2.586l2.293-2.293c0.391-0.391,1.023-0.391,1.414,0S8.098,1.316,7.707,1.707z'/></svg>"); + border-bottom-left-radius: 2px; + border-bottom-right-radius: 2px; +} + +.ebTextArea::-webkit-scrollbar-button:horizontal:decrement { + background-position: 4px center; + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M4.707,6.293c0.391,0.391,0.391,1.023,0,1.414C4.512,7.902,4.256,8,4,8S3.488,7.902,3.293,7.707l-3-3 C0.105,4.52,0,4.266,0,4s0.105-0.52,0.293-0.707l3-3c0.391-0.391,1.023-0.391,1.414,0c0.391,0.39,0.391,1.023,0,1.414L2.414,4 L4.707,6.293z'/></svg>"); + border-bottom-left-radius: 2px; + border-top-left-radius: 2px; +} + +.ebTextArea::-webkit-scrollbar-button:horizontal:increment { + background-image: + url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M0.293,1.707c-0.391-0.391-0.391-1.023,0-1.414C0.488,0.098,0.744,0,1,0s0.512,0.098,0.707,0.293l3,3 C4.895,3.48,5,3.734,5,4s-0.105,0.52-0.293,0.707l-3,3c-0.391,0.391-1.023,0.391-1.414,0s-0.391-1.023,0-1.414L2.586,4L0.293,1.707z'/></svg>"); + border-bottom-right-radius: 2px; + border-top-right-radius: 2px; +} + +.ebTextArea_noMargin { + margin: 0; +} + +.ebTextArea_txtCenter { + text-align: center; +} + +.ebTextArea_miniW, .ebTextArea_width_mini { + width: 40px; +} + +.ebTextArea_smallW, .ebTextArea_width_small { + width: 80px; +} + +.ebTextArea_longW, .ebTextArea_width_long { + width: 180px; +} + +.ebTextArea_xLongW, .ebTextArea_width_xLong { + width: 220px; +} + +.ebTextArea_width_full { + min-width: 40px; + width: 100%; +} + +.ebTextArea_noRightSide { + border-width: 1px 0 1px 1px; + border-radius: 3px 0 0 3px; +} + +.ebTextArea_noLeftSide { + border-width: 1px 1px 1px 0; + border-radius: 0 3px 3px 0; +} + +.ebTextArea:hover { + border-color: #666666; +} + +.ebTextArea[readonly] { + cursor: text; + border-color: #E3E3E3; + background-color: #f0f0f0; + color: #b2b2b2; +} + +.ebTextArea[readonly]:hover { // + border-color: #E3E3E3; +} + +.ebTextArea_disabled, .ebTextArea:disabled { + color: #B2B2B2; + border-color: #B2B2B2; + background-color: rgba(0, 0, 0, 0.05); + -ms-touch-action: none; + touch-action: none; + -webkit-text-fill-color: #b2b2b2; + opacity: 1; + box-shadow: inset 1px 1px 0 0 #cccccc; +} + +.ebTextArea_status_none { + border-color: #b3b3b3; +} + +.ebTextArea_status_warning { + border-color: #f08a00; +} + +.ebTextArea_status_error { + border-color: #e32119; +} + +.ebTextArea:invalid:not (.ebTextArea_status_warning ):not (.ebTextArea_status_none + ) { + border-color: #e32119; +} + +/* Button */ +.ebBtn { + position: relative; + display: inline-block; + vertical-align: middle; + color: #333333; + background-color: #ffffff; + border: none; + min-width: 60px; + box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); + border-radius: 3px; + -moz-box-sizing: border-box; + box-sizing: border-box; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.1) 100%); + padding: 0 8px; + height: 2.4rem; + font-size: 1.2rem; + white-space: nowrap; + text-decoration: none; + text-align: center; + cursor: pointer; +} + +a.ebBtn:hover { + color: #333; +} + +a.ebBtn:focus, a.ebBtn:active, a.ebBtn_active { + text-decoration: none; +} + +.ebBtn:focus { + outline: none; + box-shadow: 0 0 2px 1px #4d90fe, 0 0 0 1px rgba(0, 0, 0, 0.2) inset; +} + +.ebBtn_color_blue, .ebBtn_color_darkBlue, .ebBtn_color_paleBlue, + .ebBtn_color_darkGreen, .ebBtn_color_green, .ebBtn_color_orange, + .ebBtn_color_red, .ebBtn_color_purple { + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.3) 100%); + color: #F0F0F0 !important; +} + +.ebBtn_color_blue:hover, .ebBtn_color_darkBlue:hover, + .ebBtn_color_paleBlue:hover, .ebBtn_color_darkGreen:hover, + .ebBtn_color_green:hover, .ebBtn_color_orange:hover, .ebBtn_color_red:hover, + .ebBtn_color_purple:hover { + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.1) 100%); +} + +.ebBtn_color_blue { + background-color: #0966b3; +} + +.ebBtn_color_darkBlue { + background-color: #0066b3; +} + +.ebBtn_color_paleBlue { + background-color: #00A9D4; +} + +.ebBtn_color_darkGreen { + background-color: #00625F; +} + +.ebBtn_color_green { + background-color: #89BA17; +} + +.ebBtn_color_orange { + background-color: #F08A00; +} + +.ebBtn_color_red { + background-color: #E32119; +} + +.ebBtn_color_purple { + background-color: #953882; +} + +.ebBtn_small { + font-size: 1.1rem; + padding: 0 6px; + height: 2rem; +} + +.ebBtn_large { + font-size: 1.4rem; + padding: 0 10px; + height: 3.8rem; +} + +.ebBtn:hover { + text-decoration: none; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.15) 100%); +} + +.ebBtn_active, .ebBtn:active, .ebBtn_active:hover { + text-decoration: none; + box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px + rgba(0, 0, 0, 0.2); + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, + rgba(0, 0, 0, 0.2) 100%); +} + +.ebBtn:disabled, .ebBtn_disabled, .ebBtn:disabled:hover, .ebBtn_disabled:hover, + .ebBtn:disabled:active, .ebBtn_disabled:active { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; + background: rgba(0, 0, 0, 0.1); + color: #8d8d8d !important; +} + +.ebBtn:disabled .ebIcon, .ebBtn_disabled .ebIcon { + opacity: 0.3; +} + +.ebBtn_subtle { + background-image: none; + background-color: transparent; + box-shadow: none; + min-width: auto; +} + +.ebBtn_subtle:hover { + background-image: none; + box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); +} + +.ebBtn_subtle:focus { + box-shadow: 0 0 2px 1px #4d90fe, 0 0 0 1px rgba(0, 0, 0, 0.2) inset; +} + +.ebBtn_subtle:active, .ebBtn_subtle.ebBtn_subtle_active { + text-decoration: none; + box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px + rgba(0, 0, 0, 0.2); + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, + rgba(0, 0, 0, 0.2) 100%); +} + +.ebBtn_subtle:disabled, .ebBtn_subtle.ebBtn_subtle_disabled, + .ebBtn_subtle:disabled:hover, .ebBtn_subtle.ebBtn_subtle_disabled:hover, + .ebBtn_subtle:disabled:active, .ebBtn_subtle.ebBtn_subtle_disabled:active + { + background-color: transparent; + box-shadow: none; +} + +.ebBtn:active:focus, .ebBtn_active:focus { + box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px + rgba(0, 0, 0, 0.2), 0 0 2px 1px #4d90fe; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, + rgba(0, 0, 0, 0.2) 100%); +} + +/* Combobox */ +.ebCombobox { + position: relative; + display: inline-block; + vertical-align: middle; + white-space: nowrap; + margin: 0; + padding: 0; + height: 2.4rem; +} + +.ebCombobox_width_full { + min-width: 70px; + width: 100%; +} + +.ebCombobox_width_full .ebInput { + width: calc(100% - 30px); +} + +.ebCombobox-list, .ebCombobox-body { + position: absolute; + margin-top: 6px; + display: none; + width: 100%; +} + +.ebCombobox-list_rightAlign, .ebCombobox-body_rightAlign { + right: 0; +} + +.ebCombobox-Helper, .ebCombobox-helper { + position: relative; + display: inline-block; + vertical-align: middle; + width: 30px; + /*height: 100%; ewwatkmi: replaced with 2.4rem below*/ + height: 2.4rem; + cursor: pointer; + border: 1px solid #999999; + background-color: #ffffff; + -moz-box-sizing: border-box; + box-sizing: border-box; + border-radius: 0 3px 3px 0; + -webkit-appearance: none; + -moz-appearance: none; + -ms-appearance: none; + appearance: none; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.1) 100%); +} + +.ebCombobox-Helper:hover, .ebCombobox-helper:hover { + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.15) 100%); +} + +.ebCombobox-Helper:active, .ebCombobox-helper:active { + box-shadow: inset 2px 2px 3px 0 rgba(0, 0, 0, 0.35); + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, + rgba(0, 0, 0, 0.2) 100%); +} + +.ebCombobox-Helper:disabled, .ebCombobox-helper:disabled { + border-color: #b2b2b2; +} + +.ebCombobox-Helper:disabled, .ebCombobox-helper:disabled, + .ebCombobox-Helper:disabled:hover, .ebCombobox-helper:disabled:hover, + .ebCombobox-Helper:disabled:active, .ebCombobox-helper:disabled:active + { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; + background: #e5e5e5; + color: #B2B2B2; + cursor: not-allowed; + box-shadow: none; +} + +.ebCombobox-Helper .ebCombobox-iconHolder, .ebCombobox-helper .ebCombobox-iconHolder + { + display: inline-block; + opacity: 0.7; + cursor: pointer; + line-height: 2.2rem; +} + +.ebCombobox-Helper .ebCombobox-iconHolder .ebIcon, .ebCombobox-helper .ebCombobox-iconHolder .ebIcon + { + position: absolute; + top: 0; + bottom: 0; + left: 0; + right: 0; + margin: auto; +} + +.ebCombobox:hover>.ebCombobox-Helper, .ebCombobox:hover>.ebCombobox-helper + { + border-color: #666666; +} + +.ebCombobox + +.ebInput +:focus + +~ +.ebCombobox-list +, /*.ebCombobox .ebInput:focus ~ .ebCombobox-body,*/ +.ebCombobox +:active +> +.ebCombobox-list +, /*.ebCombobox:active > .ebCombobox-body*/ +{ +display +: + +block +; + + +} +.ebCombobox>.ebCombobox-list, .ebCombobox>.ebCombobox-body { + display: none; +} + +.ebCombobox_noMargin { + margin: 0; +} + +.ebCombobox_disabled, .ebCombobox_disabled *:hover { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; +} + +.ebCombobox_disabled .ebCombobox-iconHolder, .ebCombobox_disabled .ebCombobox-iconHolder:hover, + .ebCombobox_disabled .ebCombobox-iconHolder:active { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; + opacity: 0.3; +} + +.ebCombobox_disabled:hover>.ebCombobox-Helper, .ebCombobox_disabled:hover>.ebCombobox-helper + { + border-color: #b2b2b2; +} + +.ebCombobox_disabled:active>.ebCombobox-list, .ebCombobox_disabled:active>.ebCombobox-body + { + display: none; +} + +.ebCombobox_disabled .ebInput:focus ~ .ebCombobox-list, + .ebCombobox_disabled .ebInput:focus ~ .ebCombobox-body { + display: none; +} + +.ebCombobox_status_warning .ebInput { + border-color: #f08a00; +} + +.ebCombobox_status_error .ebInput { + border-color: #e32119; +} + +/* Switcher */ +.ebSwitcher { + position: relative; + height: 24px; + width: 84px; + display: block; + overflow: hidden; + cursor: pointer; + border: 1px solid #ccc; + border-radius: 3px; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; +} + +.ebSwitcher-checkbox { + display: none; +} + +.ebSwitcher-body { + position: relative; + font-size: 0; + white-space: nowrap; + top: 0; + left: 0; + width: 100%; + height: 100%; + transition: left 0.2s linear; +} + +.ebSwitcher-onLabel, .ebSwitcher-switch, .ebSwitcher-offLabel { + display: inline-block; + vertical-align: top; + overflow: hidden; + height: 100%; +} + +.ebSwitcher-onLabel, .ebSwitcher-offLabel { + width: calc(100% - 24px); + line-height: 2.4rem; + color: white; + text-align: center; + font-size: 1.2rem; +} + +.ebSwitcher-onLabel { + background-color: red; +} + +.ebSwitcher-onLabel2 { + background-color: #89ba17; +} + +.ebSwitcher-offLabel { + background-color: #89ba17; +} + +.ebSwitcher-offLabel2 { + background-color: red; +} + +.ebSwitcher-switch { + height: 24px; + width: 24px; + transition: left 0.2s; +} + +.ebSwitcher-switch::after { + content: ""; + position: absolute; + margin: -1px; + width: 24px; + height: 24px; + display: inline-block; + background: #ffffff; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.1) 100%); + border-radius: 3px; + border: 1px solid rgba(0, 0, 0, 0.2); +} + +.ebSwitcher-checkbox:not (:checked ) +.ebSwitcher-body { + left: calc(-100% + 24px); +} + +.ebSwitcher:focus { + /* + outline: #4d90fe auto 5px; + box-shadow: 0 0 0 1px #4d90fe; + -webkit-box-shadow: none; + */ + outline: none; + box-shadow: 0 0 2px 1px #4d90fe; +} + +.ebSwitcher_status_warning { + border-color: #f08a00; +} + +.ebSwitcher_status_error { + border-color: #e32119; +} + +.ebSwitcher_disabled { + cursor: not-allowed; +} + +.ebSwitcher_disabled .ebSwitcher-onLabel, .ebSwitcher_disabled .ebSwitcher-offLabel, + .ebSwitcher_disabled .ebSwitcher-switch::after { + background-color: #e5e5e5; + background-image: none; + color: #8d8d8d; +} + +/* Dropdown */ +.ebDropdown { + position: relative; + display: inline-block; + height: 2.4rem; + padding: 0; + margin: 0; +} + +.ebDropdown-list, .ebDropdown-body { + position: absolute; + margin-top: 6px; + display: none; + min-width: 100%; +} + +.ebDropdown-list_rightAlign, .ebDropdown-body_rightAlign { + right: 0; +} + +.ebDropdown-Header, .ebDropdown-header { + position: relative; + display: inline-block; + vertical-align: middle; + height: 100%; + min-width: 60px; + margin: 0; + padding: 6px 8px; + line-height: 1.2rem; + font-size: 1.2rem; + text-align: left; + text-decoration: none; + white-space: nowrap; + color: #333333; + background-color: #ffffff; + border: none; + cursor: pointer; + box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); + border-radius: 3px; + -moz-box-sizing: border-box; + box-sizing: border-box; + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.1) 100%); +} + +.ebDropdown-Header:hover, .ebDropdown-header:hover { + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, + rgba(0, 0, 0, 0.15) 100%); +} + +.ebDropdown-Header:active, .ebDropdown-header:active { + box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px + rgba(0, 0, 0, 0.2); + background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, + rgba(0, 0, 0, 0.2) 100%); +} + +.ebDropdown-Header .ebDropdown-caption, .ebDropdown-header .ebDropdown-caption + { + display: inline-block; + padding: 0 4px 0 0; + vertical-align: middle; + min-width: 27px; +} + +.ebDropdown-Header .ebDropdown-iconHolder, .ebDropdown-header .ebDropdown-iconHolder + { + display: inline-block; + cursor: pointer; + opacity: 0.7; +} + +.ebDropdown .ebDropdown-Header:focus+.ebDropdown-list, .ebDropdown .ebDropdown-header:focus+.ebDropdown-body, + .ebDropdown .ebDropdown-Header:active+.ebDropdown-list, .ebDropdown .ebDropdown-header:active+.ebDropdown-body, + .ebDropdown:focus>.ebDropdown-list, .ebDropdown:focus>.ebDropdown-body, + .ebDropdown:active>.ebDropdown-list, .ebDropdown:active>.ebDropdown-body + { + display: block; +} + +.ebDropdown_disabled .ebDropdown-Header, .ebDropdown_disabled .ebDropdown-header + { + background: rgba(0, 0, 0, 0.1); + color: #B2B2B2; +} + +.ebDropdown_disabled .ebDropdown-Header, .ebDropdown_disabled .ebDropdown-header, + .ebDropdown_disabled .ebDropdown-Header:hover, .ebDropdown_disabled .ebDropdown-header:hover, + .ebDropdown_disabled .ebDropdown-Header:active, .ebDropdown_disabled .ebDropdown-header:active + { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; +} + +.ebDropdown_disabled .ebDropdown-Header:hover, .ebDropdown_disabled .ebDropdown-header:hover, + .ebDropdown_disabled .ebDropdown-Header:active, .ebDropdown_disabled .ebDropdown-header:active + { + background: rgba(0, 0, 0, 0.1); + color: #B2B2B2; + box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); +} + +.ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder, + .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder, + .ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder:hover, + .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder:hover, + .ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder:active, + .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder:active { + -ms-touch-action: none !important; + cursor: not-allowed !important; + touch-action: none !important; + opacity: 0.3; +} + +.ebDropdown_disabled .ebDropdown-Header:focus+.ebDropdown-list, + .ebDropdown_disabled .ebDropdown-header:focus+.ebDropdown-body, + .ebDropdown_disabled .ebDropdown-Header:active+.ebDropdown-list, + .ebDropdown_disabled .ebDropdown-header:active+.ebDropdown-body, + .ebDropdown_disabled:focus>.ebDropdown-list, .ebDropdown_disabled:focus>.ebDropdown-body, + .ebDropdown_disabled:active>.ebDropdown-list, .ebDropdown_disabled:active>.ebDropdown-body + { + display: none; +} + +/* Icons */ +.ebIcon { + display: inline-block; + vertical-align: middle; + border: none; + height: 16px; + width: 16px; + line-height: 1.6rem; + background-repeat: no-repeat; + background-position: center; + background-color: transparent; + background-size: 100%; + -khtml-user-select: none; + -moz-user-select: none; + -o-user-select: none; + -webkit-user-select: none; + user-select: none; + /*small icons */ + /*16px icons*/ +} + +.ebIcon_interactive { + opacity: 0.7; + cursor: pointer; +} + +.ebIcon_interactive:hover { + opacity: 1.0; +} + +.ebIcon_interactive:active { + opacity: 0.4; +} + +.ebIcon_button { + margin: 10px; +} + +.ebIcon_noVertAlign { + vertical-align: inherit; +} + +.ebIcon_disabled { + cursor: default; +} + +.ebIcon_disabled, .ebIcon_disabled:hover, .ebIcon_disabled:active { + opacity: 0.3; +} + +.ebIcon_small { + width: 1rem; + height: 1rem; + line-height: 1rem; +} + +.ebIcon_big { + width: 2rem; + height: 2rem; + line-height: 2rem; +} + +.ebIcon_large { + width: 2.8rem; + height: 2.8rem; + line-height: 2.8rem; +} + +.ebIcon_wMargin { + margin: 4px; +} + +.ebIcon_upArrow { + background-image: url('../resources/16px/ArrowUpSmall_black_16px.svg'); +} + +.ebIcon_upArrow_white { + background-image: url('../resources/16px/arrowUpSmall_white_16px.svg'); +} + +.ebIcon_downArrow { + background-image: url('../resources/16px/ArrowDownSmall_black_16px.svg'); +} + +.ebIcon_downArrow_white { + background-image: url('../resources/16px/ArrowDownSmall_white_16px.svg'); +} + +.ebIcon_leftArrow { + background-image: url('../resources/16px/ArrowLeftSmall_black_16px.svg'); +} + +.ebIcon_leftArrow_white { + background-image: url('../resources/16px/ArrowLeftSmall_white_16px.svg'); +} + +.ebIcon_rightArrow { + background-image: + url('../resources/16px/ArrowRightSmall_black_16px.svg'); +} + +.ebIcon_rightArrow_white { + background-image: + url('../resources/16px/ArrowRightSmall_white_16px.svg'); +} + +.ebIcon_prevArrow { + background-image: + url('../resources/16px/ArrowDoubleLeftSmall_black_16px.svg'); +} + +.ebIcon_nextArrow { + background-image: + url('../resources/16px/ArrowDoubleRightSmall_black_16px.svg'); +} + +.ebIcon_upArrow_10px { + background-image: url('../resources/10px/ArrowUpSmall_black_10px.svg'); +} + +.ebIcon_downArrow_10px { + background-image: url('../resources/10px/ArrowDownSmall_black_10px.svg'); +} + +.ebIcon_leftArrow_10px { + background-image: url('../resources/10px/ArrowLeftSmall_black_10px.svg'); +} + +.ebIcon_rightArrow_10px { + background-image: + url('../resources/10px/ArrowRightSmall_black_10px.svg'); +} + +.ebIcon_prevArrow_10px { + background-image: + url('../resources/10px/ArrowDoubleLeftSmall_black_10px.svg'); +} + +.ebIcon_nextArrow_10px { + background-image: + url('../resources/10px/ArrowDoubleRightSmall_black_10px.svg'); +} + +.ebIcon_errorSmall { + background-image: url('../resources/other/errorSmall_red_10px.svg'); +} + +.ebIcon_tickSmallBlack { + background-image: url('../resources/other/tick_black_10x8px.svg'); +} + +.ebIcon_tickSmallGreen { + background-image: url('../resources/other/tick_green_10x8px.svg'); +} + +.ebIcon_upArrowLarge { + background-image: url('../resources/16px/ArrowUp_black_16px.svg'); +} + +.ebIcon_upArrowLarge_white { + background-image: url('../resources/16px/ArrowUp_white_16px.svg'); +} + +.ebIcon_downArrowLarge { + background-image: url('../resources/16px/ArrowDown_black_16px.svg'); +} + +.ebIcon_downArrowLarge_white { + background-image: url('../resources/16px/ArrowDown_white_16px.svg'); +} + +.ebIcon_downArrowLarge_blue { + background-image: url('../resources/16px/ArrowDown_blue_16px.svg'); +} + +.ebIcon_leftArrowLarge { + background-image: url('../resources/16px/ArrowLeft_black_16px.svg'); +} + +.ebIcon_leftArrowLarge_white { + background-image: url('../resources/16px/ArrowLeft_white_16px.svg'); +} + +.ebIcon_rightArrowLarge { + background-image: url('../resources/16px/ArrowRight_black_16px.svg'); +} + +.ebIcon_rightArrowLarge_white { + background-image: url('../resources/16px/ArrowRight_white_16px.svg'); +} + +.ebIcon_circleArrowDown { + background-image: + url('../resources/16px/circleArrowDown_black_16px.svg'); +} + +.ebIcon_circleArrowDown_white { + background-image: + url('../resources/16px/circleArrowDown_white_16px.svg'); +} + +.ebIcon_circleArrowLeft { + background-image: + url('../resources/16px/circleArrowLeft_black_16px.svg'); +} + +.ebIcon_circleArrowLeft_white { + background-image: + url('../resources/16px/circleArrowLeft_white_16px.svg'); +} + +.ebIcon_circleArrowRight { + background-image: + url('../resources/16px/circleArrowRight_black_16px.svg'); +} + +.ebIcon_circleArrowRight_white { + background-image: + url('../resources/16px/circleArrowRight_white_16px.svg'); +} + +.ebIcon_circleArrowUp { + background-image: url('../resources/16px/circleArrowUp_black_16px.svg'); +} + +.ebIcon_circleArrowUp_white { + background-image: url('../resources/16px/circleArrowUp_white_16px.svg'); +} + +.ebIcon_circleCaretDown { + background-image: + url('../resources/16px/circleCaretDown_black_16px.svg'); +} + +.ebIcon_circleCaretDown_white { + background-image: + url('../resources/16px/circleCaretDown_white_16px.svg'); +} + +.ebIcon_circleCaretLeft { + background-image: + url('../resources/16px/circleCaretLeft_black_16px.svg'); +} + +.ebIcon_circleCaretLeft_white { + background-image: + url('../resources/16px/circleCaretLeft_white_16px.svg'); +} + +.ebIcon_circleCaretRight { + background-image: + url('../resources/16px/circleCaretRight_black_16px.svg'); +} + +.ebIcon_circleCaretRight_white { + background-image: + url('../resources/16px/circleCaretRight_white_16px.svg'); +} + +.ebIcon_circleCaretUp { + background-image: url('../resources/16px/circleCaretUp_black_16px.svg'); +} + +.ebIcon_circleCaretUp_white { + background-image: url('../resources/16px/circleCaretUp_white_16px.svg'); +} + +.ebIcon_eLogo { + background-image: url('../resources/systemBar/econ01.svg'); +} + +.ebIcon_comment { + background-image: url('../resources/16px/Comment_black_16px.svg'); +} + +.ebIcon_comment_white { + background-image: url('../resources/16px/comment_white.svg'); +} + +.ebIcon_copy { + background-image: url('../resources/16px/copy_black_16px.svg'); +} + +.ebIcon_copy_white { + background-image: url('../resources/16px/copy_white_16px.svg'); +} + +.ebIcon_cut { + background-image: url('../resources/16px/cut_black.svg'); +} + +.ebIcon_cut_white { + background-image: url('../resources/16px/cut_white.svg'); +} + +.ebIcon_delete { + background-image: url('../resources/16px/delete_black_16px.svg'); +} + +.ebIcon_delete_white { + background-image: url('../resources/16px/delete_white_16px.svg'); +} + +.ebIcon_duplicate { + background-image: url('../resources/16px/duplicate_black_16px.svg'); +} + +.ebIcon_duplicate_white { + background-image: url('../resources/16px/duplicate_white_16px.svg'); +} + +.ebIcon_edit { + background-image: url('../resources/16px/edit_black_16px.svg'); +} + +.ebIcon_editWhite { + background-image: url('../resources/16px/edit_white_16px.svg'); +} + +.ebIcon_newFile { + background-image: url('../resources/16px/newFile_black_16px.svg'); +} + +.ebIcon_newFile_white { + background-image: url('../resources/16px/newFile_white_16px.svg'); +} + +.ebIcon_save { + background-image: url('../resources/16px/save_black_16px.svg'); +} + +.ebIcon_save_white { + background-size: contain; + background-image: url('../resources/16px/save_white.svg'); +} + +.ebIcon_filter { + background-image: url('../resources/16px/filter_black_16px.svg'); +} + +.ebIcon_filterOn { + background-image: url('../resources/16px/filters_on.svg'); +} + +.ebIcon_filterOff { + background-image: url('../resources/16px/filters_off.svg'); +} + +.ebIcon_filter_white { + background-image: url('../resources/16px/filter_white_16px.svg'); +} + +.ebIcon_folder { + background-image: url('../resources/16px/folder_black_16px.svg'); +} + +.ebIcon_folder_white { + background-image: url('../resources/16px/folder_white_16px.svg'); +} + +.ebIcon_folderClosed { + background-image: url('../resources/16px/folderClosed_black.svg'); +} + +.ebIcon_folderClosed_white { + background-image: url('../resources/16px/folderClosed_white.svg'); +} + +.ebIcon_detach { + background-image: url('../resources/16px/detach_black_16px.svg'); +} + +.ebIcon_detach_white { + background-size: contain; + background-image: url('../resources/16px/detach_white.svg'); +} + +.ebIcon_import { + background-image: url('../resources/16px/import_black.svg'); +} + +.ebIcon_import_white { + background-image: url('../resources/16px/import_white.svg'); +} + +.ebIcon_export { + background-image: url('../resources/16px/export_black_16px.svg'); +} + +.ebIcon_export_white { + background-image: url('../resources/16px/export_white.svg'); +} + +.ebIcon_undo { + background-image: url('../resources/16px/undo_black_16px.svg'); +} + +.ebIcon_undo_white { + background-image: url('../resources/16px/undo_white_16px.svg'); +} + +.ebIcon_cancelled { + background-image: url('../resources/16px/Cancelled_Black_16px.svg'); +} + +.ebIcon_draft { + background-size: contain; + background-image: url('../resources/16px/draft.svg'); +} + +.ebIcon_importExport { + background-image: url('../resources/16px/import_export.svg'); +} + +.ebIcon_login { + background-image: url('../resources/16px/login.svg'); +} + +.ebIcon_move { + background-image: url('../resources/16px/move.svg'); +} + +.ebIcon_remove { + background-image: url('../resources/16px/remove.svg'); +} + +.ebIcon_valid { + background-image: url('../resources/16px/valid_icon.svg'); +} + +.ebIcon_invalid { + background-image: url('../resources/16px/invalid_icon.svg'); +} + +.ebIcon_error { + background-image: url('../resources/16px/error_red_16px.svg'); +} + +.ebIcon_warning { + background-image: url('../resources/16px/warning_yellow_16px.svg'); +} + +.ebIcon_warningOrange { + background-image: url('../resources/16px/warning_orange_16px.svg'); +} + +.ebIcon_warning_white { + background-image: url('../resources/16px/warning_white.svg'); +} + +.ebIcon_warningShield { + background-image: url('../resources/16px/warningShield_black_16px.svg'); +} + +.ebIcon_warningShield_white { + background-size: contain; + background-image: url('../resources/16px/warningShield_white.svg'); +} + +.ebIcon_mail { + background-image: url('../resources/16px/mail_black_16px.svg'); +} + +.ebIcon_mail_white { + background-image: url('../resources/16px/mail_white_16px.svg'); +} + +.ebIcon_mailRead { + background-image: url('../resources/16px/mailRead_black_16px.svg'); +} + +.ebIcon_mailRead_white { + background-image: url('../resources/16px/mailRead_white_16px.svg'); +} + +.ebIcon_link { + background-image: url('../resources/16px/Link_black_16px.svg');; +} + +.ebIcon_lock { + background-image: url('../resources/16px/lock_black_16px.svg'); +} + +.ebIcon_lock_white { + background-image: url('../resources/16px/lock_white_16px.svg'); +} + +.ebIcon_unlock { + background-image: url('../resources/16px/unlock_black_16px.svg'); +} + +.ebIcon_unlock_white { + background-image: url('../resources/16px/unlock_white_16px.svg'); +} + +.ebIcon_logout { + background-image: url('../resources/16px/logout_black_16px.svg'); +} + +.ebIcon_menu { + background-image: url('../resources/16px/menu_black_16px.svg'); +} + +.ebIcon_menu_white { + background-image: url('../resources/16px/menu_white_16px.svg'); +} + +.ebIcon_search { + background-image: url('../resources/16px/search_black_16px.svg'); +} + +.ebIcon_searchWhite { + background-image: url('../resources/16px/search_white_16px.svg'); +} + +.ebIcon_advancedSearch { + background-image: + url('../resources/16px/advanced_search_black_16px.svg'); +} + +.ebIcon_advancedSearchWhite { + background-image: + url('../resources/16px/advanced_search_white_16px.svg'); +} + +.ebIcon_share { + background-image: url('../resources/16px/share_black_16px.svg'); +} + +.ebIcon_share_white { + background-image: url('../resources/16px/share_white.svg'); +} + +.ebIcon_star { + background-image: url('../resources/16px/star_black_16px.svg'); +} + +.ebIcon_star_white { + background-image: url('../resources/16px/star_white_16px.svg'); +} + +.ebIcon_star_yellow { + background-image: url('../resources/16px/star_yellow_16px.svg'); +} + +.ebIcon_starOutline { + background-image: url('../resources/16px/star_outline_black_16px.svg'); +} + +.ebIcon_starOutline_white { + background-image: url('../resources/16px/star_outline_white_16px.svg'); +} + +.ebIcon_starOutline_yellow { + background-image: url('../resources/16px/star_outline_yellow_16px.svg'); +} + +.ebIcon_tick { + background-image: url('../resources/16px/tick_green_16px.svg'); +} + +.ebIcon_tick_black { + background-image: url('../resources/16px/tick_16px.svg'); +} + +.ebIcon_simpleGreenTick { + background-image: url('../resources/16px/simple_green_tick.svg'); +} + +.ebIcon_simpleTick_black { + background-image: url('../resources/16px/simple_tick.svg'); +} + +.ebIcon_download { + background-image: url('../resources/16px/download_black.svg'); +} + +.ebIcon_download_white { + background-image: url('../resources/16px/download_white.svg'); +} + +.ebIcon_downloadWhite { + background-image: url('../resources/16px/download_white_16px.svg'); +} + +.ebIcon_documentWhite { + background-image: url('../resources/16px/document_white_16px.svg'); +} + +.ebIcon_expand { + background-image: url('../resources/16px/expand_black_16px.svg'); +} + +.ebIcon_rowCollapsed { + background-image: url('../resources/16px/rowCollapsed_black_16px.svg'); +} + +.ebIcon_rowExpanded { + background-image: url('../resources/16px/rowExpanded_black_16px.svg'); +} + +.ebIcon_rowView { + background-image: url('../resources/16px/rowView_black_16px.svg'); +} + +.ebIcon_rowView_white { + background-image: url('../resources/16px/rowView_white.svg'); +} + +.ebIcon_externalApp { + background-image: url('../resources/16px/externalApp_black_16px.svg'); +} + +.ebIcon_externalApp_white { + background-image: url('../resources/16px/externalApp_white_16px.svg'); +} + +.ebIcon_fullscreen { + background-image: url('../resources/16px/fullscreen_black_16px.svg'); +} + +.ebIcon_fullscreenMinimize { + background-image: + url('../resources/16px/fullscreenMinimise_black_16px.svg'); +} + +.ebIcon_help { + background-image: url('../resources/16px/help_black_16px.svg'); +} + +.ebIcon_help_white { + background-image: url('../resources/16px/help_white.svg'); +} + +.ebIcon_info { + background-image: url('../resources/16px/info_black.svg'); +} + +.ebIcon_info_white { + background-image: url('../resources/16px/info_white.svg'); +} + +.ebIcon_dialogInfo { + background-image: url('../resources/16px/dialogInfo_blue.svg'); +} + +.ebIcon_dialogInfo_white { + background-image: url('../resources/16px/dialogInfo_white.svg'); +} + +.ebIcon_infoMsgIndicator { + background-image: url('../resources/16px/infoMsgIndicator_16px.svg'); +} + +.ebIcon_exitFullscreen { + background-image: + url('../resources/16px/minimiseFullscreen_black_16px.svg'); +} + +.ebIcon_refresh { + background-image: url('../resources/16px/refresh_black_16px.svg'); +} + +.ebIcon_refresh_white { + background-image: url('../resources/16px/refresh_white_16px.svg'); +} + +.ebIcon_settings { + background-image: url('../resources/16px/settings_black_16px.svg'); +} + +.ebIcon_settings_white { + background-image: url('../resources/16px/settings_white_16px.svg'); +} + +.ebIcon_user { + background-image: url('../resources/16px/user_black_16px.svg'); +} + +.ebIcon_user_white { + background-image: url('../resources/16px/user_white_16px.svg'); +} + +.ebIcon_close { + background-image: url('../resources/16px/X_black_16px.svg'); +} + +.ebIcon_close_white { + background-image: url('../resources/16px/close_white_16px.svg'); +} + +.ebIcon_close_blue { + background-image: url('../resources/16px/X_blue_16px.svg'); +} + +.ebIcon_close_paleBlue { + background-image: url('../resources/16px/X_paleBlue_16px.svg'); +} + +.ebIcon_close_green { + background-image: url('../resources/16px/X_green_16px.svg'); +} + +.ebIcon_close_orange { + background-image: url('../resources/16px/X_orange_16px.svg'); +} + +.ebIcon_close_red { + background-image: url('../resources/16px/X_red_16px.svg'); +} + +.ebIcon_close_yellow { + background-image: url('../resources/16px/X_yellow_16px.svg'); +} + +.ebIcon_minus { + background-image: url('../resources/16px/minus_black_16px.svg'); +} + +.ebIcon_plus { + background-image: url('../resources/16px/plus_black_16px.svg'); +} + +.ebIcon_add { + background-image: url('../resources/16px/add_black_16px.svg'); +} + +.ebIcon_add_white { + background-image: url('../resources/16px/add_white_16px.svg'); +} + +.ebIcon_multiSelect { + background-image: url('../resources/16px/multiSelect_black_16px.svg'); +} + +.ebIcon_multiSelect_white { + background-size: contain; + background-image: url('../resources/16px/multiSelect_white.svg'); +} + +.ebIcon_multiSort { + background-image: url('../resources/16px/multi-sort.svg'); +} + +.ebIcon_multiSort_white { + background-image: url('../resources/16px/multi-sort_white.svg'); +} + +.ebIcon_sort { + background-image: url('../resources/16px/sort.svg'); +} + +.ebIcon_sort_white { + background-image: url('../resources/16px/sort_white.svg'); +} + +.ebIcon_stop { + background-image: url('../resources/16px/stop_black_16px.svg'); +} + +.ebIcon_pause { + background-image: url('../resources/16px/pause_black_16px.svg'); +} + +.ebIcon_suspend { + background-image: url('../resources/16px/suspend_black_16px.svg'); +} + +.ebIcon_resume { + background-image: url('../resources/16px/resume_black_16px.svg'); +} + +.ebIcon_play { + background-image: url('../resources/16px/play_black_16px.svg'); +} + +.ebIcon_fastForward { + background-image: url('../resources/16px/fastForward_black_16px.svg'); +} + +.ebIcon_fastRewind { + background-image: url('../resources/16px/fastRewind_black_16px.svg'); +} + +.ebIcon_print { + background-image: url('../resources/16px/print_black_16px.svg'); +} + +.ebIcon_print_white { + background-image: url('../resources/16px/print_white_16px.svg'); +} + +.ebIcon_calendar { + background-image: url('../resources/16px/calendar_black_16px.svg'); +} + +.ebIcon_calendar_white { + background-image: url('../resources/16px/calendar_white_16px.svg'); +} + +.ebIcon_addToFolder { + background-image: url('../resources/16px/addToFolder_black.svg'); +} + +.ebIcon_addToFolder_white { + background-image: url('../resources/16px/addToFolder_white.svg'); +} + +.ebIcon_alarmCleared { + background-image: url('../resources/16px/alarmCleared_16px.svg'); +} + +.ebIcon_alarmCleared_white { + background-image: url('../resources/16px/alarmCleared_white_16px.svg'); +} + +.ebIcon_alarmCritical { + background-image: url('../resources/16px/alarmCritical_16px.svg'); +} + +.ebIcon_alarmCritical_white { + background-image: url('../resources/16px/alarmCritical_white_16px.svg'); +} + +.ebIcon_alarmHeartbeat { + background-image: url('../resources/16px/alarmHeartbeat_16px.svg'); +} + +.ebIcon_alarmIndeterminate { + background-image: url('../resources/16px/alarmIndeterminate_16px.svg'); +} + +.ebIcon_alarmIndeterminate_white { + background-image: + url('../resources/16px/alarmIndeterminate_white_16px.svg'); +} + +.ebIcon_alarmMajor { + background-image: url('../resources/16px/alarmMajor_16px.svg'); +} + +.ebIcon_alarmMajor_white { + background-image: url('../resources/16px/alarmMajor_white_16px.svg'); +} + +.ebIcon_alarmMinor { + background-image: url('../resources/16px/alarmMinor_16px.svg'); +} + +.ebIcon_alarmMinor_white { + background-image: url('../resources/16px/alarmMinor_white_16px.svg'); +} + +.ebIcon_alarmWarning { + background-image: url('../resources/16px/alarmWarning_16px.svg'); +} + +.ebIcon_alarmWarning_white { + background-image: url('../resources/16px/alarmWarning_white_16px.svg'); +} + +.ebIcon_alarmOtherGrouping { + background-image: url('../resources/16px/alarmOtherGrouping_16px.svg'); +} + +.ebIcon_alarmUnacknowledged { + background-image: url('../resources/16px/alarmUnacknowledged.svg'); +} + +.ebIcon_alarmUnacknowledged_white { + background-image: url('../resources/16px/alarmUnacknowledged_white.svg'); +} + +.ebIcon_alarmUnspecified { + background-image: url('../resources/16px/alarmUnspecified_16px.svg'); +} + +.ebIcon_acknowledgeAlarm { + background-image: url('../resources/16px/acknowledgeAlarm.svg'); +} + +.ebIcon_acknowledgeAlarm_white { + background-image: url('../resources/16px/acknowledgeAlarm_white.svg'); +} + +.ebIcon_clearAlarm { + background-image: url('../resources/16px/clearAlarm.svg'); +} + +.ebIcon_clearAlarm_white { + background-image: url('../resources/16px/clearAlarm_white.svg'); +} + +.ebIcon_bsc { + background-image: url('../resources/16px/BSC_black_16px.svg'); +} + +.ebIcon_bscYellow { + background-image: url('../resources/16px/BSC_Yellow_16px.svg'); +} + +.ebIcon_bscFunction { + background-image: url('../resources/16px/BSCFunction_black_16px.svg'); +} + +.ebIcon_bscFunctionYellow { + background-image: url('../resources/16px/BSCFunction_Yellow_16px.svg'); +} + +.ebIcon_cabinet { + background-image: url('../resources/16px/cabinet_black_16px.svg'); +} + +.ebIcon_cellGray { + background-image: url('../resources/16px/cell_gray_16px.svg'); +} + +.ebIcon_cellGreen { + background-image: url('../resources/16px/cell_green_16px.svg'); +} + +.ebIcon_cellRed { + background-image: url('../resources/16px/cell_red_16px.svg'); +} + +.ebIcon_cellAdjacent { + background-image: url('../resources/16px/cellAdjacent_16px.svg'); +} + +.ebIcon_cellExternal { + background-image: url('../resources/16px/cellExternal_16px.svg'); +} + +.ebIcon_charging { + background-image: url('../resources/16px/charging_black.svg'); +} + +.ebIcon_charging_white { + background-size: contain; + background-image: url('../resources/16px/charging_white.svg'); +} + +.ebIcon_connected { + background-image: url('../resources/16px/connected_black_16px.svg'); +} + +.ebIcon_disconnected { + background-image: url('../resources/16px/disconnected_black_16px.svg'); +} + +.ebIcon_connectionError { + background-image: + url('../resources/16px/connectionError_black_16px.svg'); +} + +.ebIcon_core { + background-image: url('../resources/16px/core_black_16px.svg'); +} + +.ebIcon_coreSubscriber { + background-image: url('../resources/16px/coreSubscriber_black_16px.svg'); +} + +.ebIcon_database { + background-image: url('../resources/16px/database_black_16px.svg'); +} + +.ebIcon_ftpServer { + background-image: url('../resources/16px/ftpServer_black_16px.svg'); +} + +.ebIcon_ftpServerFunction { + background-image: + url('../resources/16px/ftpServerFunction_black_16px.svg'); +} + +.ebIcon_gatewayFunction { + background-image: + url('../resources/16px/gatewayFunction_black_16px.svg'); +} + +.ebIcon_grabHandle { + background-image: url('../resources/16px/grabHandle_black_16px.svg'); +} + +.ebIcon_grabHandle_white { + background-size: contain; + background-image: url('../resources/16px/grabHandle_white.svg'); +} + +.ebIcon_managedFunction { + background-image: + url('../resources/16px/managedFunction_black_16px.svg'); +} + +.ebIcon_managedGroup { + background-image: url('../resources/16px/managedGroup_black_16px.svg'); +} + +.ebIcon_managementNode { + background-image: url('../resources/16px/managementNode_black_16px.svg'); +} + +.ebIcon_network { + background-image: url('../resources/16px/network_black_16px.svg'); +} + +.ebIcon_networkElement { + background-image: url('../resources/16px/networkElement_black_16px.svg'); +} + +.ebIcon_networkElement_white { + background-image: url('../resources/16px/networkElement_white_16px.svg'); +} + +.ebIcon_rbs { + background-image: url('../resources/16px/RBS_black_16px.svg'); +} + +.ebIcon_rbs_white { + background-image: url('../resources/16px/RBS_white_16px.svg'); +} + +.ebIcon_routeSwitch { + background-image: url('../resources/16px/routeSwitch.svg'); +} + +.ebIcon_rxi { + background-image: url('../resources/16px/rxi_black_16px.svg'); +} + +.ebIcon_switchFunction { + background-image: url('../resources/16px/switchFunction_black_16px.svg'); +} + +.ebIcon_technicianPresent { + background-image: url('../resources/16px/technicianPresent_16px.svg'); +} + +.ebIcon_terminal { + background-image: url('../resources/16px/terminal_black_16px.svg'); +} + +.ebIcon_topology { + background-image: url('../resources/16px/topology_black_16px.svg'); +} + +.ebIcon_access { + background-image: url('../resources/16px/access_black_16px.svg'); +} + +.ebIcon_access_white { + background-image: url('../resources/16px/access_white_16px.svg'); +} + +.ebIcon_accessSettings { + background-image: url('../resources/16px/accessSettings_black_16px.svg'); +} + +.ebIcon_accessSettings_white { + background-image: url('../resources/16px/accessSettings_white_16px.svg'); +} + +.ebIcon_alignCenter { + background-image: url('../resources/16px/alignCenter_black_16px.svg'); +} + +.ebIcon_alignCenter_white { + background-image: url('../resources/16px/alignCenter_white.svg'); +} + +.ebIcon_alignLeft { + background-image: url('../resources/16px/alignLeft_black_16px.svg'); +} + +.ebIcon_alignLeft_white { + background-image: url('../resources/16px/alignLeft_white.svg'); +} + +.ebIcon_alignRight { + background-image: url('../resources/16px/alignRight_black_16px.svg'); +} + +.ebIcon_alignRight_white { + background-image: url('../resources/16px/alignRight_white.svg'); +} + +.ebIcon_cli { + background-image: + url('../resources/16px/CommandLineInterface_black_16px.svg'); +} + +.ebIcon_cli_white { + background-image: + url('../resources/16px/CommandLineInterface_white_16px.svg'); +} + +.ebIcon_controllingNode { + background-image: url('../resources/16px/controllingNode.svg'); +} + +.ebIcon_grid3x3 { + background-image: url('../resources/16px/grid3X3_black_16px.svg'); +} + +.ebIcon_grid3x3_white { + background-image: url('../resources/16px/grid3x3_white.svg'); +} + +.ebIcon_grid4x4 { + background-image: url('../resources/16px/grid4X4_black_16px.svg'); +} + +.ebIcon_grid4x4_white { + background-image: url('../resources/16px/grid4x4_white.svg'); +} + +.ebIcon_gridView { + background-image: url('../resources/16px/gridView_black_16px.svg'); +} + +.ebIcon_gridView_white { + background-image: url('../resources/16px/gridView_white.svg'); +} + +.ebIcon_jumpTo { + background-image: url('../resources/16px/jumpTo_black_16px.svg'); +} + +.ebIcon_microwave { + background-image: url('../resources/16px/microwave.svg'); +} + +.ebIcon_mo { + background-image: url('../resources/16px/mo.svg'); +} + +.ebIcon_security { + background-image: url('../resources/16px/security_black_16px.svg'); +} + +.ebIcon_security_white { + background-image: url('../resources/16px/security_white_16px.svg'); +} + +.ebIcon_site { + background-image: url('../resources/16px/site_black_16px.svg'); +} + +.ebIcon_siteManager { + background-image: url('../resources/16px/siteManager_black_16px.svg'); +} + +.ebIcon_subnetwork { + background-image: url('../resources/16px/subnetwork.svg'); +} + +.ebIcon_gateway, .ebIcon_switch { + background-image: url('../resources/16px/switch.svg'); +} + +.ebIcon_tip { + background-image: url('../resources/16px/tip_black_16px.svg'); +} + +.ebIcon_tip_white { + background-image: url('../resources/16px/tip_white_16px.svg'); +} + +.ebIcon_attach { + background-image: url('../resources/16px/attach_black_16px.svg'); +} + +.ebIcon_attach_white { + background-size: contain; + background-image: url('../resources/16px/attach_white.svg'); +} + +.ebIcon_clock { + background-image: url('../resources/16px/clock_black_16px.svg'); +} + +.ebIcon_clock_white { + background-image: url('../resources/16px/clock_white_16px.svg'); +} + +.ebIcon_windowMaximize { + background-image: url('../resources/16px/WindowMaximize_black_16px.svg'); +} + +.ebIcon_windowMinimize { + background-image: url('../resources/16px/WindowMinimize_black_16px.svg'); +} + +.ebIcon_deprecated { + background-image: url('../resources/16px/deprecated_16px.svg'); +} + +.ebIcon_obsolete { + background-image: url('../resources/16px/obsolete_16px.svg'); +} + +.ebIcon_newStatus_blue { + background-image: url('../resources/16px/newStatus_blue_16px.svg'); +} + +.ebIcon_newStatus_green { + background-image: url('../resources/16px/newStatus_green_16px.svg'); +} + +.ebIcon_upload { + background-image: url('../resources/16px/upload_black_16px.svg'); +} + +.ebIcon_activate { + background-image: url('../resources/16px/activate_black_16px.svg'); +} + +.ebIcon_activate_white { + background-size: contain; + background-image: url('../resources/16px/activate_white.svg'); +} + +.ebIcon_deactivate { + background-image: url('../resources/16px/deactivate_black_16px.svg'); +} + +.ebIcon_deactivate_white { + background-size: contain; + background-image: url('../resources/16px/deactivate_white.svg'); +} + +.ebIcon_switchBetween { + background-image: url('../resources/16px/switchBetween_black_16px.svg'); +} + +.ebIcon_switchBetween_white { + background-image: url('../resources/16px/switchBetween_white_16px.svg'); +} + +.ebIcon_eye { + background-image: url('../resources/16px/eye_black_16px.svg'); +} + +.ebIcon_eye_white { + background-image: url('../resources/16px/eye_white_16px.svg'); +} + +.ebIcon_eyeLine { + background-image: url('../resources/16px/eyeLine_black_16px.svg'); +} + +.ebIcon_eyeLine_white { + background-image: url('../resources/16px/eyeLine_white.svg'); +} + +.ebIcon_activityTray { + background-image: url('../resources/16px/activity_16px_black.svg'); +} + +.ebIcon_note { + background-image: url('../resources/16px/note_black_16px.svg'); + background-size: contain; +} + +.ebIcon_note_white { + background-image: url('../resources/16px/note_white_16px.svg'); +} + +.ebIcon_tableView { + background-image: url('../resources/16px/tableView_black_16px.svg'); +} + +.ebIcon_tableView_white { + background-image: url('../resources/16px/tableView_white_16px.svg'); +} + +.ebIcon_synced { + background-image: url('../resources/16px/Syncd_16px.svg'); +} + +.ebIcon_syncError { + background-image: url('../resources/16px/SyncError_16px.svg'); +} + +.ebIcon_syncing { + background-image: url('../resources/16px/Syncing_Static_16px.svg'); +} + +.ebIcon_syncing_animated { + background-image: url('../resources/16px/Syncing_Animated_16px.svg'); +} + +/* Breadcrumb */ +.ebBreadcrumbs { + position: relative; + display: block; + font-size: 0; + margin-top: 12px; + margin-bottom: 4px; +} + +.ebBreadcrumbs-link { + font-size: 1.2rem; + vertical-align: middle; + display: inline-block +} + +.ebBreadcrumbs-list { + position: absolute; + left: 0; + margin-top: 6px; + display: none; + min-width: calc(100% - 16px); + max-width: 250px; + z-index: 1500 +} + +.ebBreadcrumbs-arrow { + margin-left: .6rem; + vertical-align: middle; + outline: none; + display: inline-block; + line-height: 12px +} + +.ebBreadcrumbs-arrow:focus>* { + opacity: 1 +} + +.ebBreadcrumbs-arrow_hidden { + display: none +} + +.ebBreadcrumbs-arrow:focus+.ebBreadcrumbs-list { + display: block +} + +.ebBreadcrumbs-item { + position: relative; + font-size: 0; + white-space: nowrap; + display: inline-block; + margin-bottom: .8rem +} + +.ebBreadcrumbs-item:after { + vertical-align: middle; + display: inline-block; + width: 20px; + content: "/"; + font-size: 1.6rem; + text-align: center; + color: #999; + cursor: default !important; + pointer-events: none !important; + -ms-touch-action: none !important; + touch-action: none !important; + -khtml-user-select: none !important; + -moz-user-select: none !important; + -o-user-select: none !important; + -webkit-user-select: none !important; + user-select: none +} + +.ebBreadcrumbs-item:last-child { + margin-right: 0 +} + +.ebBreadcrumbs-item:last-child>.ebBreadcrumbs-link { + -ms-touch-action: none !important; + touch-action: none !important; + -khtml-user-select: none !important; + -moz-user-select: none !important; + -o-user-select: none !important; + -webkit-user-select: none !important; + user-select: none +} + +.ebBreadcrumbs-item:last-child:after { + content: ""; + padding: 0; + font-size: 0; + width: 0; +} + +.ebBreadcrumbs a { + font-size: 1.2rem; + color: #0066b3; + text-decoration: none; +} + +.ebBreadcrumbs a:hover { + text-decoration: underline; + outline: none; +} + +.ebBreadcrumbs a:active { + text-decoration: underline +} + +.ebBreadcrumbs a:focus { + outline: none; + text-decoration: underline; + box-shadow: none; +}
\ No newline at end of file diff --git a/client/client-common/src/main/resources/css/styles.css b/client/client-common/src/main/resources/css/styles.css new file mode 100644 index 000000000..0d3666458 --- /dev/null +++ b/client/client-common/src/main/resources/css/styles.css @@ -0,0 +1,422 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ +.ebSystemBar-config { + position: absolute; + top: 0; + bottom: 0; + right: 0; + height: 40px; + width: 20px; + padding: 0 10px; + background: url('../resources/16px/settings_black_16px.svg') no-repeat + center center transparent; + background-size: 20px; + cursor: pointer; +} + +.content { + display: none; + padding: 10px; +} + +.context { + margin-left: 5px; +} + +.wrapper { + border: 1px dashed #ddd; + box-shadow: 0 0 0 3px #fff, 0 0 0 5px #ddd, 0 0 0 10px #fff, 0 0 2px + 10px #eee; + padding: 10px; + margin: 10px; + min-width: 1287px; +} + +.engineService { + margin-left: 5px; + padding-bottom: 10px; +} + +.apexDialogDiv { + background-color: white; + position: fixed; + top: 50%; + left: 50%; + transform: translate(-50%, -50%); + min-width: 310px; + min-height: 140px; + resize: both; + overflow: auto; + padding: 10px 10px 10px 10px; + border: 1px solid #c0c0c0; + border-radius: 3px; + box-shadow: 3px 7px 5px #555555; +} + +.apexDialogDiv { + background-color: white; + position: fixed; + top: 50%; + left: 50%; + transform: translate(-50%, -50%); + min-width: 310px; + min-height: 140px; + resize: both; + overflow: auto; + padding: 10px 10px 10px 10px; + border: 1px solid #c0c0c0; + border-radius: 3px; + box-shadow: 3px 7px 5px #555555; +} + +.apexErrorDialogDiv { + max-width: 80%; + max-height: 80%; + overflow: hidden; +} + +/* Dialog */ +.apexDialogDiv .headingSpan { + width: 100%; + height: 30px; + display: inline-block; + text-align: center; + font-weight: bold; + font-size: 20px; + padding: 5px 0px 0px 0px; + border-bottom: #c0c0c0 solid 1px; +} + +.apexDialogDivBackground { + position: fixed; + height: 100%; + width: 100%; + background-color: rgba(0, 0, 0, 0.5); + top: 0px; + left: 0px; +} + +.dialogMessage { + white-space: pre-wrap; + font: 14px "Lucida Sans Unicode", "Lucida Grande", sans-serif; + overflow-y: auto; + max-height: 480px; + overflow-x: hidden; + word-wrap: break-word; +} + +/* Form */ +.resultFormDiv .form-style-1 .field-textarea { + height: 480px; + font-size: 15px; +} + +.form-style-1 { + margin: 10px auto; + font: 16px "Lucida Sans Unicode", "Lucida Grande", sans-serif; +} + +.form-style-1 li { + padding: 0; + display: block; + list-style: none; + margin: 10px 0 0 0; +} + +.form-style-1 label { + margin: 0 0 3px 0; + padding: 0px; + display: block; + font-weight: bold; +} + +.form-style-1 input[type=text], .form-style-1 input[type=date], + .form-style-1 input[type=datetime], .form-style-1 input[type=number], + .form-style-1 input[type=search], .form-style-1 input[type=time], + .form-style-1 input[type=url], .form-style-1 input[type=email], + textarea, select { + box-sizing: border-box; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + border: 1px solid #BEBEBE; + padding: 0px 7px; + margin: 0px; + -webkit-transition: all 0.30s ease-in-out; + -moz-transition: all 0.30s ease-in-out; + -ms-transition: all 0.30s ease-in-out; + -o-transition: all 0.30s ease-in-out; + outline: none; +} + +.form-style-1 input[type=text]:focus, .form-style-1 input[type=date]:focus, + .form-style-1 input[type=datetime]:focus, .form-style-1 input[type=number]:focus, + .form-style-1 input[type=search]:focus, .form-style-1 input[type=time]:focus, + .form-style-1 input[type=url]:focus, .form-style-1 input[type=email]:focus, + .form-style-1 textarea:focus, .form-style-1 select:focus { + -moz-box-shadow: 0 0 8px #88D5E9; + -webkit-box-shadow: 0 0 8px #88D5E9; + box-shadow: 0 0 8px #88D5E9; + border: 1px solid #88D5E9; +} + +.form-style-1 input:focus::-webkit-input-placeholder { + color: transparent; +} + +.form-style-1 input:focus:-moz-placeholder { + color: transparent; +} + +.form-style-1 .field { + font-size: 15px; +} + +.form-style-1 .field-divided { + width: 49%; + font-size: 15px; +} + +.form-style-1 .field-long { + width: 100%; + font-size: 15px; +} + +.form-style-1 .field-medium { + width: 50%; + font-size: 15px; +} + +.form-style-1 .field-select { + width: 100%; + font-size: 15px; +} + +.form-style-1 .field-textarea { + height: 100px; + font-size: 15px; +} + +.form-style-1 .field-javaType { + width: 100%; + font-size: 15px; +} + +.form-style-1 .field-schemaFlavour { + width: 100%; + font-size: 15px; +} + +.form-style-1 .field-taskSelLogic { + width: 100%; + font-size: 15px; + height: 300px; +} + +.form-style-1 .field-taskLogic { + width: 100%; + font-size: 15px; + height: 300px; +} + +.form-style-1 .field-finalizerLogic { + width: 100%; + font-size: 15px; + height: 300px; +} + +.form-style-1 .field-schemaDefinition { + width: 100%; + font-size: 15px; + height: 100px; +} + +.form-style-1 .required { + color: red; +} + +.form-style-1 .button { + font-size: 15px; +} + +.form-style-1 .delete_ex { + height: 30px; + width: 30px; + opacity: 1; + font-size: 30px; + line-height: 30px; + transition: all 0.8s; + border: 1px solid transparent; + text-align: center; +} + +.form-style-1 .delete_ex:hover { + border-radius: 50%; + background: tomato; + border: 1px solid black; +} + +.form-style-1 .delete_ex_disabled { + width: 0px; + opacity: 0; +} + +/* Icons */ +.expandIcon { + float: right; +} + +.engineContextTitle { + padding: 1.2rem 0 .7rem 0; + font-weight: normal; +} + +.ignoreConflictsLabel { + font-size: 1.4rem; + padding-right: 15px; +} + +#engineServicesTable_periodic_events { + align-items: center; + display: flex; + height: 30px; +} + +.modelLoading { + margin-left: 5px; +} + +.layoutWrapper { + margin: 0 40px; +} + +.appHeading { + color: rgb(51, 51, 51); + display: block; + font-family: Arial, Helvetica, sans-serif; + font-size: 12px; + height: 32px; + line-height: 12px; + position: relative; +} + +.ebQuickActionBar { + margin-top: 1.2rem; + font-size: 0; + height: 32px; + padding: 0.4rem 0; + background-color: #e8e8e8; + position: relative; + width: 100%; + overflow: hidden; + line-height: 0; + box-sizing: border-box; + -webkit-transition: background-color 0.1s ease-in; + transition: background-color 0.1s ease-in; + -webkit-border-radius: 3px; + -moz-border-radius: 3px; + -ms-border-radius: 3px; + border-radius: 3px; +} + +.ebQuickActionBar_context { + background-color: #f3f3f3; + border-bottom: 2px solid #65cbe5; + box-sizing: border-box; + height: 32px; +} + +.ebQuickActionBar>* { + margin-left: 0.4rem; + margin-right: 0.4rem; + vertical-align: middle; +} + +.ebQuickActionBar-iconHolder { + display: inline-block; + vertical-align: middle; + height: 1.6rem; +} + +.ebQuickActionBar-separator { + display: inline-block; + vertical-align: middle; + border-left: 1px solid #CCCCCC; + margin: 0 8px; + height: 2.4rem; +} + +.ebQuickActionBar-Commands, .ebQuickActionBar-commands { + display: inline-block; + margin: 0; + font-size: 0; + line-height: 2.4rem; +} + +.ebQuickActionBar-Commands-iconHolder, + .ebQuickActionBar-commands-iconHolder { + display: inline-block; + vertical-align: middle; + height: 1.6rem; +} + +.ebQuickActionBar-Commands-separator, + .ebQuickActionBar-commands-separator { + display: inline-block; + vertical-align: middle; + border-left: 1px solid #CCCCCC; + margin: 0 8px; + height: 2.4rem; +} + +.ebQuickActionBar-Commands>*, .ebQuickActionBar-commands>* { + margin-left: 0.4rem; + margin-right: 0.4rem; + vertical-align: middle; +} + +.ebQuickActionBar-Commands-block, .ebQuickActionBar-commands-block, + .ebQuickActionBar-CommandsBlock, .ebQuickActionBar-commandsBlock { + margin: 0 0.8rem; + display: inline-block; +} + +.ebQuickActionBar-Commands-block>*, .ebQuickActionBar-commands-block>*, + .ebQuickActionBar-CommandsBlock>*, .ebQuickActionBar-commandsBlock>* { + margin-left: 0.4rem; + margin-right: 0.4rem; + vertical-align: middle; +} + +.ebQuickActionBar-Commands-block :last-child, + .ebQuickActionBar-commands-block :last-child, + .ebQuickActionBar-CommandsBlock :last-child, + .ebQuickActionBar-commandsBlock :last-child { + margin-right: 0; +} + +.title { + padding: 0px; +} + +.dataTd { + max-width: 1000px; + word-wrap: break-word; + white-space: normal !important; +}
\ No newline at end of file diff --git a/client/client-common/src/main/resources/jquery/jquery-1.12.4.js b/client/client-common/src/main/resources/jquery/jquery-1.12.4.js new file mode 100644 index 000000000..b038fc51f --- /dev/null +++ b/client/client-common/src/main/resources/jquery/jquery-1.12.4.js @@ -0,0 +1,11551 @@ +/*! + * jQuery JavaScript Library v1.12.4 + * http://jquery.com/ + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license + * http://jquery.org/license + * + * Date: 2016-05-20T17:17Z + */ + +(function(global, factory) { + + if (typeof module === "object" && typeof module.exports === "object") { + // For CommonJS and CommonJS-like environments where a proper `window` + // is present, execute the factory and get jQuery. + // For environments that do not have a `window` with a `document` + // (such as Node.js), expose a factory as module.exports. + // This accentuates the need for the creation of a real `window`. + // e.g. var jQuery = require("jquery")(window); + // See ticket #14549 for more info. + module.exports = global.document ? factory(global, true) : function(w) { + if (!w.document) { + throw new Error("jQuery requires a window with a document"); + } + return factory(w); + }; + } else { + factory(global); + } + + // Pass this if window is not defined yet +} + ( + typeof window !== "undefined" ? window : this, + function(window, noGlobal) { + + // Support: Firefox 18+ + // Can't be in strict mode, several libs including ASP.NET + // trace + // the stack via arguments.caller.callee and Firefox dies if + // you try to trace through "use strict" call chains. + // (#13335) + // "use strict"; + var deletedIds = []; + + var document = window.document; + + var slice = deletedIds.slice; + + var concat = deletedIds.concat; + + var push = deletedIds.push; + + var indexOf = deletedIds.indexOf; + + var class2type = {}; + + var toString = class2type.toString; + + var hasOwn = class2type.hasOwnProperty; + + var support = {}; + + var version = "1.12.4", + + // Define a local copy of jQuery + jQuery = function(selector, context) { + + // The jQuery object is actually just the init + // constructor 'enhanced' + // Need init if jQuery is called (just allow error to be + // thrown if not included) + return new jQuery.fn.init(selector, context); + }, + + // Support: Android<4.1, IE<9 + // Make sure we trim BOM and NBSP + rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, + + // Matches dashed string for camelizing + rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, + + // Used by jQuery.camelCase as callback to replace() + fcamelCase = function(all, letter) { + return letter.toUpperCase(); + }; + + jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery : version, + + constructor : jQuery, + + // Start with an empty selector + selector : "", + + // The default length of a jQuery object is 0 + length : 0, + + toArray : function() { + return slice.call(this); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get : function(num) { + return num != null ? + + // Return just the one element from the set + (num < 0 ? this[num + this.length] : this[num]) : + + // Return all the elements in a clean array + slice.call(this); + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack : function(elems) { + + // Build a new jQuery matched element set + var ret = jQuery.merge(this.constructor(), elems); + + // Add the old object onto the stack (as a + // reference) + ret.prevObject = this; + ret.context = this.context; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched + // set. + each : function(callback) { + return jQuery.each(this, callback); + }, + + map : function(callback) { + return this.pushStack(jQuery.map(this, function(elem, i) { + return callback.call(elem, i, elem); + })); + }, + + slice : function() { + return this.pushStack(slice.apply(this, arguments)); + }, + + first : function() { + return this.eq(0); + }, + + last : function() { + return this.eq(-1); + }, + + eq : function(i) { + var len = this.length, j = +i + (i < 0 ? len : 0); + return this.pushStack(j >= 0 && j < len ? [ this[j] ] : []); + }, + + end : function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery + // method. + push : push, + sort : deletedIds.sort, + splice : deletedIds.splice + }; + + jQuery.extend = jQuery.fn.extend = function() { + var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; + + // Handle a deep copy situation + if (typeof target === "boolean") { + deep = target; + + // skip the boolean and the target + target = arguments[i] || {}; + i++; + } + + // Handle case when target is a string or something + // (possible in deep copy) + if (typeof target !== "object" && !jQuery.isFunction(target)) { + target = {}; + } + + // extend jQuery itself if only one argument is passed + if (i === length) { + target = this; + i--; + } + + for (; i < length; i++) { + + // Only deal with non-null/undefined values + if ((options = arguments[i]) != null) { + + // Extend the base object + for (name in options) { + src = target[name]; + copy = options[name]; + + // Prevent never-ending loop + if (target === copy) { + continue; + } + + // Recurse if we're merging plain objects or + // arrays + if (deep && copy + && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) { + + if (copyIsArray) { + copyIsArray = false; + clone = src && jQuery.isArray(src) ? src : []; + + } else { + clone = src && jQuery.isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone + // them + target[name] = jQuery.extend(deep, clone, copy); + + // Don't bring in undefined values + } else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + + // Return the modified object + return target; + }; + + jQuery + .extend({ + + // Unique for each copy of jQuery on the page + expando : "jQuery" + (version + Math.random()).replace(/\D/g, ""), + + // Assume jQuery is ready without the ready + // module + isReady : true, + + error : function(msg) { + throw new Error(msg); + }, + + noop : function() { + }, + + // See test/unit/core.js for details concerning + // isFunction. + // Since version 1.3, DOM methods and functions + // like alert + // aren't supported. They return false on IE + // (#2968). + isFunction : function(obj) { + return jQuery.type(obj) === "function"; + }, + + isArray : Array.isArray || function(obj) { + return jQuery.type(obj) === "array"; + }, + + isWindow : function(obj) { + /* jshint eqeqeq: false */ + return obj != null && obj == obj.window; + }, + + isNumeric : function(obj) { + + // parseFloat NaNs numeric-cast false + // positives (null|true|false|"") + // ...but misinterprets leading-number + // strings, particularly hex literals + // ("0x...") + // subtraction forces infinities to NaN + // adding 1 corrects loss of precision from + // parseFloat (#15100) + var realStringObj = obj && obj.toString(); + return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0; + }, + + isEmptyObject : function(obj) { + var name; + for (name in obj) { + return false; + } + return true; + }, + + isPlainObject : function(obj) { + var key; + + // Must be an Object. + // Because of IE, we also have to check the + // presence of the constructor property. + // Make sure that DOM nodes and window + // objects don't pass through, as well + if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) { + return false; + } + + try { + + // Not own constructor property must be + // Object + if (obj.constructor && !hasOwn.call(obj, "constructor") + && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) { + return false; + } + } catch (e) { + + // IE8,9 Will throw exceptions on + // certain host objects #9897 + return false; + } + + // Support: IE<9 + // Handle iteration over inherited + // properties before own properties. + if (!support.ownFirst) { + for (key in obj) { + return hasOwn.call(obj, key); + } + } + + // Own properties are enumerated firstly, so + // to speed up, + // if last one is own, then all properties + // are own. + for (key in obj) { + } + + return key === undefined || hasOwn.call(obj, key); + }, + + type : function(obj) { + if (obj == null) { + return obj + ""; + } + return typeof obj === "object" || typeof obj === "function" ? class2type[toString + .call(obj)] + || "object" : typeof obj; + }, + + // Workarounds based on findings by Jim Driscoll + // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context + globalEval : function(data) { + if (data && jQuery.trim(data)) { + + // We use execScript on Internet + // Explorer + // We use an anonymous function so that + // context is window + // rather than jQuery in Firefox + (window.execScript || function(data) { + window["eval"].call(window, data); // jscs:ignore + // requireDotNotation + })(data); + } + }, + + // Convert dashed to camelCase; used by the css + // and data modules + // Microsoft forgot to hump their vendor prefix + // (#9572) + camelCase : function(string) { + return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase); + }, + + nodeName : function(elem, name) { + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + }, + + each : function(obj, callback) { + var length, i = 0; + + if (isArrayLike(obj)) { + length = obj.length; + for (; i < length; i++) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } else { + for (i in obj) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } + + return obj; + }, + + // Support: Android<4.1, IE<9 + trim : function(text) { + return text == null ? "" : (text + "").replace(rtrim, ""); + }, + + // results is for internal usage only + makeArray : function(arr, results) { + var ret = results || []; + + if (arr != null) { + if (isArrayLike(Object(arr))) { + jQuery.merge(ret, typeof arr === "string" ? [ arr ] : arr); + } else { + push.call(ret, arr); + } + } + + return ret; + }, + + inArray : function(elem, arr, i) { + var len; + + if (arr) { + if (indexOf) { + return indexOf.call(arr, elem, i); + } + + len = arr.length; + i = i ? i < 0 ? Math.max(0, len + i) : i : 0; + + for (; i < len; i++) { + + // Skip accessing in sparse arrays + if (i in arr && arr[i] === elem) { + return i; + } + } + } + + return -1; + }, + + merge : function(first, second) { + var len = +second.length, j = 0, i = first.length; + + while (j < len) { + first[i++] = second[j++]; + } + + // Support: IE<9 + // Workaround casting of .length to NaN on + // otherwise arraylike objects (e.g., + // NodeLists) + if (len !== len) { + while (second[j] !== undefined) { + first[i++] = second[j++]; + } + } + + first.length = i; + + return first; + }, + + grep : function(elems, callback, invert) { + var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; + + // Go through the array, only saving the + // items + // that pass the validator function + for (; i < length; i++) { + callbackInverse = !callback(elems[i], i); + if (callbackInverse !== callbackExpect) { + matches.push(elems[i]); + } + } + + return matches; + }, + + // arg is for internal usage only + map : function(elems, callback, arg) { + var length, value, i = 0, ret = []; + + // Go through the array, translating each of + // the items to their new values + if (isArrayLike(elems)) { + length = elems.length; + for (; i < length; i++) { + value = callback(elems[i], i, arg); + + if (value != null) { + ret.push(value); + } + } + + // Go through every key on the object, + } else { + for (i in elems) { + value = callback(elems[i], i, arg); + + if (value != null) { + ret.push(value); + } + } + } + + // Flatten any nested arrays + return concat.apply([], ret); + }, + + // A global GUID counter for objects + guid : 1, + + // Bind a function to a context, optionally + // partially applying any + // arguments. + proxy : function(fn, context) { + var args, proxy, tmp; + + if (typeof context === "string") { + tmp = fn[context]; + context = fn; + fn = tmp; + } + + // Quick check to determine if target is + // callable, in the spec + // this throws a TypeError, but we will just + // return undefined. + if (!jQuery.isFunction(fn)) { + return undefined; + } + + // Simulated bind + args = slice.call(arguments, 2); + proxy = function() { + return fn.apply(context || this, args.concat(slice.call(arguments))); + }; + + // Set the guid of unique handler to the + // same of original handler, so it can be + // removed + proxy.guid = fn.guid = fn.guid || jQuery.guid++; + + return proxy; + }, + + now : function() { + return +(new Date()); + }, + + // jQuery.support is not used in Core but other + // projects attach their + // properties to it so it needs to exist. + support : support + }); + + // JSHint would error on this code due to the Symbol not + // being defined in ES5. + // Defining this global in .jshintrc would create a danger + // of using the global + // unguarded in another place, it seems safer to just + // disable JSHint for these + // three lines. + /* jshint ignore: start */ + if (typeof Symbol === "function") { + jQuery.fn[Symbol.iterator] = deletedIds[Symbol.iterator]; + } + /* jshint ignore: end */ + + // Populate the class2type map + jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), + function(i, name) { + class2type["[object " + name + "]"] = name.toLowerCase(); + }); + + function isArrayLike(obj) { + + // Support: iOS 8.2 (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, type = jQuery.type(obj); + + if (type === "function" || jQuery.isWindow(obj)) { + return false; + } + + return type === "array" || length === 0 || typeof length === "number" && length > 0 + && (length - 1) in obj; + } + var Sizzle = + /* + * ! Sizzle CSS Selector Engine v2.2.1 http://sizzlejs.com/ + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license http://jquery.org/license + * + * Date: 2015-10-17 + */ + (function(window) { + + var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, + + // Local document vars + setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( + a, b) { + if (a === b) { + hasDuplicate = true; + } + return 0; + }, + + // General-purpose constants + MAX_NEGATIVE = 1 << 31, + + // Instance methods + hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, + // Use a stripped-down indexOf as it's faster than + // native + // http://jsperf.com/thor-indexof-vs-for/5 + indexOf = function(list, elem) { + var i = 0, len = list.length; + for (; i < len; i++) { + if (list[i] === elem) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier + identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", + + // Attribute selectors: + // http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + // "Attribute values must be CSS identifiers + // [capture 5] or strings [capture 3 or capture + // 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + // To reduce the number of selectors needing tokenize in + // the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + // 3. anything else (capture 2) + ".*" + ")\\)|)", + + // Leading and non-escaped trailing whitespace, + // capturing some non-whitespace characters preceding + // the latter + rwhitespace = new RegExp(whitespace + "+", "g"), rtrim = new RegExp("^" + whitespace + + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), + + rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = new RegExp("^" + + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), + + rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"), + + rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), + + matchExpr = { + "ID" : new RegExp("^#(" + identifier + ")"), + "CLASS" : new RegExp("^\\.(" + identifier + ")"), + "TAG" : new RegExp("^(" + identifier + "|[*])"), + "ATTR" : new RegExp("^" + attributes), + "PSEUDO" : new RegExp("^" + pseudos), + "CHILD" : new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + + "*(\\d+)|))" + whitespace + "*\\)|)", "i"), + "bool" : new RegExp("^(?:" + booleans + ")$", "i"), + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext" : new RegExp("^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i") + }, + + rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS + // selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, rescape = /'|\\/g, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"), funescape = function( + _, escaped, escapedWhitespace) { + var high = "0x" + escaped - 0x10000; + // NaN means non-codepoint + // Support: Firefox<24 + // Workaround erroneous numeric interpretation of + // +"0x" + return high !== high || escapedWhitespace ? escaped : high < 0 ? + // BMP codepoint + String.fromCharCode(high + 0x10000) : + // Supplemental Plane codepoint (surrogate + // pair) + String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00); + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission + // Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }; + + // Optimize for push.apply( _, NodeList ) + try { + push.apply((arr = slice.call(preferredDoc.childNodes)), preferredDoc.childNodes); + // Support: Android<4.0 + // Detect silently failing push.apply + arr[preferredDoc.childNodes.length].nodeType; + } catch (e) { + push = { + apply : arr.length ? + + // Leverage slice if possible + function(target, els) { + push_native.apply(target, slice.call(els)); + } : + + // Support: IE<9 + // Otherwise append directly + function(target, els) { + var j = target.length, i = 0; + // Can't trust NodeList.length + while ((target[j++] = els[i++])) { + } + target.length = j - 1; + } + }; + } + + function Sizzle(selector, context, results, seed) { + var m, i, elem, nid, nidselect, match, groups, newSelector, newContext = context + && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to + // document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or + // context + if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 + && nodeType !== 11) { + + return results; + } + + // Try to shortcut find operations (as opposed to + // filters) in HTML documents + if (!seed) { + + if ((context ? context.ownerDocument || context : preferredDoc) !== document) { + setDocument(context); + } + context = context || document; + + if (documentIsHTML) { + + // If the selector is sufficiently simple, + // try using a "get*By*" DOM method + // (excepting DocumentFragment context, + // where the methods don't exist) + if (nodeType !== 11 && (match = rquickExpr.exec(selector))) { + + // ID selector + if ((m = match[1])) { + + // Document context + if (nodeType === 9) { + if ((elem = context.getElementById(m))) { + + // Support: IE, Opera, + // Webkit + // TODO: identify versions + // getElementById can match + // elements by name instead + // of ID + if (elem.id === m) { + results.push(elem); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match + // elements by name instead of + // ID + if (newContext && (elem = newContext.getElementById(m)) + && contains(context, elem) && elem.id === m) { + + results.push(elem); + return results; + } + } + + // Type selector + } else if (match[2]) { + push.apply(results, context.getElementsByTagName(selector)); + return results; + + // Class selector + } else if ((m = match[3]) && support.getElementsByClassName + && context.getElementsByClassName) { + + push.apply(results, context.getElementsByClassName(m)); + return results; + } + } + + // Take advantage of querySelectorAll + if (support.qsa && !compilerCache[selector + " "] + && (!rbuggyQSA || !rbuggyQSA.test(selector))) { + + if (nodeType !== 1) { + newContext = context; + newSelector = selector; + + // qSA looks outside Element + // context, which is not what we + // want + // Thanks to Andrew Dupont for this + // workaround technique + // Support: IE <=8 + // Exclude object elements + } else if (context.nodeName.toLowerCase() !== "object") { + + // Capture the context ID, setting + // it first if necessary + if ((nid = context.getAttribute("id"))) { + nid = nid.replace(rescape, "\\$&"); + } else { + context.setAttribute("id", (nid = expando)); + } + + // Prefix every selector in the list + groups = tokenize(selector); + i = groups.length; + nidselect = ridentifier.test(nid) ? "#" + nid : "[id='" + nid + "']"; + while (i--) { + groups[i] = nidselect + " " + toSelector(groups[i]); + } + newSelector = groups.join(","); + + // Expand context for sibling + // selectors + newContext = rsibling.test(selector) && testContext(context.parentNode) + || context; + } + + if (newSelector) { + try { + push.apply(results, newContext.querySelectorAll(newSelector)); + return results; + } catch (qsaError) { + } finally { + if (nid === expando) { + context.removeAttribute("id"); + } + } + } + } + } + } + + // All others + return select(selector.replace(rtrim, "$1"), context, results, seed); + } + + /** + * Create key-value caches of limited size + * + * @returns {function(string, object)} Returns the + * Object data after storing it on itself with + * property name the (space-suffixed) string + * and (if the cache is larger than + * Expr.cacheLength) deleting the oldest entry + */ + function createCache() { + var keys = []; + + function cache(key, value) { + // Use (key + " ") to avoid collision with + // native prototype properties (see Issue #157) + if (keys.push(key + " ") > Expr.cacheLength) { + // Only keep the most recent entries + delete cache[keys.shift()]; + } + return (cache[key + " "] = value); + } + return cache; + } + + /** + * Mark a function for special use by Sizzle + * + * @param {Function} + * fn The function to mark + */ + function markFunction(fn) { + fn[expando] = true; + return fn; + } + + /** + * Support testing using an element + * + * @param {Function} + * fn Passed the created div and expects a + * boolean result + */ + function assert(fn) { + var div = document.createElement("div"); + + try { + return !!fn(div); + } catch (e) { + return false; + } finally { + // Remove from its parent by default + if (div.parentNode) { + div.parentNode.removeChild(div); + } + // release memory in IE + div = null; + } + } + + /** + * Adds the same handler for all of the specified attrs + * + * @param {String} + * attrs Pipe-separated list of attributes + * @param {Function} + * handler The method that will be applied + */ + function addHandle(attrs, handler) { + var arr = attrs.split("|"), i = arr.length; + + while (i--) { + Expr.attrHandle[arr[i]] = handler; + } + } + + /** + * Checks document order of two siblings + * + * @param {Element} + * a + * @param {Element} + * b + * @returns {Number} Returns less than 0 if a precedes + * b, greater than 0 if a follows b + */ + function siblingCheck(a, b) { + var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 + && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE); + + // Use IE sourceIndex if available on both nodes + if (diff) { + return diff; + } + + // Check if b follows a + if (cur) { + while ((cur = cur.nextSibling)) { + if (cur === b) { + return -1; + } + } + } + + return a ? 1 : -1; + } + + /** + * Returns a function to use in pseudos for input types + * + * @param {String} + * type + */ + function createInputPseudo(type) { + return function(elem) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; + } + + /** + * Returns a function to use in pseudos for buttons + * + * @param {String} + * type + */ + function createButtonPseudo(type) { + return function(elem) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && elem.type === type; + }; + } + + /** + * Returns a function to use in pseudos for positionals + * + * @param {Function} + * fn + */ + function createPositionalPseudo(fn) { + return markFunction(function(argument) { + argument = +argument; + return markFunction(function(seed, matches) { + var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length; + + // Match elements found at the specified + // indexes + while (i--) { + if (seed[(j = matchIndexes[i])]) { + seed[j] = !(matches[j] = seed[j]); + } + } + }); + }); + } + + /** + * Checks a node for validity as a Sizzle context + * + * @param {Element|Object=} + * context + * @returns {Element|Object|Boolean} The input node if + * acceptable, otherwise a falsy value + */ + function testContext(context) { + return context && typeof context.getElementsByTagName !== "undefined" && context; + } + + // Expose support vars for convenience + support = Sizzle.support = {}; + + /** + * Detects XML nodes + * + * @param {Element|Object} + * elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML + * node + */ + isXML = Sizzle.isXML = function(elem) { + // documentElement is verified for cases where it + // doesn't yet exist + // (such as loading iframes in IE - #4833) + var documentElement = elem && (elem.ownerDocument || elem).documentElement; + return documentElement ? documentElement.nodeName !== "HTML" : false; + }; + + /** + * Sets document-related variables once based on the + * current document + * + * @param {Element|Object} + * [doc] An element or document object to use + * to set the document + * @returns {Object} Returns the current document + */ + setDocument = Sizzle.setDocument = function(node) { + var hasCompare, parent, doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already + // selected + if (doc === document || doc.nodeType !== 9 || !doc.documentElement) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML(document); + + // Support: IE 9-11, Edge + // Accessing iframe documents after unload throws + // "permission denied" errors (jQuery #13936) + if ((parent = document.defaultView) && parent.top !== parent) { + // Support: IE 11 + if (parent.addEventListener) { + parent.addEventListener("unload", unloadHandler, false); + + // Support: IE 9 - 10 only + } else if (parent.attachEvent) { + parent.attachEvent("onunload", unloadHandler); + } + } + + /* + * Attributes + * ---------------------------------------------------------------------- + */ + + // Support: IE<8 + // Verify that getAttribute really returns + // attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert(function(div) { + div.className = "i"; + return !div.getAttribute("className"); + }); + + /*************************************************** + * getElement(s)By + * ---------------------------------------------------------------------- + */ + + // Check if getElementsByTagName("*") returns only + // elements + support.getElementsByTagName = assert(function(div) { + div.appendChild(document.createComment("")); + return !div.getElementsByTagName("*").length; + }); + + // Support: IE<9 + support.getElementsByClassName = rnative.test(document.getElementsByClassName); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up + // programatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert(function(div) { + docElem.appendChild(div).id = expando; + return !document.getElementsByName || !document.getElementsByName(expando).length; + }); + + // ID find and filter + if (support.getById) { + Expr.find["ID"] = function(id, context) { + if (typeof context.getElementById !== "undefined" && documentIsHTML) { + var m = context.getElementById(id); + return m ? [ m ] : []; + } + }; + Expr.filter["ID"] = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + return elem.getAttribute("id") === attrId; + }; + }; + } else { + // Support: IE6/7 + // getElementById is not reliable as a find + // shortcut + delete Expr.find["ID"]; + + Expr.filter["ID"] = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + var node = typeof elem.getAttributeNode !== "undefined" + && elem.getAttributeNode("id"); + return node && node.value === attrId; + }; + }; + } + + // Tag + Expr.find["TAG"] = support.getElementsByTagName ? function(tag, context) { + if (typeof context.getElementsByTagName !== "undefined") { + return context.getElementsByTagName(tag); + + // DocumentFragment nodes don't have gEBTN + } else if (support.qsa) { + return context.querySelectorAll(tag); + } + } : + + function(tag, context) { + var elem, tmp = [], i = 0, + // By happy coincidence, a (broken) + // gEBTN appears on DocumentFragment + // nodes too + results = context.getElementsByTagName(tag); + + // Filter out possible comments + if (tag === "*") { + while ((elem = results[i++])) { + if (elem.nodeType === 1) { + tmp.push(elem); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find["CLASS"] = support.getElementsByClassName && function(className, context) { + if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) { + return context.getElementsByClassName(className); + } + }; + + /* + * QSA/matchesSelector + * ---------------------------------------------------------------------- + */ + + // QSA and matchesSelector support + // matchesSelector(:active) reports false when true + // (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that + // throws an error + // whenever `document.activeElement` is accessed on + // an iframe + // So, we allow :focus to pass through QSA all the + // time to avoid the IE error + // See http://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ((support.qsa = rnative.test(document.querySelectorAll))) { + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert(function(div) { + // Select is set to empty string on purpose + // This is to test IE's treatment of not + // explicitly + // setting a boolean content attribute, + // since its presence should be enough + // http://bugs.jquery.com/ticket/12359 + docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + + "<select id='" + expando + "-\r\\' msallowcapture=''>" + + "<option selected=''></option></select>"; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty + // strings follow ^= or $= or *= + // The test attribute must be unknown in + // Opera but "safe" for WinRT + // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if (div.querySelectorAll("[msallowcapture^='']").length) { + rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")"); + } + + // Support: IE8 + // Boolean attributes and "value" are not + // treated correctly + if (!div.querySelectorAll("[selected]").length) { + rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")"); + } + + // Support: Chrome<29, Android<4.4, + // Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if (!div.querySelectorAll("[id~=" + expando + "-]").length) { + rbuggyQSA.push("~="); + } + + // Webkit/Opera - :checked should return + // selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see + // later tests + if (!div.querySelectorAll(":checked").length) { + rbuggyQSA.push(":checked"); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibing-combinator + // selector` fails + if (!div.querySelectorAll("a#" + expando + "+*").length) { + rbuggyQSA.push(".#.+[+~]"); + } + }); + + assert(function(div) { + // Support: Windows 8 Native Apps + // The type and name attributes are + // restricted during .innerHTML assignment + var input = document.createElement("input"); + input.setAttribute("type", "hidden"); + div.appendChild(input).setAttribute("name", "D"); + + // Support: IE8 + // Enforce case-sensitivity of name + // attribute + if (div.querySelectorAll("[name=d]").length) { + rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?="); + } + + // FF 3.5 - :enabled/:disabled and hidden + // elements (hidden elements are still + // enabled) + // IE8 throws error here and will not see + // later tests + if (!div.querySelectorAll(":enabled").length) { + rbuggyQSA.push(":enabled", ":disabled"); + } + + // Opera 10-11 does not throw on post-comma + // invalid pseudos + div.querySelectorAll("*,:x"); + rbuggyQSA.push(",.*:"); + }); + } + + if ((support.matchesSelector = rnative.test((matches = docElem.matches + || docElem.webkitMatchesSelector || docElem.mozMatchesSelector + || docElem.oMatchesSelector || docElem.msMatchesSelector)))) { + + assert(function(div) { + // Check to see if it's possible to do + // matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call(div, "div"); + + // This should fail with an exception + // Gecko does not error, returns false + // instead + matches.call(div, "[s!='']:x"); + rbuggyMatches.push("!=", pseudos); + }); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")); + rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")); + + /* + * Contains + * ---------------------------------------------------------------------- + */ + hasCompare = rnative.test(docElem.compareDocumentPosition); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test(docElem.contains) ? function(a, b) { + var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; + return a === bup + || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) + : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16)); + } : function(a, b) { + if (b) { + while ((b = b.parentNode)) { + if (b === a) { + return true; + } + } + } + return false; + }; + + /* + * Sorting + * ---------------------------------------------------------------------- + */ + + // Document order sorting + sortOrder = hasCompare ? function(a, b) { + + // Flag for duplicate removal + if (a === b) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input + // has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if (compare) { + return compare; + } + + // Calculate position if both inputs belong to + // the same document + compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a + .compareDocumentPosition(b) : + + // Otherwise we know they are + // disconnected + 1; + + // Disconnected nodes + if (compare & 1 || (!support.sortDetached && b.compareDocumentPosition(a) === compare)) { + + // Choose the first element that is related + // to our preferred document + if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) { + return -1; + } + if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) { + return 1; + } + + // Maintain original order + return sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0; + } + + return compare & 4 ? -1 : 1; + } + : function(a, b) { + // Exit early if the nodes are identical + if (a === b) { + hasDuplicate = true; + return 0; + } + + var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; + + // Parentless nodes are either documents + // or disconnected + if (!aup || !bup) { + return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 + : sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0; + + // If the nodes are siblings, we can + // do a quick check + } else if (aup === bup) { + return siblingCheck(a, b); + } + + // Otherwise we need full lists of their + // ancestors for comparison + cur = a; + while ((cur = cur.parentNode)) { + ap.unshift(cur); + } + cur = b; + while ((cur = cur.parentNode)) { + bp.unshift(cur); + } + + // Walk down the tree looking for a + // discrepancy + while (ap[i] === bp[i]) { + i++; + } + + return i ? + // Do a sibling check if the nodes have + // a common ancestor + siblingCheck(ap[i], bp[i]) : + + // Otherwise nodes in our document sort + // first + ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; + }; + + return document; + }; + + Sizzle.matches = function(expr, elements) { + return Sizzle(expr, null, null, elements); + }; + + Sizzle.matchesSelector = function(elem, expr) { + // Set document vars if needed + if ((elem.ownerDocument || elem) !== document) { + setDocument(elem); + } + + // Make sure that attribute selectors are quoted + expr = expr.replace(rattributeQuotes, "='$1']"); + + if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] + && (!rbuggyMatches || !rbuggyMatches.test(expr)) + && (!rbuggyQSA || !rbuggyQSA.test(expr))) { + + try { + var ret = matches.call(elem, expr); + + // IE 9's matchesSelector returns false on + // disconnected nodes + if (ret || support.disconnectedMatch || + // As well, disconnected nodes are said to + // be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11) { + return ret; + } + } catch (e) { + } + } + + return Sizzle(expr, document, null, [ elem ]).length > 0; + }; + + Sizzle.contains = function(context, elem) { + // Set document vars if needed + if ((context.ownerDocument || context) !== document) { + setDocument(context); + } + return contains(context, elem); + }; + + Sizzle.attr = function(elem, name) { + // Set document vars if needed + if ((elem.ownerDocument || elem) !== document) { + setDocument(elem); + } + + var fn = Expr.attrHandle[name.toLowerCase()], + // Don't get fooled by Object.prototype properties + // (jQuery #13807) + val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, + !documentIsHTML) : undefined; + + return val !== undefined ? val : support.attributes || !documentIsHTML ? elem + .getAttribute(name) + : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; + }; + + Sizzle.error = function(msg) { + throw new Error("Syntax error, unrecognized expression: " + msg); + }; + + /** + * Document sorting and removing duplicates + * + * @param {ArrayLike} + * results + */ + Sizzle.uniqueSort = function(results) { + var elem, duplicates = [], j = 0, i = 0; + + // Unless we *know* we can detect duplicates, assume + // their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice(0); + results.sort(sortOrder); + + if (hasDuplicate) { + while ((elem = results[i++])) { + if (elem === results[i]) { + j = duplicates.push(i); + } + } + while (j--) { + results.splice(duplicates[j], 1); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; + }; + + /** + * Utility function for retrieving the text value of an + * array of DOM nodes + * + * @param {Array|Element} + * elem + */ + getText = Sizzle.getText = function(elem) { + var node, ret = "", i = 0, nodeType = elem.nodeType; + + if (!nodeType) { + // If no nodeType, this is expected to be an + // array + while ((node = elem[i++])) { + // Do not traverse comment nodes + ret += getText(node); + } + } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) { + // Use textContent for elements + // innerText usage removed for consistency of + // new lines (jQuery #11153) + if (typeof elem.textContent === "string") { + return elem.textContent; + } else { + // Traverse its children + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + ret += getText(elem); + } + } + } else if (nodeType === 3 || nodeType === 4) { + return elem.nodeValue; + } + // Do not include comment or processing instruction + // nodes + + return ret; + }; + + Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength : 50, + + createPseudo : markFunction, + + match : matchExpr, + + attrHandle : {}, + + find : {}, + + relative : { + ">" : { + dir : "parentNode", + first : true + }, + " " : { + dir : "parentNode" + }, + "+" : { + dir : "previousSibling", + first : true + }, + "~" : { + dir : "previousSibling" + } + }, + + preFilter : { + "ATTR" : function(match) { + match[1] = match[1].replace(runescape, funescape); + + // Move the given value to match[3] whether + // quoted or unquoted + match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape); + + if (match[2] === "~=") { + match[3] = " " + match[3] + " "; + } + + return match.slice(0, 4); + }, + + "CHILD" : function(match) { + /* + * matches from matchExpr["CHILD"] 1 type + * (only|nth|...) 2 what (child|of-type) 3 + * argument + * (even|odd|\d*|\d*n([+-]\d+)?|...) 4 + * xn-component of xn+y argument + * ([+-]?\d*n|) 5 sign of xn-component 6 x + * of xn-component 7 sign of y-component 8 y + * of y-component + */ + match[1] = match[1].toLowerCase(); + + if (match[1].slice(0, 3) === "nth") { + // nth-* requires argument + if (!match[3]) { + Sizzle.error(match[0]); + } + + // numeric x and y parameters for + // Expr.filter.CHILD + // remember that false/true cast + // respectively to 0/1 + match[4] = +(match[4] ? match[5] + (match[6] || 1) + : 2 * (match[3] === "even" || match[3] === "odd")); + match[5] = +((match[7] + match[8]) || match[3] === "odd"); + + // other types prohibit arguments + } else if (match[3]) { + Sizzle.error(match[0]); + } + + return match; + }, + + "PSEUDO" : function(match) { + var excess, unquoted = !match[6] && match[2]; + + if (matchExpr["CHILD"].test(match[0])) { + return null; + } + + // Accept quoted arguments as-is + if (match[3]) { + match[2] = match[4] || match[5] || ""; + + // Strip excess characters from unquoted + // arguments + } else if (unquoted && rpseudo.test(unquoted) && + // Get excess from tokenize + // (recursively) + (excess = tokenize(unquoted, true)) && + // advance to the next closing + // parenthesis + (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) { + + // excess is a negative index + match[0] = match[0].slice(0, excess); + match[2] = unquoted.slice(0, excess); + } + + // Return only captures needed by the pseudo + // filter method (type and argument) + return match.slice(0, 3); + } + }, + + filter : { + + "TAG" : function(nodeNameSelector) { + var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase(); + return nodeNameSelector === "*" ? function() { + return true; + } : function(elem) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS" : function(className) { + var pattern = classCache[className + " "]; + + return pattern + || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + + whitespace + "|$)")) + && classCache(className, function(elem) { + return pattern.test(typeof elem.className === "string" + && elem.className || typeof elem.getAttribute !== "undefined" + && elem.getAttribute("class") || ""); + }); + }, + + "ATTR" : function(name, operator, check) { + return function(elem) { + var result = Sizzle.attr(elem, name); + + if (result == null) { + return operator === "!="; + } + if (!operator) { + return true; + } + + result += ""; + + return operator === "=" ? result === check + : operator === "!=" ? result !== check + : operator === "^=" ? check && result.indexOf(check) === 0 + : operator === "*=" ? check + && result.indexOf(check) > -1 + : operator === "$=" ? check + && result.slice(-check.length) === check + : operator === "~=" ? (" " + + result.replace(rwhitespace, + " ") + " ") + .indexOf(check) > -1 + : operator === "|=" ? result === check + || result + .slice( + 0, + check.length + 1) === check + + "-" + : false; + }; + }, + + "CHILD" : function(type, what, argument, first, last) { + var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function(elem) { + return !!elem.parentNode; + } + : + + function(elem, context, xml) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" + : "previousSibling", parent = elem.parentNode, name = ofType + && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; + + if (parent) { + + // :(first|last|only)-(child|of-type) + if (simple) { + while (dir) { + node = elem; + while ((node = node[dir])) { + if (ofType ? node.nodeName.toLowerCase() === name + : node.nodeType === 1) { + + return false; + } + } + // Reverse direction + // for :only-* (if + // we haven't yet + // done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) + // stores cache data on + // `parent` + if (forward && useCache) { + + // Seek `elem` from a + // previously-cached + // index + + // ...in a gzip-friendly + // way + node = parent; + outerCache = node[expando] || (node[expando] = {}); + + // Support: IE <9 only + // Defend against cloned + // attroperties (jQuery + // gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + cache = uniqueCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex && cache[2]; + node = nodeIndex && parent.childNodes[nodeIndex]; + + while ((node = ++nodeIndex && node && node[dir] || + + // Fallback to + // seeking + // `elem` from + // the start + (diff = nodeIndex = 0) || start.pop())) { + + // When found, cache + // indexes on + // `parent` and + // break + if (node.nodeType === 1 && ++diff && node === elem) { + uniqueCache[type] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + // Use previously-cached + // element index if + // available + if (useCache) { + // ...in a + // gzip-friendly way + node = elem; + outerCache = node[expando] || (node[expando] = {}); + + // Support: IE <9 + // only + // Defend against + // cloned + // attroperties + // (jQuery gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + cache = uniqueCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or + // :nth-last-child(...) + // or + // :nth(-last)?-of-type(...) + if (diff === false) { + // Use the same loop + // as above to seek + // `elem` from the + // start + while ((node = ++nodeIndex && node && node[dir] + || (diff = nodeIndex = 0) || start.pop())) { + + if ((ofType ? node.nodeName.toLowerCase() === name + : node.nodeType === 1) + && ++diff) { + + // Cache the + // index of + // each + // encountered + // element + if (useCache) { + outerCache = node[expando] + || (node[expando] = {}); + + // Support: + // IE <9 + // only + // Defend + // against + // cloned + // attroperties + // (jQuery + // gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + uniqueCache[type] = [ dirruns, diff ]; + } + + if (node === elem) { + break; + } + } + } + } + } + + // Incorporate the offset, + // then check against cycle + // size + diff -= last; + return diff === first || (diff % first === 0 && diff / first >= 0); + } + }; + }, + + "PSEUDO" : function(pseudo, argument) { + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case + // custom pseudos are added with uppercase + // letters + // Remember that setFilters inherits from + // pseudos + var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] + || Sizzle.error("unsupported pseudo: " + pseudo); + + // The user may use createPseudo to indicate + // that + // arguments are needed to create the filter + // function + // just as Sizzle does + if (fn[expando]) { + return fn(argument); + } + + // But maintain support for old signatures + if (fn.length > 1) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function( + seed, matches) { + var idx, matched = fn(seed, argument), i = matched.length; + while (i--) { + idx = indexOf(seed, matched[i]); + seed[idx] = !(matches[idx] = matched[i]); + } + }) + : function(elem) { + return fn(elem, 0, args); + }; + } + + return fn; + } + }, + + pseudos : { + // Potentially complex pseudos + "not" : markFunction(function(selector) { + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], results = [], matcher = compile(selector.replace(rtrim, "$1")); + + return matcher[expando] ? markFunction(function(seed, matches, context, xml) { + var elem, unmatched = matcher(seed, null, xml, []), i = seed.length; + + // Match elements unmatched by `matcher` + while (i--) { + if ((elem = unmatched[i])) { + seed[i] = !(matches[i] = elem); + } + } + }) : function(elem, context, xml) { + input[0] = elem; + matcher(input, null, xml, results); + // Don't keep the element (issue + // #299) + input[0] = null; + return !results.pop(); + }; + }), + + "has" : markFunction(function(selector) { + return function(elem) { + return Sizzle(selector, elem).length > 0; + }; + }), + + "contains" : markFunction(function(text) { + text = text.replace(runescape, funescape); + return function(elem) { + return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1; + }; + }), + + // "Whether an element is represented by a + // :lang() selector + // is based solely on the element's language + // value + // being equal to the identifier C, + // or beginning with the identifier C + // immediately followed by "-". + // The matching of C against the element's + // language value is performed + // case-insensitively. + // The identifier C does not have to be a valid + // language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang" : markFunction(function(lang) { + // lang value must be a valid identifier + if (!ridentifier.test(lang || "")) { + Sizzle.error("unsupported lang: " + lang); + } + lang = lang.replace(runescape, funescape).toLowerCase(); + return function(elem) { + var elemLang; + do { + if ((elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") + || elem.getAttribute("lang"))) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf(lang + "-") === 0; + } + } while ((elem = elem.parentNode) && elem.nodeType === 1); + return false; + }; + }), + + // Miscellaneous + "target" : function(elem) { + var hash = window.location && window.location.hash; + return hash && hash.slice(1) === elem.id; + }, + + "root" : function(elem) { + return elem === docElem; + }, + + "focus" : function(elem) { + return elem === document.activeElement + && (!document.hasFocus || document.hasFocus()) + && !!(elem.type || elem.href || ~elem.tabIndex); + }, + + // Boolean properties + "enabled" : function(elem) { + return elem.disabled === false; + }, + + "disabled" : function(elem) { + return elem.disabled === true; + }, + + "checked" : function(elem) { + // In CSS3, :checked should return both + // checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return (nodeName === "input" && !!elem.checked) + || (nodeName === "option" && !!elem.selected); + }, + + "selected" : function(elem) { + // Accessing this property makes + // selected-by-default + // options in Safari work properly + if (elem.parentNode) { + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty" : function(elem) { + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or + // content nodes (text: 3; cdata: 4; entity + // ref: 5), + // but not by others (comment: 8; processing + // instruction: 7; etc.) + // nodeType < 6 works because attributes (2) + // do not appear as children + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + if (elem.nodeType < 6) { + return false; + } + } + return true; + }, + + "parent" : function(elem) { + return !Expr.pseudos["empty"](elem); + }, + + // Element/input types + "header" : function(elem) { + return rheader.test(elem.nodeName); + }, + + "input" : function(elem) { + return rinputs.test(elem.nodeName); + }, + + "button" : function(elem) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text" : function(elem) { + var attr; + return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., + // "search") appear with elem.type + // === "text" + ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text"); + }, + + // Position-in-collection + "first" : createPositionalPseudo(function() { + return [ 0 ]; + }), + + "last" : createPositionalPseudo(function(matchIndexes, length) { + return [ length - 1 ]; + }), + + "eq" : createPositionalPseudo(function(matchIndexes, length, argument) { + return [ argument < 0 ? argument + length : argument ]; + }), + + "even" : createPositionalPseudo(function(matchIndexes, length) { + var i = 0; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "odd" : createPositionalPseudo(function(matchIndexes, length) { + var i = 1; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "lt" : createPositionalPseudo(function(matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; --i >= 0;) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "gt" : createPositionalPseudo(function(matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; ++i < length;) { + matchIndexes.push(i); + } + return matchIndexes; + }) + } + }; + + Expr.pseudos["nth"] = Expr.pseudos["eq"]; + + // Add button/input type pseudos + for (i in { + radio : true, + checkbox : true, + file : true, + password : true, + image : true + }) { + Expr.pseudos[i] = createInputPseudo(i); + } + for (i in { + submit : true, + reset : true + }) { + Expr.pseudos[i] = createButtonPseudo(i); + } + + // Easy API for creating new setFilters + function setFilters() { + } + setFilters.prototype = Expr.filters = Expr.pseudos; + Expr.setFilters = new setFilters(); + + tokenize = Sizzle.tokenize = function(selector, parseOnly) { + var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + + " "]; + + if (cached) { + return parseOnly ? 0 : cached.slice(0); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while (soFar) { + + // Comma and first run + if (!matched || (match = rcomma.exec(soFar))) { + if (match) { + // Don't consume trailing commas as + // valid + soFar = soFar.slice(match[0].length) || soFar; + } + groups.push((tokens = [])); + } + + matched = false; + + // Combinators + if ((match = rcombinators.exec(soFar))) { + matched = match.shift(); + tokens.push({ + value : matched, + // Cast descendant combinators to space + type : match[0].replace(rtrim, " ") + }); + soFar = soFar.slice(matched.length); + } + + // Filters + for (type in Expr.filter) { + if ((match = matchExpr[type].exec(soFar)) + && (!preFilters[type] || (match = preFilters[type](match)))) { + matched = match.shift(); + tokens.push({ + value : matched, + type : type, + matches : match + }); + soFar = soFar.slice(matched.length); + } + } + + if (!matched) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : + // Cache the tokens + tokenCache(selector, groups).slice(0); + }; + + function toSelector(tokens) { + var i = 0, len = tokens.length, selector = ""; + for (; i < len; i++) { + selector += tokens[i].value; + } + return selector; + } + + function addCombinator(matcher, combinator, base) { + var dir = combinator.dir, checkNonElements = base && dir === "parentNode", doneName = done++; + + return combinator.first ? + // Check against closest ancestor/preceding element + function(elem, context, xml) { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + return matcher(elem, context, xml); + } + } + } + : + + // Check against all ancestor/preceding + // elements + function(elem, context, xml) { + var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML + // nodes, so they don't benefit from + // combinator caching + if (xml) { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + if (matcher(elem, context, xml)) { + return true; + } + } + } + } else { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + outerCache = elem[expando] || (elem[expando] = {}); + + // Support: IE <9 only + // Defend against cloned + // attroperties (jQuery + // gh-1709) + uniqueCache = outerCache[elem.uniqueID] + || (outerCache[elem.uniqueID] = {}); + + if ((oldCache = uniqueCache[dir]) && oldCache[0] === dirruns + && oldCache[1] === doneName) { + + // Assign to newCache so + // results + // back-propagate to + // previous elements + return (newCache[2] = oldCache[2]); + } else { + // Reuse newcache so + // results + // back-propagate to + // previous elements + uniqueCache[dir] = newCache; + + // A match means we're + // done; a fail means we + // have to keep checking + if ((newCache[2] = matcher(elem, context, xml))) { + return true; + } + } + } + } + } + }; + } + + function elementMatcher(matchers) { + return matchers.length > 1 ? function(elem, context, xml) { + var i = matchers.length; + while (i--) { + if (!matchers[i](elem, context, xml)) { + return false; + } + } + return true; + } : matchers[0]; + } + + function multipleContexts(selector, contexts, results) { + var i = 0, len = contexts.length; + for (; i < len; i++) { + Sizzle(selector, contexts[i], results); + } + return results; + } + + function condense(unmatched, map, filter, context, xml) { + var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; + + for (; i < len; i++) { + if ((elem = unmatched[i])) { + if (!filter || filter(elem, context, xml)) { + newUnmatched.push(elem); + if (mapped) { + map.push(i); + } + } + } + } + + return newUnmatched; + } + + function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) { + if (postFilter && !postFilter[expando]) { + postFilter = setMatcher(postFilter); + } + if (postFinder && !postFinder[expando]) { + postFinder = setMatcher(postFinder, postSelector); + } + return markFunction(function(seed, results, context, xml) { + var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, + + // Get initial elements from seed or context + elems = seed + || multipleContexts(selector || "*", context.nodeType ? [ context ] : context, + []), + + // Prefilter to get matcher input, preserving a + // map for seed-results synchronization + matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, + context, xml) : elems, + + matcherOut = matcher ? + // If we have a postFinder, or filtered seed, or + // non-seed postFilter or preexisting results, + postFinder || (seed ? preFilter : preexisting || postFilter) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : matcherIn; + + // Find primary matches + if (matcher) { + matcher(matcherIn, matcherOut, context, xml); + } + + // Apply postFilter + if (postFilter) { + temp = condense(matcherOut, postMap); + postFilter(temp, [], context, xml); + + // Un-match failing elements by moving them + // back to matcherIn + i = temp.length; + while (i--) { + if ((elem = temp[i])) { + matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem); + } + } + } + + if (seed) { + if (postFinder || preFilter) { + if (postFinder) { + // Get the final matcherOut by + // condensing this intermediate into + // postFinder contexts + temp = []; + i = matcherOut.length; + while (i--) { + if ((elem = matcherOut[i])) { + // Restore matcherIn since + // elem is not yet a final + // match + temp.push((matcherIn[i] = elem)); + } + } + postFinder(null, (matcherOut = []), temp, xml); + } + + // Move matched elements from seed to + // results to keep them synchronized + i = matcherOut.length; + while (i--) { + if ((elem = matcherOut[i]) + && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) { + + seed[temp] = !(results[temp] = elem); + } + } + } + + // Add elements to results, through + // postFinder if defined + } else { + matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, + matcherOut.length) : matcherOut); + if (postFinder) { + postFinder(null, results, matcherOut, xml); + } else { + push.apply(results, matcherOut); + } + } + }); + } + + function matcherFromTokens(tokens) { + var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative + || Expr.relative[" "], i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements + // are reachable from top-level context(s) + matchContext = addCombinator(function(elem) { + return elem === checkContext; + }, implicitRelative, true), matchAnyContext = addCombinator(function(elem) { + return indexOf(checkContext, elem) > -1; + }, implicitRelative, true), matchers = [ function(elem, context, xml) { + var ret = (!leadingRelative && (xml || context !== outermostContext)) + || ((checkContext = context).nodeType ? matchContext(elem, context, xml) + : matchAnyContext(elem, context, xml)); + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for (; i < len; i++) { + if ((matcher = Expr.relative[tokens[i].type])) { + matchers = [ addCombinator(elementMatcher(matchers), matcher) ]; + } else { + matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); + + // Return special upon seeing a positional + // matcher + if (matcher[expando]) { + // Find the next relative operator (if + // any) for proper handling + j = ++i; + for (; j < len; j++) { + if (Expr.relative[tokens[j].type]) { + break; + } + } + return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( + // If the + // preceding + // token was a + // descendant + // combinator, + // insert an + // implicit + // any-element + // `*` + tokens.slice(0, i - 1).concat({ + value : tokens[i - 2].type === " " ? "*" : "" + })).replace(rtrim, "$1"), matcher, i < j + && matcherFromTokens(tokens.slice(i, j)), j < len + && matcherFromTokens((tokens = tokens.slice(j))), j < len + && toSelector(tokens)); + } + matchers.push(matcher); + } + } + + return elementMatcher(matchers); + } + + function matcherFromGroupMatchers(elementMatchers, setMatchers) { + var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( + seed, context, xml, results, outermost) { + var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, + // We must always have either seed elements or + // outermost context + elems = seed || byElement && Expr.find["TAG"]("*", outermost), + // Use integer dirruns iff this is the outermost + // matcher + dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; + + if (outermost) { + outermostContext = context === document || context || outermost; + } + + // Add elements passing elementMatchers directly + // to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; + // Safari: <number>) matching elements by id + for (; i !== len && (elem = elems[i]) != null; i++) { + if (byElement && elem) { + j = 0; + if (!context && elem.ownerDocument !== document) { + setDocument(elem); + xml = !documentIsHTML; + } + while ((matcher = elementMatchers[j++])) { + if (matcher(elem, context || document, xml)) { + results.push(elem); + break; + } + } + if (outermost) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if (bySet) { + // They will have gone through all + // possible matchers + if ((elem = !matcher && elem)) { + matchedCount--; + } + + // Lengthen the array for every element, + // matched or not + if (seed) { + unmatched.push(elem); + } + } + } + + // `i` is now the count of elements visited + // above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no + // unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ + // elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` + // allows `i` to remain a string only in that + // case, which will result in a "00" + // `matchedCount` that differs from `i` but is + // also + // numerically zero. + if (bySet && i !== matchedCount) { + j = 0; + while ((matcher = setMatchers[j++])) { + matcher(unmatched, setMatched, context, xml); + } + + if (seed) { + // Reintegrate element matches to + // eliminate the need for sorting + if (matchedCount > 0) { + while (i--) { + if (!(unmatched[i] || setMatched[i])) { + setMatched[i] = pop.call(results); + } + } + } + + // Discard index placeholder values to + // get only actual matches + setMatched = condense(setMatched); + } + + // Add matches to results + push.apply(results, setMatched); + + // Seedless set matches succeeding multiple + // successful matchers stipulate sorting + if (outermost && !seed && setMatched.length > 0 + && (matchedCount + setMatchers.length) > 1) { + + Sizzle.uniqueSort(results); + } + } + + // Override manipulation of globals by nested + // matchers + if (outermost) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? markFunction(superMatcher) : superMatcher; + } + + compile = Sizzle.compile = function(selector, match /* + * Internal + * Use + * Only + */) { + var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "]; + + if (!cached) { + // Generate a function of recursive functions + // that can be used to check each element + if (!match) { + match = tokenize(selector); + } + i = match.length; + while (i--) { + cached = matcherFromTokens(match[i]); + if (cached[expando]) { + setMatchers.push(cached); + } else { + elementMatchers.push(cached); + } + } + + // Cache the compiled function + cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; + }; + + /** + * A low-level selection function that works with + * Sizzle's compiled selector functions + * + * @param {String|Function} + * selector A selector or a pre-compiled + * selector function built with + * Sizzle.compile + * @param {Element} + * context + * @param {Array} + * [results] + * @param {Array} + * [seed] A set of elements to match against + */ + select = Sizzle.select = function(selector, context, results, seed) { + var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed + && tokenize((selector = compiled.selector || selector)); + + results = results || []; + + // Try to minimize operations if there is only one + // selector in the list and no seed + // (the latter of which guarantees us context) + if (match.length === 1) { + + // Reduce context if the leading compound + // selector is an ID + tokens = match[0] = match[0].slice(0); + if (tokens.length > 2 && (token = tokens[0]).type === "ID" && support.getById + && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) { + + context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0]; + if (!context) { + return results; + + // Precompiled matchers will still + // verify ancestry, so step up a level + } else if (compiled) { + context = context.parentNode; + } + + selector = selector.slice(tokens.shift().value.length); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length; + while (i--) { + token = tokens[i]; + + // Abort if we hit a combinator + if (Expr.relative[(type = token.type)]) { + break; + } + if ((find = Expr.find[type])) { + // Search, expanding context for leading + // sibling combinators + if ((seed = find(token.matches[0].replace(runescape, funescape), rsibling + .test(tokens[0].type) + && testContext(context.parentNode) || context))) { + + // If seed is empty or no tokens + // remain, we can return early + tokens.splice(i, 1); + selector = seed.length && toSelector(tokens); + if (!selector) { + push.apply(results, seed); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one + // is not provided + // Provide `match` to avoid retokenization if we + // modified the selector above + (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context + || rsibling.test(selector) && testContext(context.parentNode) || context); + return results; + }; + + // One-time assignments + + // Sort stability + support.sortStable = expando.split("").sort(sortOrder).join("") === expando; + + // Support: Chrome 14-35+ + // Always assume duplicates if they aren't passed to the + // comparison function + support.detectDuplicates = !!hasDuplicate; + + // Initialize against the default document + setDocument(); + + // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 + // (fixed in Chrome 27) + // Detached nodes confoundingly follow *each other* + support.sortDetached = assert(function(div1) { + // Should return 1, but returns 4 (following) + return div1.compareDocumentPosition(document.createElement("div")) & 1; + }); + + // Support: IE<8 + // Prevent attribute/property "interpolation" + // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx + if (!assert(function(div) { + div.innerHTML = "<a href='#'></a>"; + return div.firstChild.getAttribute("href") === "#"; + })) { + addHandle("type|href|height|width", function(elem, name, isXML) { + if (!isXML) { + return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2); + } + }); + } + + // Support: IE<9 + // Use defaultValue in place of getAttribute("value") + if (!support.attributes || !assert(function(div) { + div.innerHTML = "<input/>"; + div.firstChild.setAttribute("value", ""); + return div.firstChild.getAttribute("value") === ""; + })) { + addHandle("value", function(elem, name, isXML) { + if (!isXML && elem.nodeName.toLowerCase() === "input") { + return elem.defaultValue; + } + }); + } + + // Support: IE<9 + // Use getAttributeNode to fetch booleans when + // getAttribute lies + if (!assert(function(div) { + return div.getAttribute("disabled") == null; + })) { + addHandle(booleans, function(elem, name, isXML) { + var val; + if (!isXML) { + return elem[name] === true ? name.toLowerCase() : (val = elem + .getAttributeNode(name)) + && val.specified ? val.value : null; + } + }); + } + + return Sizzle; + + })(window); + + jQuery.find = Sizzle; + jQuery.expr = Sizzle.selectors; + jQuery.expr[":"] = jQuery.expr.pseudos; + jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; + jQuery.text = Sizzle.getText; + jQuery.isXMLDoc = Sizzle.isXML; + jQuery.contains = Sizzle.contains; + + var dir = function(elem, dir, until) { + var matched = [], truncate = until !== undefined; + + while ((elem = elem[dir]) && elem.nodeType !== 9) { + if (elem.nodeType === 1) { + if (truncate && jQuery(elem).is(until)) { + break; + } + matched.push(elem); + } + } + return matched; + }; + + var siblings = function(n, elem) { + var matched = []; + + for (; n; n = n.nextSibling) { + if (n.nodeType === 1 && n !== elem) { + matched.push(n); + } + } + + return matched; + }; + + var rneedsContext = jQuery.expr.match.needsContext; + + var rsingleTag = (/^<([\w-]+)\s*\/?>(?:<\/\1>|)$/); + + var risSimple = /^.[^:#\[\.,]*$/; + + // Implement the identical functionality for filter and not + function winnow(elements, qualifier, not) { + if (jQuery.isFunction(qualifier)) { + return jQuery.grep(elements, function(elem, i) { + /* jshint -W018 */ + return !!qualifier.call(elem, i, elem) !== not; + }); + + } + + if (qualifier.nodeType) { + return jQuery.grep(elements, function(elem) { + return (elem === qualifier) !== not; + }); + + } + + if (typeof qualifier === "string") { + if (risSimple.test(qualifier)) { + return jQuery.filter(qualifier, elements, not); + } + + qualifier = jQuery.filter(qualifier, elements); + } + + return jQuery.grep(elements, function(elem) { + return (jQuery.inArray(elem, qualifier) > -1) !== not; + }); + } + + jQuery.filter = function(expr, elems, not) { + var elem = elems[0]; + + if (not) { + expr = ":not(" + expr + ")"; + } + + return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [ elem ] + : [] + : jQuery.find.matches(expr, jQuery.grep(elems, function(elem) { + return elem.nodeType === 1; + })); + }; + + jQuery.fn.extend({ + find : function(selector) { + var i, ret = [], self = this, len = self.length; + + if (typeof selector !== "string") { + return this.pushStack(jQuery(selector).filter(function() { + for (i = 0; i < len; i++) { + if (jQuery.contains(self[i], this)) { + return true; + } + } + })); + } + + for (i = 0; i < len; i++) { + jQuery.find(selector, self[i], ret); + } + + // Needed because $( selector, context ) + // becomes $( context ).find( selector ) + ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret); + ret.selector = this.selector ? this.selector + " " + selector : selector; + return ret; + }, + filter : function(selector) { + return this.pushStack(winnow(this, selector || [], false)); + }, + not : function(selector) { + return this.pushStack(winnow(this, selector || [], true)); + }, + is : function(selector) { + return !!winnow(this, + + // If this is a positional/relative + // selector, check membership in the + // returned set + // so $("p:first").is("p:last") + // won't return true for a doc with + // two "p". + typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector + || [], false).length; + } + }); + + // Initialize a jQuery object + + // A central reference to the root jQuery(document) + var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over <tag> to avoid XSS via location.hash + // (#9521) + // Strict HTML recognition (#11290: must start with <) + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, + + init = jQuery.fn.init = function(selector, context, root) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if (!selector) { + return this; + } + + // init accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if (typeof selector === "string") { + if (selector.charAt(0) === "<" && selector.charAt(selector.length - 1) === ">" + && selector.length >= 3) { + + // Assume that strings that start and end with + // <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec(selector); + } + + // Match html or make sure no context is specified + // for #id + if (match && (match[1] || !context)) { + + // HANDLE: $(html) -> $(array) + if (match[1]) { + context = context instanceof jQuery ? context[0] : context; + + // scripts is true for back-compat + // Intentionally let the error be thrown if + // parseHTML is not present + jQuery.merge(this, jQuery.parseHTML(match[1], + context && context.nodeType ? context.ownerDocument || context : document, + true)); + + // HANDLE: $(html, props) + if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) { + for (match in context) { + + // Properties of context are called + // as methods if possible + if (jQuery.isFunction(this[match])) { + this[match](context[match]); + + // ...and otherwise set as + // attributes + } else { + this.attr(match, context[match]); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById(match[2]); + + // Check parentNode to catch when Blackberry + // 4.6 returns + // nodes that are no longer in the document + // #6963 + if (elem && elem.parentNode) { + + // Handle the case where IE and Opera + // return items + // by name instead of ID + if (elem.id !== match[2]) { + return rootjQuery.find(selector); + } + + // Otherwise, we inject the element + // directly into the jQuery object + this.length = 1; + this[0] = elem; + } + + this.context = document; + this.selector = selector; + return this; + } + + // HANDLE: $(expr, $(...)) + } else if (!context || context.jquery) { + return (context || root).find(selector); + + // HANDLE: $(expr, context) + // (which is just equivalent to: + // $(context).find(expr) + } else { + return this.constructor(context).find(selector); + } + + // HANDLE: $(DOMElement) + } else if (selector.nodeType) { + this.context = this[0] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if (jQuery.isFunction(selector)) { + return typeof root.ready !== "undefined" ? root.ready(selector) : + + // Execute immediately if ready is not present + selector(jQuery); + } + + if (selector.selector !== undefined) { + this.selector = selector.selector; + this.context = selector.context; + } + + return jQuery.makeArray(selector, this); + }; + + // Give the init function the jQuery prototype for later + // instantiation + init.prototype = jQuery.fn; + + // Initialize central reference + rootjQuery = jQuery(document); + + var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // methods guaranteed to produce a unique set when starting + // from a unique set + guaranteedUnique = { + children : true, + contents : true, + next : true, + prev : true + }; + + jQuery.fn.extend({ + has : function(target) { + var i, targets = jQuery(target, this), len = targets.length; + + return this.filter(function() { + for (i = 0; i < len; i++) { + if (jQuery.contains(this, targets[i])) { + return true; + } + } + }); + }, + + closest : function(selectors, context) { + var cur, i = 0, l = this.length, matched = [], pos = rneedsContext.test(selectors) + || typeof selectors !== "string" ? jQuery(selectors, context || this.context) : 0; + + for (; i < l; i++) { + for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) { + + // Always skip document fragments + if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : + + // Don't pass + // non-elements to + // Sizzle + cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) { + + matched.push(cur); + break; + } + } + } + + return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched); + }, + + // Determine the position of an element within + // the matched set of elements + index : function(elem) { + + // No argument, return index in parent + if (!elem) { + return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1; + } + + // index in selector + if (typeof elem === "string") { + return jQuery.inArray(this[0], jQuery(elem)); + } + + // Locate the position of the desired + // element + return jQuery.inArray( + + // If it receives a jQuery object, the first + // element is used + elem.jquery ? elem[0] : elem, this); + }, + + add : function(selector, context) { + return this.pushStack(jQuery + .uniqueSort(jQuery.merge(this.get(), jQuery(selector, context)))); + }, + + addBack : function(selector) { + return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector)); + } + }); + + function sibling(cur, dir) { + do { + cur = cur[dir]; + } while (cur && cur.nodeType !== 1); + + return cur; + } + + jQuery.each({ + parent : function(elem) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents : function(elem) { + return dir(elem, "parentNode"); + }, + parentsUntil : function(elem, i, until) { + return dir(elem, "parentNode", until); + }, + next : function(elem) { + return sibling(elem, "nextSibling"); + }, + prev : function(elem) { + return sibling(elem, "previousSibling"); + }, + nextAll : function(elem) { + return dir(elem, "nextSibling"); + }, + prevAll : function(elem) { + return dir(elem, "previousSibling"); + }, + nextUntil : function(elem, i, until) { + return dir(elem, "nextSibling", until); + }, + prevUntil : function(elem, i, until) { + return dir(elem, "previousSibling", until); + }, + siblings : function(elem) { + return siblings((elem.parentNode || {}).firstChild, elem); + }, + children : function(elem) { + return siblings(elem.firstChild); + }, + contents : function(elem) { + return jQuery.nodeName(elem, "iframe") ? elem.contentDocument + || elem.contentWindow.document : jQuery.merge([], elem.childNodes); + } + }, function(name, fn) { + jQuery.fn[name] = function(until, selector) { + var ret = jQuery.map(this, fn, until); + + if (name.slice(-5) !== "Until") { + selector = until; + } + + if (selector && typeof selector === "string") { + ret = jQuery.filter(selector, ret); + } + + if (this.length > 1) { + + // Remove duplicates + if (!guaranteedUnique[name]) { + ret = jQuery.uniqueSort(ret); + } + + // Reverse order for parents* + // and prev-derivatives + if (rparentsprev.test(name)) { + ret = ret.reverse(); + } + } + + return this.pushStack(ret); + }; + }); + var rnotwhite = (/\S+/g); + + // Convert String-formatted options into Object-formatted + // ones + function createOptions(options) { + var object = {}; + jQuery.each(options.match(rnotwhite) || [], function(_, flag) { + object[flag] = true; + }); + return object; + } + + /* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that + * will change how the callback list behaves or a more + * traditional option object + * + * By default a callback list will act like an event + * callback list and can be "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired + * once (like a Deferred) + * + * memory: will keep track of previous values and will call + * any callback added after the list has been fired right + * away with the latest "memorized" values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no + * duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns + * false + * + */ + jQuery.Callbacks = function(options) { + + // Convert options from String-formatted to + // Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by + // add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime + // changes + fired = firing = true; + for (; queue.length; firingIndex = -1) { + memory = queue.shift(); + while (++firingIndex < list.length) { + + // Run callback and check for early + // termination + if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) { + + // Jump to end and forget the data so + // .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if (!options.memory) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if (locked) { + + // Keep an empty list if we have data for future + // add calls + if (memory) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to + // the list + add : function() { + if (list) { + + // If we have memory from a past run, we + // should fire after adding + if (memory && !firing) { + firingIndex = list.length - 1; + queue.push(memory); + } + + (function add(args) { + jQuery.each(args, function(_, arg) { + if (jQuery.isFunction(arg)) { + if (!options.unique || !self.has(arg)) { + list.push(arg); + } + } else if (arg && arg.length && jQuery.type(arg) !== "string") { + + // Inspect + // recursively + add(arg); + } + }); + })(arguments); + + if (memory && !firing) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove : function() { + jQuery.each(arguments, function(_, arg) { + var index; + while ((index = jQuery.inArray(arg, list, index)) > -1) { + list.splice(index, 1); + + // Handle firing indexes + if (index <= firingIndex) { + firingIndex--; + } + } + }); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not + // list has callbacks attached. + has : function(fn) { + return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0; + }, + + // Remove all callbacks from the list + empty : function() { + if (list) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable : function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled : function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it + // would have no effect) + // Abort any pending executions + lock : function() { + locked = true; + if (!memory) { + self.disable(); + } + return this; + }, + locked : function() { + return !!locked; + }, + + // Call all callbacks with the given context and + // arguments + fireWith : function(context, args) { + if (!locked) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push(args); + if (!firing) { + fire(); + } + } + return this; + }, + + // Call all the callbacks with the given arguments + fire : function() { + self.fireWith(this, arguments); + return this; + }, + + // To know if the callbacks have already been called + // at least once + fired : function() { + return !!fired; + } + }; + + return self; + }; + + jQuery + .extend({ + + Deferred : function(func) { + var tuples = [ + + // action, add listener, listener + // list, final state + [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], + [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], + [ "notify", "progress", jQuery.Callbacks("memory") ] ], state = "pending", promise = { + state : function() { + return state; + }, + always : function() { + deferred.done(arguments).fail(arguments); + return this; + }, + then : function( /* + * fnDone, fnFail, + * fnProgress + */) { + var fns = arguments; + return jQuery.Deferred( + function(newDefer) { + jQuery.each(tuples, function(i, tuple) { + var fn = jQuery.isFunction(fns[i]) && fns[i]; + + // deferred[ + // done + // | + // fail + // | + // progress + // ] + // for + // forwarding + // actions + // to + // newDefer + deferred[tuple[1]](function() { + var returned = fn && fn.apply(this, arguments); + if (returned && jQuery.isFunction(returned.promise)) { + returned.promise().progress(newDefer.notify).done( + newDefer.resolve).fail(newDefer.reject); + } else { + newDefer[tuple[0] + "With"]( + this === promise ? newDefer.promise() + : this, fn ? [ returned ] + : arguments); + } + }); + }); + fns = null; + }).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise + // aspect is added to the object + promise : function(obj) { + return obj != null ? jQuery.extend(obj, promise) : promise; + } + }, deferred = {}; + + // Keep pipe for back-compat + promise.pipe = promise.then; + + // Add list-specific methods + jQuery.each(tuples, function(i, tuple) { + var list = tuple[2], stateString = tuple[3]; + + // promise[ done | fail + // | progress ] = + // list.add + promise[tuple[1]] = list.add; + + // Handle state + if (stateString) { + list.add(function() { + + // state + // = [ + // resolved + // | + // rejected + // ] + state = stateString; + + // [ + // reject_list + // | + // resolve_list + // ].disable; + // progress_list.lock + }, tuples[i ^ 1][2].disable, tuples[2][2].lock); + } + + // deferred[ resolve | + // reject | notify ] + deferred[tuple[0]] = function() { + deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments); + return this; + }; + deferred[tuple[0] + "With"] = list.fireWith; + }); + + // Make the deferred a promise + promise.promise(deferred); + + // Call given func if any + if (func) { + func.call(deferred, deferred); + } + + // All done! + return deferred; + }, + + // Deferred helper + when : function(subordinate /* + * , ..., + * subordinateN + */) { + var i = 0, resolveValues = slice.call(arguments), length = resolveValues.length, + + // the count of uncompleted subordinates + remaining = length !== 1 || (subordinate && jQuery.isFunction(subordinate.promise)) ? length + : 0, + + // the master Deferred. + // If resolveValues consist of only a single + // Deferred, just use that. + deferred = remaining === 1 ? subordinate : jQuery.Deferred(), + + // Update function for both resolve and + // progress values + updateFunc = function(i, contexts, values) { + return function(value) { + contexts[i] = this; + values[i] = arguments.length > 1 ? slice.call(arguments) : value; + if (values === progressValues) { + deferred.notifyWith(contexts, values); + + } else if (!(--remaining)) { + deferred.resolveWith(contexts, values); + } + }; + }, + + progressValues, progressContexts, resolveContexts; + + // add listeners to Deferred subordinates; + // treat others as resolved + if (length > 1) { + progressValues = new Array(length); + progressContexts = new Array(length); + resolveContexts = new Array(length); + for (; i < length; i++) { + if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) { + resolveValues[i].promise().progress( + updateFunc(i, progressContexts, progressValues)).done( + updateFunc(i, resolveContexts, resolveValues)).fail( + deferred.reject); + } else { + --remaining; + } + } + } + + // if we're not waiting on anything, resolve + // the master + if (!remaining) { + deferred.resolveWith(resolveContexts, resolveValues); + } + + return deferred.promise(); + } + }); + + // The deferred used on DOM ready + var readyList; + + jQuery.fn.ready = function(fn) { + + // Add the callback + jQuery.ready.promise().done(fn); + + return this; + }; + + jQuery.extend({ + + // Is the DOM ready to be used? Set to true once it + // occurs. + isReady : false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait : 1, + + // Hold (or release) the ready event + holdReady : function(hold) { + if (hold) { + jQuery.readyWait++; + } else { + jQuery.ready(true); + } + }, + + // Handle when the DOM is ready + ready : function(wait) { + + // Abort if there are pending holds or we're already + // ready + if (wait === true ? --jQuery.readyWait : jQuery.isReady) { + return; + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and + // wait if need be + if (wait !== true && --jQuery.readyWait > 0) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith(document, [ jQuery ]); + + // Trigger any bound ready events + if (jQuery.fn.triggerHandler) { + jQuery(document).triggerHandler("ready"); + jQuery(document).off("ready"); + } + } + }); + + /** + * Clean-up method for dom ready events + */ + function detach() { + if (document.addEventListener) { + document.removeEventListener("DOMContentLoaded", completed); + window.removeEventListener("load", completed); + + } else { + document.detachEvent("onreadystatechange", completed); + window.detachEvent("onload", completed); + } + } + + /** + * The ready event handler and self cleanup method + */ + function completed() { + + // readyState === "complete" is good enough for us to + // call the dom ready in oldIE + if (document.addEventListener || window.event.type === "load" + || document.readyState === "complete") { + + detach(); + jQuery.ready(); + } + } + + jQuery.ready.promise = function(obj) { + if (!readyList) { + + readyList = jQuery.Deferred(); + + // Catch cases where $(document).ready() is called + // after the browser event has already occurred. + // Support: IE6-10 + // Older IE sometimes signals "interactive" too soon + if (document.readyState === "complete" + || (document.readyState !== "loading" && !document.documentElement.doScroll)) { + + // Handle it asynchronously to allow scripts the + // opportunity to delay ready + window.setTimeout(jQuery.ready); + + // Standards-based browsers support + // DOMContentLoaded + } else if (document.addEventListener) { + + // Use the handy event callback + document.addEventListener("DOMContentLoaded", completed); + + // A fallback to window.onload, that will always + // work + window.addEventListener("load", completed); + + // If IE event model is used + } else { + + // Ensure firing before onload, maybe late but + // safe also for iframes + document.attachEvent("onreadystatechange", completed); + + // A fallback to window.onload, that will always + // work + window.attachEvent("onload", completed); + + // If IE and not a frame + // continually check to see if the document is + // ready + var top = false; + + try { + top = window.frameElement == null && document.documentElement; + } catch (e) { + } + + if (top && top.doScroll) { + (function doScrollCheck() { + if (!jQuery.isReady) { + + try { + + // Use the trick by Diego Perini + // http://javascript.nwbox.com/IEContentLoaded/ + top.doScroll("left"); + } catch (e) { + return window.setTimeout(doScrollCheck, 50); + } + + // detach all dom ready events + detach(); + + // and execute any waiting functions + jQuery.ready(); + } + })(); + } + } + } + return readyList.promise(obj); + }; + + // Kick off the DOM ready check even if the user does not + jQuery.ready.promise(); + + // Support: IE<9 + // Iteration over object's inherited properties before its + // own + var i; + for (i in jQuery(support)) { + break; + } + support.ownFirst = i === "0"; + + // Note: most support tests are defined in their respective + // modules. + // false until the test is run + support.inlineBlockNeedsLayout = false; + + // Execute ASAP in case we need to set body.style.zoom + jQuery(function() { + + // Minified: var a,b,c,d + var val, div, body, container; + + body = document.getElementsByTagName("body")[0]; + if (!body || !body.style) { + + // Return for frameset docs that don't have a body + return; + } + + // Setup + div = document.createElement("div"); + container = document.createElement("div"); + container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; + body.appendChild(container).appendChild(div); + + if (typeof div.style.zoom !== "undefined") { + + // Support: IE<8 + // Check if natively block-level elements act like + // inline-block + // elements when setting their display to 'inline' + // and giving + // them layout + div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1"; + + support.inlineBlockNeedsLayout = val = div.offsetWidth === 3; + if (val) { + + // Prevent IE 6 from affecting layout for + // positioned elements #11048 + // Prevent IE from shrinking the body in IE 7 + // mode #12869 + // Support: IE<8 + body.style.zoom = 1; + } + } + + body.removeChild(container); + }); + + (function() { + var div = document.createElement("div"); + + // Support: IE<9 + support.deleteExpando = true; + try { + delete div.test; + } catch (e) { + support.deleteExpando = false; + } + + // Null elements to avoid leaks in IE. + div = null; + })(); + var acceptData = function(elem) { + var noData = jQuery.noData[(elem.nodeName + " ").toLowerCase()], nodeType = +elem.nodeType || 1; + + // Do not set data on non-element DOM nodes because it + // will not be cleared (#8335). + return nodeType !== 1 && nodeType !== 9 ? false : + + // Nodes accept data unless otherwise specified; + // rejection can be conditional + !noData || noData !== true && elem.getAttribute("classid") === noData; + }; + + var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /([A-Z])/g; + + function dataAttr(elem, key, data) { + + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if (data === undefined && elem.nodeType === 1) { + + var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase(); + + data = elem.getAttribute(name); + + if (typeof data === "string") { + try { + data = data === "true" ? true : data === "false" ? false : data === "null" ? null : + + // Only convert to a + // number if it + // doesn't change + // the string + +data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data; + } catch (e) { + } + + // Make sure we set the data so it isn't changed + // later + jQuery.data(elem, key, data); + + } else { + data = undefined; + } + } + + return data; + } + + // checks a cache object for emptiness + function isEmptyDataObject(obj) { + var name; + for (name in obj) { + + // if the public data object is empty, the private + // is still empty + if (name === "data" && jQuery.isEmptyObject(obj[name])) { + continue; + } + if (name !== "toJSON") { + return false; + } + } + + return true; + } + + function internalData(elem, name, data, pvt /* + * Internal Use + * Only + */) { + if (!acceptData(elem)) { + return; + } + + var ret, thisCache, internalKey = jQuery.expando, + + // We have to handle DOM nodes and JS objects + // differently because IE6-7 + // can't GC object references properly across the DOM-JS + // boundary + isNode = elem.nodeType, + + // Only DOM nodes need the global jQuery cache; JS + // object data is + // attached directly to the object so GC can occur + // automatically + cache = isNode ? jQuery.cache : elem, + + // Only defining an ID for JS objects if its cache + // already exists allows + // the code to shortcut on the same path as a DOM node + // with no cache + id = isNode ? elem[internalKey] : elem[internalKey] && internalKey; + + // Avoid doing any more work than we need to when trying + // to get data on an + // object that has no data at all + if ((!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined + && typeof name === "string") { + return; + } + + if (!id) { + + // Only DOM nodes need a new unique ID for each + // element since their data + // ends up in the global cache + if (isNode) { + id = elem[internalKey] = deletedIds.pop() || jQuery.guid++; + } else { + id = internalKey; + } + } + + if (!cache[id]) { + + // Avoid exposing jQuery metadata on plain JS + // objects when the object + // is serialized using JSON.stringify + cache[id] = isNode ? {} : { + toJSON : jQuery.noop + }; + } + + // An object can be passed to jQuery.data instead of a + // key/value pair; this gets + // shallow copied over onto the existing cache + if (typeof name === "object" || typeof name === "function") { + if (pvt) { + cache[id] = jQuery.extend(cache[id], name); + } else { + cache[id].data = jQuery.extend(cache[id].data, name); + } + } + + thisCache = cache[id]; + + // jQuery data() is stored in a separate object inside + // the object's internal data + // cache in order to avoid key collisions between + // internal data and user-defined + // data. + if (!pvt) { + if (!thisCache.data) { + thisCache.data = {}; + } + + thisCache = thisCache.data; + } + + if (data !== undefined) { + thisCache[jQuery.camelCase(name)] = data; + } + + // Check for both converted-to-camel and non-converted + // data property names + // If a data property was specified + if (typeof name === "string") { + + // First Try to find as-is property data + ret = thisCache[name]; + + // Test for null|undefined property data + if (ret == null) { + + // Try to find the camelCased property + ret = thisCache[jQuery.camelCase(name)]; + } + } else { + ret = thisCache; + } + + return ret; + } + + function internalRemoveData(elem, name, pvt) { + if (!acceptData(elem)) { + return; + } + + var thisCache, i, isNode = elem.nodeType, + + // See jQuery.data for more information + cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando; + + // If there is already no cache entry for this object, + // there is no + // purpose in continuing + if (!cache[id]) { + return; + } + + if (name) { + + thisCache = pvt ? cache[id] : cache[id].data; + + if (thisCache) { + + // Support array or space separated string names + // for data keys + if (!jQuery.isArray(name)) { + + // try the string as a key before any + // manipulation + if (name in thisCache) { + name = [ name ]; + } else { + + // split the camel cased version by + // spaces unless a key with the spaces + // exists + name = jQuery.camelCase(name); + if (name in thisCache) { + name = [ name ]; + } else { + name = name.split(" "); + } + } + } else { + + // If "name" is an array of keys... + // When data is initially created, via + // ("key", "val") signature, + // keys will be converted to camelCase. + // Since there is no way to tell _how_ a key + // was added, remove + // both plain key and camelCase key. #12786 + // This will only penalize the array + // argument path. + name = name.concat(jQuery.map(name, jQuery.camelCase)); + } + + i = name.length; + while (i--) { + delete thisCache[name[i]]; + } + + // If there is no data left in the cache, we + // want to continue + // and let the cache object itself get destroyed + if (pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache)) { + return; + } + } + } + + // See jQuery.data for more information + if (!pvt) { + delete cache[id].data; + + // Don't destroy the parent cache unless the + // internal data object + // had been the only thing left in it + if (!isEmptyDataObject(cache[id])) { + return; + } + } + + // Destroy the cache + if (isNode) { + jQuery.cleanData([ elem ], true); + + // Use delete when supported for expandos or `cache` + // is not a window per isWindow (#10080) + /* jshint eqeqeq: false */ + } else if (support.deleteExpando || cache != cache.window) { + /* jshint eqeqeq: true */ + delete cache[id]; + + // When all else fails, undefined + } else { + cache[id] = undefined; + } + } + + jQuery.extend({ + cache : {}, + + // The following elements (space-suffixed to + // avoid Object.prototype collisions) + // throw uncatchable exceptions if you attempt + // to set expando properties + noData : { + "applet " : true, + "embed " : true, + + // ...but Flash objects (which have this + // classid) *can* handle expandos + "object " : "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" + }, + + hasData : function(elem) { + elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando]; + return !!elem && !isEmptyDataObject(elem); + }, + + data : function(elem, name, data) { + return internalData(elem, name, data); + }, + + removeData : function(elem, name) { + return internalRemoveData(elem, name); + }, + + // For internal use only. + _data : function(elem, name, data) { + return internalData(elem, name, data, true); + }, + + _removeData : function(elem, name) { + return internalRemoveData(elem, name, true); + } + }); + + jQuery.fn.extend({ + data : function(key, value) { + var i, name, data, elem = this[0], attrs = elem && elem.attributes; + + // Special expections of .data basically + // thwart jQuery.access, + // so implement the relevant behavior + // ourselves + + // Gets all values + if (key === undefined) { + if (this.length) { + data = jQuery.data(elem); + + if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) { + i = attrs.length; + while (i--) { + + // Support: IE11+ + // The attrs elements can be + // null (#14894) + if (attrs[i]) { + name = attrs[i].name; + if (name.indexOf("data-") === 0) { + name = jQuery.camelCase(name.slice(5)); + dataAttr(elem, name, data[name]); + } + } + } + jQuery._data(elem, "parsedAttrs", true); + } + } + + return data; + } + + // Sets multiple values + if (typeof key === "object") { + return this.each(function() { + jQuery.data(this, key); + }); + } + + return arguments.length > 1 ? + + // Sets one value + this.each(function() { + jQuery.data(this, key, value); + }) : + + // Gets one value + // Try to fetch any internally stored data + // first + elem ? dataAttr(elem, key, jQuery.data(elem, key)) : undefined; + }, + + removeData : function(key) { + return this.each(function() { + jQuery.removeData(this, key); + }); + } + }); + + jQuery + .extend({ + queue : function(elem, type, data) { + var queue; + + if (elem) { + type = (type || "fx") + "queue"; + queue = jQuery._data(elem, type); + + // Speed up dequeue by getting out + // quickly if this is just a lookup + if (data) { + if (!queue || jQuery.isArray(data)) { + queue = jQuery._data(elem, type, jQuery.makeArray(data)); + } else { + queue.push(data); + } + } + return queue || []; + } + }, + + dequeue : function(elem, type) { + type = type || "fx"; + + var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue + .shift(), hooks = jQuery._queueHooks(elem, type), next = function() { + jQuery.dequeue(elem, type); + }; + + // If the fx queue is dequeued, always + // remove the progress sentinel + if (fn === "inprogress") { + fn = queue.shift(); + startLength--; + } + + if (fn) { + + // Add a progress sentinel to prevent + // the fx queue from being + // automatically dequeued + if (type === "fx") { + queue.unshift("inprogress"); + } + + // clear up the last queue stop function + delete hooks.stop; + fn.call(elem, next, hooks); + } + + if (!startLength && hooks) { + hooks.empty.fire(); + } + }, + + // not intended for public consumption - + // generates a queueHooks object, + // or returns the current one + _queueHooks : function(elem, type) { + var key = type + "queueHooks"; + return jQuery._data(elem, key) || jQuery._data(elem, key, { + empty : jQuery.Callbacks("once memory").add(function() { + jQuery._removeData(elem, type + "queue"); + jQuery._removeData(elem, key); + }) + }); + } + }); + + jQuery.fn + .extend({ + queue : function(type, data) { + var setter = 2; + + if (typeof type !== "string") { + data = type; + type = "fx"; + setter--; + } + + if (arguments.length < setter) { + return jQuery.queue(this[0], type); + } + + return data === undefined ? this : this.each(function() { + var queue = jQuery.queue(this, type, data); + + // ensure a hooks for + // this queue + jQuery._queueHooks(this, type); + + if (type === "fx" && queue[0] !== "inprogress") { + jQuery.dequeue(this, type); + } + }); + }, + dequeue : function(type) { + return this.each(function() { + jQuery.dequeue(this, type); + }); + }, + clearQueue : function(type) { + return this.queue(type || "fx", []); + }, + + // Get a promise resolved when queues of a + // certain type + // are emptied (fx is the type by default) + promise : function(type, obj) { + var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { + if (!(--count)) { + defer.resolveWith(elements, [ elements ]); + } + }; + + if (typeof type !== "string") { + obj = type; + type = undefined; + } + type = type || "fx"; + + while (i--) { + tmp = jQuery._data(elements[i], type + "queueHooks"); + if (tmp && tmp.empty) { + count++; + tmp.empty.add(resolve); + } + } + resolve(); + return defer.promise(obj); + } + }); + + (function() { + var shrinkWrapBlocksVal; + + support.shrinkWrapBlocks = function() { + if (shrinkWrapBlocksVal != null) { + return shrinkWrapBlocksVal; + } + + // Will be changed later if needed. + shrinkWrapBlocksVal = false; + + // Minified: var b,c,d + var div, body, container; + + body = document.getElementsByTagName("body")[0]; + if (!body || !body.style) { + + // Test fired too early or in an unsupported + // environment, exit. + return; + } + + // Setup + div = document.createElement("div"); + container = document.createElement("div"); + container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; + body.appendChild(container).appendChild(div); + + // Support: IE6 + // Check if elements with layout shrink-wrap their + // children + if (typeof div.style.zoom !== "undefined") { + + // Reset CSS: box-sizing; display; margin; + // border + div.style.cssText = + + // Support: Firefox<29, Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + + "box-sizing:content-box;display:block;margin:0;border:0;" + + "padding:1px;width:1px;zoom:1"; + div.appendChild(document.createElement("div")).style.width = "5px"; + shrinkWrapBlocksVal = div.offsetWidth !== 3; + } + + body.removeChild(container); + + return shrinkWrapBlocksVal; + }; + + })(); + var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source; + + var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i"); + + var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + + var isHidden = function(elem, el) { + + // isHidden might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + return jQuery.css(elem, "display") === "none" || !jQuery.contains(elem.ownerDocument, elem); + }; + + function adjustCSS(elem, prop, valueParts, tween) { + var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function() { + return tween.cur(); + } : function() { + return jQuery.css(elem, prop, ""); + }, initial = currentValue(), unit = valueParts && valueParts[3] + || (jQuery.cssNumber[prop] ? "" : "px"), + + // Starting value computation is required for potential + // unit mismatches + initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) + && rcssNum.exec(jQuery.css(elem, prop)); + + if (initialInUnit && initialInUnit[3] !== unit) { + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[3]; + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + + // Iteratively approximate from a nonzero starting + // point + initialInUnit = +initial || 1; + + do { + + // If previous iteration zeroed out, double + // until we get *something*. + // Use string for doubling so we don't + // accidentally see scale as unchanged below + scale = scale || ".5"; + + // Adjust and apply + initialInUnit = initialInUnit / scale; + jQuery.style(elem, prop, initialInUnit + unit); + + // Update scale, tolerating zero or NaN from + // tween.cur() + // Break the loop if scale is unchanged or + // perfect, or if we've just had enough. + } while (scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations); + } + + if (valueParts) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] + : +valueParts[2]; + if (tween) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; + } + + // Multifunctional method to get and set values of a + // collection + // The value/s can optionally be executed if it's a function + var access = function(elems, fn, key, value, chainable, emptyGet, raw) { + var i = 0, length = elems.length, bulk = key == null; + + // Sets many values + if (jQuery.type(key) === "object") { + chainable = true; + for (i in key) { + access(elems, fn, i, key[i], true, emptyGet, raw); + } + + // Sets one value + } else if (value !== undefined) { + chainable = true; + + if (!jQuery.isFunction(value)) { + raw = true; + } + + if (bulk) { + + // Bulk operations run against the entire set + if (raw) { + fn.call(elems, value); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function(elem, key, value) { + return bulk.call(jQuery(elem), value); + }; + } + } + + if (fn) { + for (; i < length; i++) { + fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key))); + } + } + } + + return chainable ? elems : + + // Gets + bulk ? fn.call(elems) : length ? fn(elems[0], key) : emptyGet; + }; + var rcheckableType = (/^(?:checkbox|radio)$/i); + + var rtagName = (/<([\w:-]+)/); + + var rscriptType = (/^$|\/(?:java|ecma)script/i); + + var rleadingWhitespace = (/^\s+/); + + var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" + + "details|dialog|figcaption|figure|footer|header|hgroup|main|" + + "mark|meter|nav|output|picture|progress|section|summary|template|time|video"; + + function createSafeFragment(document) { + var list = nodeNames.split("|"), safeFrag = document.createDocumentFragment(); + + if (safeFrag.createElement) { + while (list.length) { + safeFrag.createElement(list.pop()); + } + } + return safeFrag; + } + + (function() { + var div = document.createElement("div"), fragment = document.createDocumentFragment(), input = document + .createElement("input"); + + // Setup + div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; + + // IE strips leading whitespace when .innerHTML is used + support.leadingWhitespace = div.firstChild.nodeType === 3; + + // Make sure that tbody elements aren't automatically + // inserted + // IE will insert them into empty tables + support.tbody = !div.getElementsByTagName("tbody").length; + + // Make sure that link elements get serialized correctly + // by innerHTML + // This requires a wrapper element in IE + support.htmlSerialize = !!div.getElementsByTagName("link").length; + + // Makes sure cloning an html5 element does not cause + // problems + // Where outerHTML is undefined, this still works + support.html5Clone = document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>"; + + // Check if a disconnected checkbox will retain its + // checked + // value of true after appended to the DOM (IE6/7) + input.type = "checkbox"; + input.checked = true; + fragment.appendChild(input); + support.appendChecked = input.checked; + + // Make sure textarea (and checkbox) defaultValue is + // properly cloned + // Support: IE6-IE11+ + div.innerHTML = "<textarea>x</textarea>"; + support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; + + // #11217 - WebKit loses check when the name is after + // the checked attribute + fragment.appendChild(div); + + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA + // (#14901) + input = document.createElement("input"); + input.setAttribute("type", "radio"); + input.setAttribute("checked", "checked"); + input.setAttribute("name", "t"); + + div.appendChild(input); + + // Support: Safari 5.1, iOS 5.1, Android 4.x, Android + // 2.3 + // old WebKit doesn't clone checked state correctly in + // fragments + support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; + + // Support: IE<9 + // Cloned elements keep attachEvent handlers, we use + // addEventListener on IE9+ + support.noCloneEvent = !!div.addEventListener; + + // Support: IE<9 + // Since attributes and properties are the same in IE, + // cleanData must set properties to undefined rather + // than use removeAttribute + div[jQuery.expando] = 1; + support.attributes = !div.getAttribute(jQuery.expando); + })(); + + // We have to close these tags to support XHTML (#13200) + var wrapMap = { + option : [ 1, "<select multiple='multiple'>", "</select>" ], + legend : [ 1, "<fieldset>", "</fieldset>" ], + area : [ 1, "<map>", "</map>" ], + + // Support: IE8 + param : [ 1, "<object>", "</object>" ], + thead : [ 1, "<table>", "</table>" ], + tr : [ 2, "<table><tbody>", "</tbody></table>" ], + col : [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ], + td : [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], + + // IE6-8 can't serialize link, script, style, or any + // html5 (NoScope) tags, + // unless wrapped in a div with non-breaking characters + // in front of it. + _default : support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ] + }; + + // Support: IE8-IE9 + wrapMap.optgroup = wrapMap.option; + + wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; + wrapMap.th = wrapMap.td; + + function getAll(context, tag) { + var elems, elem, i = 0, found = typeof context.getElementsByTagName !== "undefined" ? context + .getElementsByTagName(tag || "*") + : typeof context.querySelectorAll !== "undefined" ? context + .querySelectorAll(tag || "*") : undefined; + + if (!found) { + for (found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++) { + if (!tag || jQuery.nodeName(elem, tag)) { + found.push(elem); + } else { + jQuery.merge(found, getAll(elem, tag)); + } + } + } + + return tag === undefined || tag && jQuery.nodeName(context, tag) ? jQuery.merge([ context ], + found) : found; + } + + // Mark scripts as having already been evaluated + function setGlobalEval(elems, refElements) { + var elem, i = 0; + for (; (elem = elems[i]) != null; i++) { + jQuery + ._data(elem, "globalEval", !refElements + || jQuery._data(refElements[i], "globalEval")); + } + } + + var rhtml = /<|&#?\w+;/, rtbody = /<tbody/i; + + function fixDefaultChecked(elem) { + if (rcheckableType.test(elem.type)) { + elem.defaultChecked = elem.checked; + } + } + + function buildFragment(elems, context, scripts, selection, ignored) { + var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, + + // Ensure a safe fragment + safe = createSafeFragment(context), + + nodes = [], i = 0; + + for (; i < l; i++) { + elem = elems[i]; + + if (elem || elem === 0) { + + // Add nodes directly + if (jQuery.type(elem) === "object") { + jQuery.merge(nodes, elem.nodeType ? [ elem ] : elem); + + // Convert non-html into a text node + } else if (!rhtml.test(elem)) { + nodes.push(context.createTextNode(elem)); + + // Convert html into DOM nodes + } else { + tmp = tmp || safe.appendChild(context.createElement("div")); + + // Deserialize a standard representation + tag = (rtagName.exec(elem) || [ "", "" ])[1].toLowerCase(); + wrap = wrapMap[tag] || wrapMap._default; + + tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; + + // Descend through wrappers to the right + // content + j = wrap[0]; + while (j--) { + tmp = tmp.lastChild; + } + + // Manually add leading whitespace removed + // by IE + if (!support.leadingWhitespace && rleadingWhitespace.test(elem)) { + nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0])); + } + + // Remove IE's autoinserted <tbody> from + // table fragments + if (!support.tbody) { + + // String was a <table>, *may* have + // spurious <tbody> + elem = tag === "table" && !rtbody.test(elem) ? tmp.firstChild : + + // String was a bare <thead> or + // <tfoot> + wrap[1] === "<table>" && !rtbody.test(elem) ? tmp : 0; + + j = elem && elem.childNodes.length; + while (j--) { + if (jQuery.nodeName((tbody = elem.childNodes[j]), "tbody") + && !tbody.childNodes.length) { + + elem.removeChild(tbody); + } + } + } + + jQuery.merge(nodes, tmp.childNodes); + + // Fix #12392 for WebKit and IE > 9 + tmp.textContent = ""; + + // Fix #12392 for oldIE + while (tmp.firstChild) { + tmp.removeChild(tmp.firstChild); + } + + // Remember the top-level container for + // proper cleanup + tmp = safe.lastChild; + } + } + } + + // Fix #11356: Clear elements from fragment + if (tmp) { + safe.removeChild(tmp); + } + + // Reset defaultChecked for any radios and checkboxes + // about to be appended to the DOM in IE 6/7 (#8060) + if (!support.appendChecked) { + jQuery.grep(getAll(nodes, "input"), fixDefaultChecked); + } + + i = 0; + while ((elem = nodes[i++])) { + + // Skip elements already in the context collection + // (trac-4087) + if (selection && jQuery.inArray(elem, selection) > -1) { + if (ignored) { + ignored.push(elem); + } + + continue; + } + + contains = jQuery.contains(elem.ownerDocument, elem); + + // Append to fragment + tmp = getAll(safe.appendChild(elem), "script"); + + // Preserve script evaluation history + if (contains) { + setGlobalEval(tmp); + } + + // Capture executables + if (scripts) { + j = 0; + while ((elem = tmp[j++])) { + if (rscriptType.test(elem.type || "")) { + scripts.push(elem); + } + } + } + } + + tmp = null; + + return safe; + } + + (function() { + var i, eventName, div = document.createElement("div"); + + // Support: IE<9 (lack submit/change bubble), Firefox + // (lack focus(in | out) events) + for (i in { + submit : true, + change : true, + focusin : true + }) { + eventName = "on" + i; + + if (!(support[i] = eventName in window)) { + + // Beware of CSP restrictions + // (https://developer.mozilla.org/en/Security/CSP) + div.setAttribute(eventName, "t"); + support[i] = div.attributes[eventName].expando === false; + } + } + + // Null elements to avoid leaks in IE. + div = null; + })(); + + var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + + function returnTrue() { + return true; + } + + function returnFalse() { + return false; + } + + // Support: IE9 + // See #13393 for more info + function safeActiveElement() { + try { + return document.activeElement; + } catch (err) { + } + } + + function on(elem, types, selector, data, fn, one) { + var origFn, type; + + // Types can be a map of types/handlers + if (typeof types === "object") { + + // ( types-Object, selector, data ) + if (typeof selector !== "string") { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for (type in types) { + on(elem, type, selector, data, types[type], one); + } + return elem; + } + + if (data == null && fn == null) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if (fn == null) { + if (typeof selector === "string") { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if (fn === false) { + fn = returnFalse; + } else if (!fn) { + return elem; + } + + if (one === 1) { + origFn = fn; + fn = function(event) { + + // Can use an empty set, since event contains + // the info + jQuery().off(event); + return origFn.apply(this, arguments); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || (origFn.guid = jQuery.guid++); + } + return elem.each(function() { + jQuery.event.add(this, types, fn, data, selector); + }); + } + + /* + * Helper functions for managing events -- not part of the + * public interface. Props to Dean Edwards' addEvent library + * for many of the ideas. + */ + jQuery.event = { + + global : {}, + + add : function(elem, types, handler, data, selector) { + var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery + ._data(elem); + + // Don't attach events to noData or text/comment + // nodes (but allow plain objects) + if (!elemData) { + return; + } + + // Caller can pass in an object of custom data in + // lieu of the handler + if (handler.handler) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Make sure that the handler has a unique ID, used + // to find/remove it later + if (!handler.guid) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main + // handler, if this is the first + if (!(events = elemData.events)) { + events = elemData.events = {}; + } + if (!(eventHandle = elemData.handle)) { + eventHandle = elemData.handle = function(e) { + + // Discard the second event of a + // jQuery.event.trigger() and + // when an event is called after a page has + // unloaded + return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.dispatch + .apply(eventHandle.elem, arguments) + : undefined; + }; + + // Add elem as a property of the handle fn to + // prevent a memory leak + // with IE non-native events + eventHandle.elem = elem; + } + + // Handle multiple events separated by a space + types = (types || "").match(rnotwhite) || [ "" ]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + + // There *must* be a type, no attaching + // namespace-only handlers + if (!type) { + continue; + } + + // If event changes its type, use the special + // event handlers for the changed type + special = jQuery.event.special[type] || {}; + + // If selector defined, determine special event + // api type, otherwise given type + type = (selector ? special.delegateType : special.bindType) || type; + + // Update special based on newly reset type + special = jQuery.event.special[type] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend({ + type : type, + origType : origType, + data : data, + handler : handler, + guid : handler.guid, + selector : selector, + needsContext : selector && jQuery.expr.match.needsContext.test(selector), + namespace : namespaces.join(".") + }, handleObjIn); + + // Init the event handler queue if we're the + // first + if (!(handlers = events[type])) { + handlers = events[type] = []; + handlers.delegateCount = 0; + + // Only use addEventListener/attachEvent if + // the special events handler returns false + if (!special.setup + || special.setup.call(elem, data, namespaces, eventHandle) === false) { + + // Bind the global event handler to the + // element + if (elem.addEventListener) { + elem.addEventListener(type, eventHandle, false); + + } else if (elem.attachEvent) { + elem.attachEvent("on" + type, eventHandle); + } + } + } + + if (special.add) { + special.add.call(elem, handleObj); + + if (!handleObj.handler.guid) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates + // in front + if (selector) { + handlers.splice(handlers.delegateCount++, 0, handleObj); + } else { + handlers.push(handleObj); + } + + // Keep track of which events have ever been + // used, for event optimization + jQuery.event.global[type] = true; + } + + // Nullify elem to prevent memory leaks in IE + elem = null; + }, + + // Detach an event or set of events from an element + remove : function(elem, types, handler, selector, mappedTypes) { + var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery + .hasData(elem) + && jQuery._data(elem); + + if (!elemData || !(events = elemData.events)) { + return; + } + + // Once for each type.namespace in types; type may + // be omitted + types = (types || "").match(rnotwhite) || [ "" ]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + + // Unbind all events (on this namespace, if + // provided) for the element + if (!type) { + for (type in events) { + jQuery.event.remove(elem, type + types[t], handler, selector, true); + } + continue; + } + + special = jQuery.event.special[type] || {}; + type = (selector ? special.delegateType : special.bindType) || type; + handlers = events[type] || []; + tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"); + + // Remove matching events + origCount = j = handlers.length; + while (j--) { + handleObj = handlers[j]; + + if ((mappedTypes || origType === handleObj.origType) + && (!handler || handler.guid === handleObj.guid) + && (!tmp || tmp.test(handleObj.namespace)) + && (!selector || selector === handleObj.selector || selector === "**" + && handleObj.selector)) { + handlers.splice(j, 1); + + if (handleObj.selector) { + handlers.delegateCount--; + } + if (special.remove) { + special.remove.call(elem, handleObj); + } + } + } + + // Remove generic event handler if we removed + // something and no more handlers exist + // (avoids potential for endless recursion + // during removal of special event handlers) + if (origCount && !handlers.length) { + if (!special.teardown + || special.teardown.call(elem, namespaces, elemData.handle) === false) { + + jQuery.removeEvent(elem, type, elemData.handle); + } + + delete events[type]; + } + } + + // Remove the expando if it's no longer used + if (jQuery.isEmptyObject(events)) { + delete elemData.handle; + + // removeData also checks for emptiness and + // clears the expando if empty + // so use it instead of delete + jQuery._removeData(elem, "events"); + } + }, + + trigger : function(event, data, elem, onlyHandlers) { + var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [ elem || document ], type = hasOwn + .call(event, "type") ? event.type : event, namespaces = hasOwn.call(event, + "namespace") ? event.namespace.split(".") : []; + + cur = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if (elem.nodeType === 3 || elem.nodeType === 8) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're + // not firing them right now + if (rfocusMorph.test(type + jQuery.event.triggered)) { + return; + } + + if (type.indexOf(".") > -1) { + + // Namespaced trigger; create a regexp to match + // event type in handle() + namespaces = type.split("."); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf(":") < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, + // or just an event type string + event = event[jQuery.expando] ? event : new jQuery.Event(type, typeof event === "object" + && event); + + // Trigger bitmask: & 1 for native handlers; & 2 for + // jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join("."); + event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; + + // Clean up the event in case it is being reused + event.result = undefined; + if (!event.target) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, + // creating the handler arg list + data = data == null ? [ event ] : jQuery.makeArray(data, [ event ]); + + // Allow special events to draw outside the lines + special = jQuery.event.special[type] || {}; + if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) { + return; + } + + // Determine event propagation path in advance, per + // W3C events spec (#9951) + // Bubble up to document, then to window; watch for + // a global ownerDocument var (#9724) + if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) { + + bubbleType = special.delegateType || type; + if (!rfocusMorph.test(bubbleType + type)) { + cur = cur.parentNode; + } + for (; cur; cur = cur.parentNode) { + eventPath.push(cur); + tmp = cur; + } + + // Only add window if we got to document (e.g., + // not plain obj or detached DOM) + if (tmp === (elem.ownerDocument || document)) { + eventPath.push(tmp.defaultView || tmp.parentWindow || window); + } + } + + // Fire handlers on the event path + i = 0; + while ((cur = eventPath[i++]) && !event.isPropagationStopped()) { + + event.type = i > 1 ? bubbleType : special.bindType || type; + + // jQuery handler + handle = (jQuery._data(cur, "events") || {})[event.type] && jQuery._data(cur, "handle"); + + if (handle) { + handle.apply(cur, data); + } + + // Native handler + handle = ontype && cur[ontype]; + if (handle && handle.apply && acceptData(cur)) { + event.result = handle.apply(cur, data); + if (event.result === false) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if (!onlyHandlers && !event.isDefaultPrevented()) { + + if ((!special._default || special._default.apply(eventPath.pop(), data) === false) + && acceptData(elem)) { + + // Call a native DOM method on the target + // with the same name name as the event. + // Can't use an .isFunction() check here + // because IE6/7 fails that test. + // Don't do default actions on window, + // that's where global variables be (#6170) + if (ontype && elem[type] && !jQuery.isWindow(elem)) { + + // Don't re-trigger an onFOO event when + // we call its FOO() method + tmp = elem[ontype]; + + if (tmp) { + elem[ontype] = null; + } + + // Prevent re-triggering of the same + // event, since we already bubbled it + // above + jQuery.event.triggered = type; + try { + elem[type](); + } catch (e) { + + // IE<9 dies on focus/blur to hidden + // element (#1486,#12518) + // only reproducible on winXP IE8 + // native, not IE9 in IE8 mode + } + jQuery.event.triggered = undefined; + + if (tmp) { + elem[ontype] = tmp; + } + } + } + } + + return event.result; + }, + + dispatch : function(event) { + + // Make a writable jQuery.Event from the native + // event object + event = jQuery.event.fix(event); + + var i, j, ret, matched, handleObj, handlerQueue = [], args = slice.call(arguments), handlers = (jQuery + ._data(this, "events") || {})[event.type] + || [], special = jQuery.event.special[event.type] || {}; + + // Use the fix-ed jQuery.Event rather than the + // (read-only) native event + args[0] = event; + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, + // and let it bail if desired + if (special.preDispatch && special.preDispatch.call(this, event) === false) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call(this, event, handlers); + + // Run delegates first; they may want to stop + // propagation beneath us + i = 0; + while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) { + event.currentTarget = matched.elem; + + j = 0; + while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) { + + // Triggered event must either 1) have no + // namespace, or 2) have namespace(s) + // a subset or equal to those in the bound + // event (both can have no namespace). + if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler) + .apply(matched.elem, args); + + if (ret !== undefined) { + if ((event.result = ret) === false) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if (special.postDispatch) { + special.postDispatch.call(this, event); + } + + return event.result; + }, + + handlers : function(event, handlers) { + var i, matches, sel, handleObj, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; + + // Support (at least): Chrome, IE9 + // Find delegate handlers + // Black-hole SVG <use> instance trees (#13180) + // + // Support: Firefox<=42+ + // Avoid non-left-click in FF but don't block IE + // radio events (#3861, gh-2343) + if (delegateCount && cur.nodeType + && (event.type !== "click" || isNaN(event.button) || event.button < 1)) { + + /* jshint eqeqeq: false */ + for (; cur != this; cur = cur.parentNode || this) { + /* jshint eqeqeq: true */ + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements + // (#6911, #8165, #11382, #11764) + if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click")) { + matches = []; + for (i = 0; i < delegateCount; i++) { + handleObj = handlers[i]; + + // Don't conflict with + // Object.prototype properties + // (#13203) + sel = handleObj.selector + " "; + + if (matches[sel] === undefined) { + matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 + : jQuery.find(sel, this, null, [ cur ]).length; + } + if (matches[sel]) { + matches.push(handleObj); + } + } + if (matches.length) { + handlerQueue.push({ + elem : cur, + handlers : matches + }); + } + } + } + } + + // Add the remaining (directly-bound) handlers + if (delegateCount < handlers.length) { + handlerQueue.push({ + elem : this, + handlers : handlers.slice(delegateCount) + }); + } + + return handlerQueue; + }, + + fix : function(event) { + if (event[jQuery.expando]) { + return event; + } + + // Create a writable copy of the event object and + // normalize some properties + var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type]; + + if (!fixHook) { + this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent + .test(type) ? this.keyHooks : {}; + } + copy = fixHook.props ? this.props.concat(fixHook.props) : this.props; + + event = new jQuery.Event(originalEvent); + + i = copy.length; + while (i--) { + prop = copy[i]; + event[prop] = originalEvent[prop]; + } + + // Support: IE<9 + // Fix target property (#1925) + if (!event.target) { + event.target = originalEvent.srcElement || document; + } + + // Support: Safari 6-8+ + // Target should not be a text node (#504, #13143) + if (event.target.nodeType === 3) { + event.target = event.target.parentNode; + } + + // Support: IE<9 + // For mouse/key events, metaKey==false if it's + // undefined (#3368, #11328) + event.metaKey = !!event.metaKey; + + return fixHook.filter ? fixHook.filter(event, originalEvent) : event; + }, + + // Includes some event props shared by KeyEvent and + // MouseEvent + props : ("altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " + + "metaKey relatedTarget shiftKey target timeStamp view which").split(" "), + + fixHooks : {}, + + keyHooks : { + props : "char charCode key keyCode".split(" "), + filter : function(event, original) { + + // Add which for key events + if (event.which == null) { + event.which = original.charCode != null ? original.charCode : original.keyCode; + } + + return event; + } + }, + + mouseHooks : { + props : ("button buttons clientX clientY fromElement offsetX offsetY " + + "pageX pageY screenX screenY toElement").split(" "), + filter : function(event, original) { + var body, eventDoc, doc, button = original.button, fromElement = original.fromElement; + + // Calculate pageX/Y if missing and clientX/Y + // available + if (event.pageX == null && original.clientX != null) { + eventDoc = event.target.ownerDocument || document; + doc = eventDoc.documentElement; + body = eventDoc.body; + + event.pageX = original.clientX + + (doc && doc.scrollLeft || body && body.scrollLeft || 0) + - (doc && doc.clientLeft || body && body.clientLeft || 0); + event.pageY = original.clientY + + (doc && doc.scrollTop || body && body.scrollTop || 0) + - (doc && doc.clientTop || body && body.clientTop || 0); + } + + // Add relatedTarget, if necessary + if (!event.relatedTarget && fromElement) { + event.relatedTarget = fromElement === event.target ? original.toElement + : fromElement; + } + + // Add which for click: 1 === left; 2 === + // middle; 3 === right + // Note: button is not normalized, so don't use + // it + if (!event.which && button !== undefined) { + event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0))); + } + + return event; + } + }, + + special : { + load : { + + // Prevent triggered image.load events from + // bubbling to window.load + noBubble : true + }, + focus : { + + // Fire native event if possible so blur/focus + // sequence is correct + trigger : function() { + if (this !== safeActiveElement() && this.focus) { + try { + this.focus(); + return false; + } catch (e) { + + // Support: IE<9 + // If we error on focus to hidden + // element (#1486, #12518), + // let .trigger() run the handlers + } + } + }, + delegateType : "focusin" + }, + blur : { + trigger : function() { + if (this === safeActiveElement() && this.blur) { + this.blur(); + return false; + } + }, + delegateType : "focusout" + }, + click : { + + // For checkbox, fire native event so checked + // state will be right + trigger : function() { + if (jQuery.nodeName(this, "input") && this.type === "checkbox" && this.click) { + this.click(); + return false; + } + }, + + // For cross-browser consistency, don't fire + // native .click() on links + _default : function(event) { + return jQuery.nodeName(event.target, "a"); + } + }, + + beforeunload : { + postDispatch : function(event) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue + // field is not set. + if (event.result !== undefined && event.originalEvent) { + event.originalEvent.returnValue = event.result; + } + } + } + }, + + // Piggyback on a donor event to simulate a different + // one + simulate : function(type, elem, event) { + var e = jQuery.extend(new jQuery.Event(), event, { + type : type, + isSimulated : true + + // Previously, `originalEvent: {}` was set here, so + // stopPropagation call + // would not be triggered on donor event, since in + // our own + // jQuery.event.stopPropagation function we had a + // check for existence of + // originalEvent.stopPropagation method, so, + // consequently it would be a noop. + // + // Guard for simulated events was moved to + // jQuery.event.stopPropagation function + // since `originalEvent` should point to the + // original event for the + // constancy with other events and for more focused + // logic + }); + + jQuery.event.trigger(e, null, elem); + + if (e.isDefaultPrevented()) { + event.preventDefault(); + } + } + }; + + jQuery.removeEvent = document.removeEventListener ? function(elem, type, handle) { + + // This "if" is needed for plain objects + if (elem.removeEventListener) { + elem.removeEventListener(type, handle); + } + } : function(elem, type, handle) { + var name = "on" + type; + + if (elem.detachEvent) { + + // #8545, #7054, preventing memory leaks for + // custom events in IE6-8 + // detachEvent needed property on element, + // by name of that event, + // to properly expose it to GC + if (typeof elem[name] === "undefined") { + elem[name] = null; + } + + elem.detachEvent(name, handle); + } + }; + + jQuery.Event = function(src, props) { + + // Allow instantiation without the 'new' keyword + if (!(this instanceof jQuery.Event)) { + return new jQuery.Event(src, props); + } + + // Event object + if (src && src.type) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been + // marked as prevented + // by a handler lower down the tree; reflect the + // correct value. + this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && + + // Support: IE < 9, Android < 4.0 + src.returnValue === false ? returnTrue : returnFalse; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event + // object + if (props) { + jQuery.extend(this, props); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || jQuery.now(); + + // Mark it as fixed + this[jQuery.expando] = true; + }; + + // jQuery.Event is based on DOM3 Events as specified by the + // ECMAScript Language Binding + // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html + jQuery.Event.prototype = { + constructor : jQuery.Event, + isDefaultPrevented : returnFalse, + isPropagationStopped : returnFalse, + isImmediatePropagationStopped : returnFalse, + + preventDefault : function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + if (!e) { + return; + } + + // If preventDefault exists, run it on the original + // event + if (e.preventDefault) { + e.preventDefault(); + + // Support: IE + // Otherwise set the returnValue property of the + // original event to false + } else { + e.returnValue = false; + } + }, + stopPropagation : function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if (!e || this.isSimulated) { + return; + } + + // If stopPropagation exists, run it on the original + // event + if (e.stopPropagation) { + e.stopPropagation(); + } + + // Support: IE + // Set the cancelBubble property of the original + // event to true + e.cancelBubble = true; + }, + stopImmediatePropagation : function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if (e && e.stopImmediatePropagation) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } + }; + + // Create mouseenter/leave events using mouseover/out and + // event-time checks + // so that event delegation works in jQuery. + // Do the same for pointerenter/pointerleave and + // pointerover/pointerout + // + // Support: Safari 7 only + // Safari sends mouseenter too often; see: + // https://code.google.com/p/chromium/issues/detail?id=470258 + // for the description of the bug (it existed in older + // Chrome versions as well). + jQuery.each({ + mouseenter : "mouseover", + mouseleave : "mouseout", + pointerenter : "pointerover", + pointerleave : "pointerout" + }, function(orig, fix) { + jQuery.event.special[orig] = { + delegateType : fix, + bindType : fix, + + handle : function(event) { + var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; + + // For mouseenter/leave call the + // handler if related is outside + // the target. + // NB: No relatedTarget if the + // mouse left/entered the + // browser window + if (!related || (related !== target && !jQuery.contains(target, related))) { + event.type = handleObj.origType; + ret = handleObj.handler.apply(this, arguments); + event.type = fix; + } + return ret; + } + }; + }); + + // IE submit delegation + if (!support.submit) { + + jQuery.event.special.submit = { + setup : function() { + + // Only need this for delegated form submit + // events + if (jQuery.nodeName(this, "form")) { + return false; + } + + // Lazy-add a submit handler when a descendant + // form may potentially be submitted + jQuery.event.add(this, "click._submit keypress._submit", function(e) { + + // Node name check avoids a + // VML-related crash in IE + // (#9807) + var elem = e.target, form = jQuery.nodeName(elem, "input") + || jQuery.nodeName(elem, "button") ? + + // Support: IE <=8 + // We use jQuery.prop + // instead of elem.form + // to allow fixing the IE8 + // delegated submit issue + // (gh-2332) + // by 3rd party + // polyfills/workarounds. + jQuery.prop(elem, "form") : undefined; + + if (form && !jQuery._data(form, "submit")) { + jQuery.event.add(form, "submit._submit", function(event) { + event._submitBubble = true; + }); + jQuery._data(form, "submit", true); + } + }); + + // return undefined since we don't need an event + // listener + }, + + postDispatch : function(event) { + + // If form was submitted by the user, bubble the + // event up the tree + if (event._submitBubble) { + delete event._submitBubble; + if (this.parentNode && !event.isTrigger) { + jQuery.event.simulate("submit", this.parentNode, event); + } + } + }, + + teardown : function() { + + // Only need this for delegated form submit + // events + if (jQuery.nodeName(this, "form")) { + return false; + } + + // Remove delegated handlers; cleanData + // eventually reaps submit handlers attached + // above + jQuery.event.remove(this, "._submit"); + } + }; + } + + // IE change delegation and checkbox/radio fix + if (!support.change) { + + jQuery.event.special.change = { + + setup : function() { + + if (rformElems.test(this.nodeName)) { + + // IE doesn't fire change on a check/radio + // until blur; trigger it on click + // after a propertychange. Eat the + // blur-change in special.change.handle. + // This still fires onchange a second time + // for check/radio after blur. + if (this.type === "checkbox" || this.type === "radio") { + jQuery.event.add(this, "propertychange._change", function(event) { + if (event.originalEvent.propertyName === "checked") { + this._justChanged = true; + } + }); + jQuery.event.add(this, "click._change", function(event) { + if (this._justChanged && !event.isTrigger) { + this._justChanged = false; + } + + // Allow triggered, + // simulated change + // events (#11500) + jQuery.event.simulate("change", this, event); + }); + } + return false; + } + + // Delegated event; lazy-add a change handler on + // descendant inputs + jQuery.event.add(this, "beforeactivate._change", function(e) { + var elem = e.target; + + if (rformElems.test(elem.nodeName) && !jQuery._data(elem, "change")) { + jQuery.event.add(elem, "change._change", function(event) { + if (this.parentNode && !event.isSimulated && !event.isTrigger) { + jQuery.event.simulate("change", this.parentNode, event); + } + }); + jQuery._data(elem, "change", true); + } + }); + }, + + handle : function(event) { + var elem = event.target; + + // Swallow native change events from + // checkbox/radio, we already triggered them + // above + if (this !== elem || event.isSimulated || event.isTrigger + || (elem.type !== "radio" && elem.type !== "checkbox")) { + + return event.handleObj.handler.apply(this, arguments); + } + }, + + teardown : function() { + jQuery.event.remove(this, "._change"); + + return !rformElems.test(this.nodeName); + } + }; + } + + // Support: Firefox + // Firefox doesn't have focus(in | out) events + // Related ticket - + // https://bugzilla.mozilla.org/show_bug.cgi?id=687787 + // + // Support: Chrome, Safari + // focus(in | out) events fire after focus & blur events, + // which is spec violation - + // http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order + // Related ticket - + // https://code.google.com/p/chromium/issues/detail?id=449857 + if (!support.focusin) { + jQuery.each({ + focus : "focusin", + blur : "focusout" + }, function(orig, fix) { + + // Attach a single capturing handler on the + // document while someone wants + // focusin/focusout + var handler = function(event) { + jQuery.event.simulate(fix, event.target, jQuery.event.fix(event)); + }; + + jQuery.event.special[fix] = { + setup : function() { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix); + + if (!attaches) { + doc.addEventListener(orig, handler, true); + } + jQuery._data(doc, fix, (attaches || 0) + 1); + }, + teardown : function() { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix) - 1; + + if (!attaches) { + doc.removeEventListener(orig, handler, true); + jQuery._removeData(doc, fix); + } else { + jQuery._data(doc, fix, attaches); + } + } + }; + }); + } + + jQuery.fn.extend({ + + on : function(types, selector, data, fn) { + return on(this, types, selector, data, fn); + }, + one : function(types, selector, data, fn) { + return on(this, types, selector, data, fn, 1); + }, + off : function(types, selector, fn) { + var handleObj, type; + if (types && types.preventDefault && types.handleObj) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery(types.delegateTarget).off( + handleObj.namespace ? handleObj.origType + "." + handleObj.namespace + : handleObj.origType, handleObj.selector, handleObj.handler); + return this; + } + if (typeof types === "object") { + + // ( types-object [, selector] ) + for (type in types) { + this.off(type, selector, types[type]); + } + return this; + } + if (selector === false || typeof selector === "function") { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if (fn === false) { + fn = returnFalse; + } + return this.each(function() { + jQuery.event.remove(this, types, fn, selector); + }); + }, + + trigger : function(type, data) { + return this.each(function() { + jQuery.event.trigger(type, data, this); + }); + }, + triggerHandler : function(type, data) { + var elem = this[0]; + if (elem) { + return jQuery.event.trigger(type, data, elem, true); + } + } + }); + + var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, rnoshimcache = new RegExp("<(?:" + nodeNames + + ")[\\s/>]", "i"), rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi, + + // Support: IE 10-11, Edge 10240+ + // In IE/Edge using regex groups here causes severe + // slowdowns. + // See + // https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /<script|<style|<link/i, + + // checked="checked" or checked + rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, safeFragment = createSafeFragment(document), fragmentDiv = safeFragment + .appendChild(document.createElement("div")); + + // Support: IE<8 + // Manipulating tables requires a tbody + function manipulationTarget(elem, content) { + return jQuery.nodeName(elem, "table") + && jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr") ? + + elem.getElementsByTagName("tbody")[0] + || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem; + } + + // Replace/restore the type attribute of script elements for + // safe DOM manipulation + function disableScript(elem) { + elem.type = (jQuery.find.attr(elem, "type") !== null) + "/" + elem.type; + return elem; + } + function restoreScript(elem) { + var match = rscriptTypeMasked.exec(elem.type); + if (match) { + elem.type = match[1]; + } else { + elem.removeAttribute("type"); + } + return elem; + } + + function cloneCopyEvent(src, dest) { + if (dest.nodeType !== 1 || !jQuery.hasData(src)) { + return; + } + + var type, i, l, oldData = jQuery._data(src), curData = jQuery._data(dest, oldData), events = oldData.events; + + if (events) { + delete curData.handle; + curData.events = {}; + + for (type in events) { + for (i = 0, l = events[type].length; i < l; i++) { + jQuery.event.add(dest, type, events[type][i]); + } + } + } + + // make the cloned public data object a copy from the + // original + if (curData.data) { + curData.data = jQuery.extend({}, curData.data); + } + } + + function fixCloneNodeIssues(src, dest) { + var nodeName, e, data; + + // We do not need to do anything for non-Elements + if (dest.nodeType !== 1) { + return; + } + + nodeName = dest.nodeName.toLowerCase(); + + // IE6-8 copies events bound via attachEvent when using + // cloneNode. + if (!support.noCloneEvent && dest[jQuery.expando]) { + data = jQuery._data(dest); + + for (e in data.events) { + jQuery.removeEvent(dest, e, data.handle); + } + + // Event data gets referenced instead of copied if + // the expando gets copied too + dest.removeAttribute(jQuery.expando); + } + + // IE blanks contents when cloning scripts, and tries to + // evaluate newly-set text + if (nodeName === "script" && dest.text !== src.text) { + disableScript(dest).text = src.text; + restoreScript(dest); + + // IE6-10 improperly clones children of object + // elements using classid. + // IE10 throws NoModificationAllowedError if parent + // is null, #12132. + } else if (nodeName === "object") { + if (dest.parentNode) { + dest.outerHTML = src.outerHTML; + } + + // This path appears unavoidable for IE9. When + // cloning an object + // element in IE9, the outerHTML strategy above is + // not sufficient. + // If the src has innerHTML and the destination does + // not, + // copy the src.innerHTML into the dest.innerHTML. + // #10324 + if (support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML))) { + dest.innerHTML = src.innerHTML; + } + + } else if (nodeName === "input" && rcheckableType.test(src.type)) { + + // IE6-8 fails to persist the checked state of a + // cloned checkbox + // or radio button. Worse, IE6-7 fail to give the + // cloned element + // a checked appearance if the defaultChecked value + // isn't also set + + dest.defaultChecked = dest.checked = src.checked; + + // IE6-7 get confused and end up setting the value + // of a cloned + // checkbox/radio button to an empty string instead + // of "on" + if (dest.value !== src.value) { + dest.value = src.value; + } + + // IE6-8 fails to return the selected option to the + // default selected + // state when cloning options + } else if (nodeName === "option") { + dest.defaultSelected = dest.selected = src.defaultSelected; + + // IE6-8 fails to set the defaultValue to the + // correct value when + // cloning other types of input fields + } else if (nodeName === "input" || nodeName === "textarea") { + dest.defaultValue = src.defaultValue; + } + } + + function domManip(collection, args, callback, ignored) { + + // Flatten any nested arrays + args = concat.apply([], args); + + var first, node, hasScripts, scripts, doc, fragment, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], isFunction = jQuery + .isFunction(value); + + // We can't cloneNode fragments that contain checked, in + // WebKit + if (isFunction + || (l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value))) { + return collection.each(function(index) { + var self = collection.eq(index); + if (isFunction) { + args[0] = value.call(this, index, self.html()); + } + domManip(self, args, callback, ignored); + }); + } + + if (l) { + fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored); + first = fragment.firstChild; + + if (fragment.childNodes.length === 1) { + fragment = first; + } + + // Require either new content or an interest in + // ignored elements to invoke the callback + if (first || ignored) { + scripts = jQuery.map(getAll(fragment, "script"), disableScript); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain + // situations (#8070). + for (; i < l; i++) { + node = fragment; + + if (i !== iNoClone) { + node = jQuery.clone(node, true, true); + + // Keep references to cloned scripts for + // later restoration + if (hasScripts) { + + // Support: Android<4.1, PhantomJS<2 + // push.apply(_, arraylike) throws + // on ancient WebKit + jQuery.merge(scripts, getAll(node, "script")); + } + } + + callback.call(collection[i], node, i); + } + + if (hasScripts) { + doc = scripts[scripts.length - 1].ownerDocument; + + // Reenable scripts + jQuery.map(scripts, restoreScript); + + // Evaluate executable scripts on first + // document insertion + for (i = 0; i < hasScripts; i++) { + node = scripts[i]; + if (rscriptType.test(node.type || "") && !jQuery._data(node, "globalEval") + && jQuery.contains(doc, node)) { + + if (node.src) { + + // Optional AJAX dependency, but + // won't run scripts if not + // present + if (jQuery._evalUrl) { + jQuery._evalUrl(node.src); + } + } else { + jQuery + .globalEval((node.text || node.textContent || node.innerHTML || "") + .replace(rcleanScript, "")); + } + } + } + } + + // Fix #11809: Avoid leaking memory + fragment = first = null; + } + } + + return collection; + } + + function remove(elem, selector, keepData) { + var node, elems = selector ? jQuery.filter(selector, elem) : elem, i = 0; + + for (; (node = elems[i]) != null; i++) { + + if (!keepData && node.nodeType === 1) { + jQuery.cleanData(getAll(node)); + } + + if (node.parentNode) { + if (keepData && jQuery.contains(node.ownerDocument, node)) { + setGlobalEval(getAll(node, "script")); + } + node.parentNode.removeChild(node); + } + } + + return elem; + } + + jQuery + .extend({ + htmlPrefilter : function(html) { + return html.replace(rxhtmlTag, "<$1></$2>"); + }, + + clone : function(elem, dataAndEvents, deepDataAndEvents) { + var destElements, node, clone, i, srcElements, inPage = jQuery.contains( + elem.ownerDocument, elem); + + if (support.html5Clone || jQuery.isXMLDoc(elem) + || !rnoshimcache.test("<" + elem.nodeName + ">")) { + + clone = elem.cloneNode(true); + + // IE<=8 does not properly clone + // detached, unknown element nodes + } else { + fragmentDiv.innerHTML = elem.outerHTML; + fragmentDiv.removeChild(clone = fragmentDiv.firstChild); + } + + if ((!support.noCloneEvent || !support.noCloneChecked) + && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) { + + // We eschew Sizzle here for performance + // reasons: + // http://jsperf.com/getall-vs-sizzle/2 + destElements = getAll(clone); + srcElements = getAll(elem); + + // Fix all IE cloning issues + for (i = 0; (node = srcElements[i]) != null; ++i) { + + // Ensure that the destination node + // is not null; Fixes #9587 + if (destElements[i]) { + fixCloneNodeIssues(node, destElements[i]); + } + } + } + + // Copy the events from the original to the + // clone + if (dataAndEvents) { + if (deepDataAndEvents) { + srcElements = srcElements || getAll(elem); + destElements = destElements || getAll(clone); + + for (i = 0; (node = srcElements[i]) != null; i++) { + cloneCopyEvent(node, destElements[i]); + } + } else { + cloneCopyEvent(elem, clone); + } + } + + // Preserve script evaluation history + destElements = getAll(clone, "script"); + if (destElements.length > 0) { + setGlobalEval(destElements, !inPage && getAll(elem, "script")); + } + + destElements = srcElements = node = null; + + // Return the cloned set + return clone; + }, + + cleanData : function(elems, /* internal */ + forceAcceptData) { + var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, attributes = support.attributes, special = jQuery.event.special; + + for (; (elem = elems[i]) != null; i++) { + if (forceAcceptData || acceptData(elem)) { + + id = elem[internalKey]; + data = id && cache[id]; + + if (data) { + if (data.events) { + for (type in data.events) { + if (special[type]) { + jQuery.event.remove(elem, type); + + // This is a + // shortcut to avoid + // jQuery.event.remove's + // overhead + } else { + jQuery.removeEvent(elem, type, data.handle); + } + } + } + + // Remove cache only if it was + // not already removed by + // jQuery.event.remove + if (cache[id]) { + + delete cache[id]; + + // Support: IE<9 + // IE does not allow us to + // delete expando properties + // from nodes + // IE creates expando + // attributes along with the + // property + // IE does not have a + // removeAttribute function + // on Document nodes + if (!attributes && typeof elem.removeAttribute !== "undefined") { + elem.removeAttribute(internalKey); + + // Webkit & Blink + // performance suffers + // when deleting + // properties + // from DOM nodes, so + // set to undefined + // instead + // https://code.google.com/p/chromium/issues/detail?id=378607 + } else { + elem[internalKey] = undefined; + } + + deletedIds.push(id); + } + } + } + } + } + }); + + jQuery.fn.extend({ + + // Keep domManip exposed until 3.0 (gh-2225) + domManip : domManip, + + detach : function(selector) { + return remove(this, selector, true); + }, + + remove : function(selector) { + return remove(this, selector); + }, + + text : function(value) { + return access(this, function(value) { + return value === undefined ? jQuery.text(this) : this.empty().append( + (this[0] && this[0].ownerDocument || document).createTextNode(value)); + }, null, value, arguments.length); + }, + + append : function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.appendChild(elem); + } + }); + }, + + prepend : function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.insertBefore(elem, target.firstChild); + } + }); + }, + + before : function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this); + } + }); + }, + + after : function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this.nextSibling); + } + }); + }, + + empty : function() { + var elem, i = 0; + + for (; (elem = this[i]) != null; i++) { + + // Remove element nodes and prevent + // memory leaks + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + } + + // Remove any remaining nodes + while (elem.firstChild) { + elem.removeChild(elem.firstChild); + } + + // If this is a select, ensure that it + // displays empty (#12336) + // Support: IE<9 + if (elem.options && jQuery.nodeName(elem, "select")) { + elem.options.length = 0; + } + } + + return this; + }, + + clone : function(dataAndEvents, deepDataAndEvents) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map(function() { + return jQuery.clone(this, dataAndEvents, deepDataAndEvents); + }); + }, + + html : function(value) { + return access(this, function(value) { + var elem = this[0] || {}, i = 0, l = this.length; + + if (value === undefined) { + return elem.nodeType === 1 ? elem.innerHTML.replace(rinlinejQuery, "") : undefined; + } + + // See if we can take a shortcut + // and just use innerHTML + if (typeof value === "string" && !rnoInnerhtml.test(value) + && (support.htmlSerialize || !rnoshimcache.test(value)) + && (support.leadingWhitespace || !rleadingWhitespace.test(value)) + && !wrapMap[(rtagName.exec(value) || [ "", "" ])[1].toLowerCase()]) { + + value = jQuery.htmlPrefilter(value); + + try { + for (; i < l; i++) { + + // Remove element + // nodes and prevent + // memory leaks + elem = this[i] || {}; + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML + // throws an exception, + // use the fallback + // method + } catch (e) { + } + } + + if (elem) { + this.empty().append(value); + } + }, null, value, arguments.length); + }, + + replaceWith : function() { + var ignored = []; + + // Make the changes, replacing each + // non-ignored context element with the new + // content + return domManip(this, arguments, function(elem) { + var parent = this.parentNode; + + if (jQuery.inArray(this, ignored) < 0) { + jQuery.cleanData(getAll(this)); + if (parent) { + parent.replaceChild(elem, this); + } + } + + // Force callback invocation + }, ignored); + } + }); + + jQuery.each({ + appendTo : "append", + prependTo : "prepend", + insertBefore : "before", + insertAfter : "after", + replaceAll : "replaceWith" + }, function(name, original) { + jQuery.fn[name] = function(selector) { + var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; + + for (; i <= last; i++) { + elems = i === last ? this : this.clone(true); + jQuery(insert[i])[original](elems); + + // Modern browsers can apply + // jQuery collections as arrays, + // but oldIE needs a .get() + push.apply(ret, elems.get()); + } + + return this.pushStack(ret); + }; + }); + + var iframe, elemdisplay = { + + // Support: Firefox + // We have to pre-define these values for FF (#10227) + HTML : "block", + BODY : "block" + }; + + /** + * Retrieve the actual display of a element + * + * @param {String} + * name nodeName of the element + * @param {Object} + * doc Document object + */ + + // Called only from within defaultDisplay + function actualDisplay(name, doc) { + var elem = jQuery(doc.createElement(name)).appendTo(doc.body), + + display = jQuery.css(elem[0], "display"); + + // We don't have any data stored on the element, + // so use "detach" method as fast way to get rid of the + // element + elem.detach(); + + return display; + } + + /** + * Try to determine the default display value of an element + * + * @param {String} + * nodeName + */ + function defaultDisplay(nodeName) { + var doc = document, display = elemdisplay[nodeName]; + + if (!display) { + display = actualDisplay(nodeName, doc); + + // If the simple way fails, read from inside an + // iframe + if (display === "none" || !display) { + + // Use the already-created iframe if possible + iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")) + .appendTo(doc.documentElement); + + // Always write a new HTML skeleton so Webkit + // and Firefox don't choke on reuse + doc = (iframe[0].contentWindow || iframe[0].contentDocument).document; + + // Support: IE + doc.write(); + doc.close(); + + display = actualDisplay(nodeName, doc); + iframe.detach(); + } + + // Store the correct default display + elemdisplay[nodeName] = display; + } + + return display; + } + var rmargin = (/^margin/); + + var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i"); + + var swap = function(elem, options, callback, args) { + var ret, name, old = {}; + + // Remember the old values, and insert the new ones + for (name in options) { + old[name] = elem.style[name]; + elem.style[name] = options[name]; + } + + ret = callback.apply(elem, args || []); + + // Revert the old values + for (name in options) { + elem.style[name] = old[name]; + } + + return ret; + }; + + var documentElement = document.documentElement; + + (function() { + var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal, reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal, container = document + .createElement("div"), div = document.createElement("div"); + + // Finish early in limited (non-browser) environments + if (!div.style) { + return; + } + + div.style.cssText = "float:left;opacity:.5"; + + // Support: IE<9 + // Make sure that element opacity exists (as opposed to + // filter) + support.opacity = div.style.opacity === "0.5"; + + // Verify style float existence + // (IE uses styleFloat instead of cssFloat) + support.cssFloat = !!div.style.cssFloat; + + div.style.backgroundClip = "content-box"; + div.cloneNode(true).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + container = document.createElement("div"); + container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + + "padding:0;margin-top:1px;position:absolute"; + div.innerHTML = ""; + container.appendChild(div); + + // Support: Firefox<29, Android 2.3 + // Vendor-prefix box-sizing + support.boxSizing = div.style.boxSizing === "" || div.style.MozBoxSizing === "" + || div.style.WebkitBoxSizing === ""; + + jQuery.extend(support, { + reliableHiddenOffsets : function() { + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableHiddenOffsetsVal; + }, + + boxSizingReliable : function() { + + // We're checking for pixelPositionVal here + // instead of boxSizingReliableVal + // since that compresses better and they're + // computed together anyway. + if (pixelPositionVal == null) { + computeStyleTests(); + } + return boxSizingReliableVal; + }, + + pixelMarginRight : function() { + + // Support: Android 4.0-4.3 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return pixelMarginRightVal; + }, + + pixelPosition : function() { + if (pixelPositionVal == null) { + computeStyleTests(); + } + return pixelPositionVal; + }, + + reliableMarginRight : function() { + + // Support: Android 2.3 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableMarginRightVal; + }, + + reliableMarginLeft : function() { + + // Support: IE <=8 only, Android 4.0 - 4.3 only, + // Firefox <=3 - 37 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableMarginLeftVal; + } + }); + + function computeStyleTests() { + var contents, divStyle, documentElement = document.documentElement; + + // Setup + documentElement.appendChild(container); + + div.style.cssText = + + // Support: Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:border-box;box-sizing:border-box;" + "position:relative;display:block;" + + "margin:auto;border:1px;padding:1px;" + "top:1%;width:50%"; + + // Support: IE<9 + // Assume reasonable values in the absence of + // getComputedStyle + pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false; + pixelMarginRightVal = reliableMarginRightVal = true; + + // Check for getComputedStyle so that this code is + // not run in IE<9. + if (window.getComputedStyle) { + divStyle = window.getComputedStyle(div); + pixelPositionVal = (divStyle || {}).top !== "1%"; + reliableMarginLeftVal = (divStyle || {}).marginLeft === "2px"; + boxSizingReliableVal = (divStyle || { + width : "4px" + }).width === "4px"; + + // Support: Android 4.0 - 4.3 only + // Some styles come back with percentage values, + // even though they shouldn't + div.style.marginRight = "50%"; + pixelMarginRightVal = (divStyle || { + marginRight : "4px" + }).marginRight === "4px"; + + // Support: Android 2.3 only + // Div with explicit width and no margin-right + // incorrectly + // gets computed margin-right based on width of + // container (#3333) + // WebKit Bug 13343 - getComputedStyle returns + // wrong value for margin-right + contents = div.appendChild(document.createElement("div")); + + // Reset CSS: box-sizing; display; margin; + // border; padding + contents.style.cssText = div.style.cssText = + + // Support: Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + + "box-sizing:content-box;display:block;margin:0;border:0;padding:0"; + contents.style.marginRight = contents.style.width = "0"; + div.style.width = "1px"; + + reliableMarginRightVal = !parseFloat((window.getComputedStyle(contents) || {}).marginRight); + + div.removeChild(contents); + } + + // Support: IE6-8 + // First check that getClientRects works as expected + // Check if table cells still have + // offsetWidth/Height when they are set + // to display:none and there are still other visible + // table cells in a + // table row; if so, offsetWidth/Height are not + // reliable for use when + // determining if an element has been hidden + // directly using + // display:none (it is still safe to use offsets if + // a parent element is + // hidden; don safety goggles and see bug #4512 for + // more information). + div.style.display = "none"; + reliableHiddenOffsetsVal = div.getClientRects().length === 0; + if (reliableHiddenOffsetsVal) { + div.style.display = ""; + div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; + div.childNodes[0].style.borderCollapse = "separate"; + contents = div.getElementsByTagName("td"); + contents[0].style.cssText = "margin:0;border:0;padding:0;display:none"; + reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; + if (reliableHiddenOffsetsVal) { + contents[0].style.display = ""; + contents[1].style.display = "none"; + reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; + } + } + + // Teardown + documentElement.removeChild(container); + } + + })(); + + var getStyles, curCSS, rposition = /^(top|right|bottom|left)$/; + + if (window.getComputedStyle) { + getStyles = function(elem) { + + // Support: IE<=11+, Firefox<=30+ (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through + // "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if (!view || !view.opener) { + view = window; + } + + return view.getComputedStyle(elem); + }; + + curCSS = function(elem, name, computed) { + var width, minWidth, maxWidth, ret, style = elem.style; + + computed = computed || getStyles(elem); + + // getPropertyValue is only needed for + // .css('filter') in IE9, see #12537 + ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined; + + // Support: Opera 12.1x only + // Fall back to style even without computed + // computed is undefined for elems on document + // fragments + if ((ret === "" || ret === undefined) && !jQuery.contains(elem.ownerDocument, elem)) { + ret = jQuery.style(elem, name); + } + + if (computed) { + + // A tribute to the "awesome hack by Dean + // Edwards" + // Chrome < 17 and Safari 5.0 uses "computed + // value" + // instead of "used value" for margin-right + // Safari 5.1.7 (at least) returns percentage + // for a larger set of values, + // but width seems to be reliably pixels + // this is against the CSSOM draft spec: + // http://dev.w3.org/csswg/cssom/#resolved-values + if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed + // value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + // Support: IE + // IE returns zIndex value as an integer. + return ret === undefined ? ret : ret + ""; + }; + } else if (documentElement.currentStyle) { + getStyles = function(elem) { + return elem.currentStyle; + }; + + curCSS = function(elem, name, computed) { + var left, rs, rsLeft, ret, style = elem.style; + + computed = computed || getStyles(elem); + ret = computed ? computed[name] : undefined; + + // Avoid setting ret to empty string here + // so we don't default to auto + if (ret == null && style && style[name]) { + ret = style[name]; + } + + // From the awesome hack by Dean Edwards + // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 + + // If we're not dealing with a regular pixel number + // but a number that has a weird ending, we need to + // convert it to pixels + // but not position css attributes, as those are + // proportional to the parent element instead + // and we can't measure the parent instead because + // it + // might trigger a "stacking dolls" problem + if (rnumnonpx.test(ret) && !rposition.test(name)) { + + // Remember the original values + left = style.left; + rs = elem.runtimeStyle; + rsLeft = rs && rs.left; + + // Put in the new values to get a computed value + // out + if (rsLeft) { + rs.left = elem.currentStyle.left; + } + style.left = name === "fontSize" ? "1em" : ret; + ret = style.pixelLeft + "px"; + + // Revert the changed values + style.left = left; + if (rsLeft) { + rs.left = rsLeft; + } + } + + // Support: IE + // IE returns zIndex value as an integer. + return ret === undefined ? ret : ret + "" || "auto"; + }; + } + + function addGetHookIf(conditionFn, hookFn) { + + // Define the hook, we'll check on the first run if it's + // really needed. + return { + get : function() { + if (conditionFn()) { + + // Hook not needed (or it's not possible to + // use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support + // test is not executed again. + return (this.get = hookFn).apply(this, arguments); + } + }; + } + + var + + ralpha = /alpha\([^)]*\)/i, ropacity = /opacity\s*=\s*([^)]*)/i, + + // swappable if display is none or starts with table except + // "table", "table-cell", or "table-caption" + // see here for display values: + // https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, rnumsplit = new RegExp("^(" + pnum + ")(.*)$", "i"), + + cssShow = { + position : "absolute", + visibility : "hidden", + display : "block" + }, cssNormalTransform = { + letterSpacing : "0", + fontWeight : "400" + }, + + cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], emptyStyle = document.createElement("div").style; + + // return a css property mapped to a potentially vendor + // prefixed property + function vendorPropName(name) { + + // shortcut for names that are not vendor prefixed + if (name in emptyStyle) { + return name; + } + + // check for vendor prefixed names + var capName = name.charAt(0).toUpperCase() + name.slice(1), i = cssPrefixes.length; + + while (i--) { + name = cssPrefixes[i] + capName; + if (name in emptyStyle) { + return name; + } + } + } + + function showHide(elements, show) { + var display, elem, hidden, values = [], index = 0, length = elements.length; + + for (; index < length; index++) { + elem = elements[index]; + if (!elem.style) { + continue; + } + + values[index] = jQuery._data(elem, "olddisplay"); + display = elem.style.display; + if (show) { + + // Reset the inline display of this element to + // learn if it is + // being hidden by cascaded rules or not + if (!values[index] && display === "none") { + elem.style.display = ""; + } + + // Set elements which have been overridden with + // display: none + // in a stylesheet to whatever the default + // browser style is + // for such an element + if (elem.style.display === "" && isHidden(elem)) { + values[index] = jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName)); + } + } else { + hidden = isHidden(elem); + + if (display && display !== "none" || !hidden) { + jQuery._data(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display")); + } + } + } + + // Set the display of most of the elements in a second + // loop + // to avoid the constant reflow + for (index = 0; index < length; index++) { + elem = elements[index]; + if (!elem.style) { + continue; + } + if (!show || elem.style.display === "none" || elem.style.display === "") { + elem.style.display = show ? values[index] || "" : "none"; + } + } + + return elements; + } + + function setPositiveNumber(elem, value, subtract) { + var matches = rnumsplit.exec(value); + return matches ? + + // Guard against undefined "subtract", e.g., when used + // as in cssHooks + Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px") : value; + } + + function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) { + var i = extra === (isBorderBox ? "border" : "content") ? + + // If we already have the right measurement, avoid + // augmentation + 4 : + + // Otherwise initialize for horizontal or vertical + // properties + name === "width" ? 1 : 0, + + val = 0; + + for (; i < 4; i += 2) { + + // both box models exclude margin, so add it if we + // want it + if (extra === "margin") { + val += jQuery.css(elem, extra + cssExpand[i], true, styles); + } + + if (isBorderBox) { + + // border-box includes padding, so remove it if + // we want content + if (extra === "content") { + val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles); + } + + // at this point, extra isn't border nor margin, + // so remove border + if (extra !== "margin") { + val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } else { + + // at this point, extra isn't content, so add + // padding + val += jQuery.css(elem, "padding" + cssExpand[i], true, styles); + + // at this point, extra isn't content nor + // padding, so add border + if (extra !== "padding") { + val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } + } + + return val; + } + + function getWidthOrHeight(elem, name, extra) { + + // Start with offset property, which is equivalent to + // the border-box value + var valueIsBorderBox = true, val = name === "width" ? elem.offsetWidth : elem.offsetHeight, styles = getStyles(elem), isBorderBox = support.boxSizing + && jQuery.css(elem, "boxSizing", false, styles) === "border-box"; + + // some non-html elements return undefined for + // offsetWidth, so check for null/undefined + // svg - + // https://bugzilla.mozilla.org/show_bug.cgi?id=649285 + // MathML - + // https://bugzilla.mozilla.org/show_bug.cgi?id=491668 + if (val <= 0 || val == null) { + + // Fall back to computed then uncomputed css if + // necessary + val = curCSS(elem, name, styles); + if (val < 0 || val == null) { + val = elem.style[name]; + } + + // Computed unit is not pixels. Stop here and + // return. + if (rnumnonpx.test(val)) { + return val; + } + + // we need the check for style in case a browser + // which returns unreliable values + // for getComputedStyle silently falls back to the + // reliable elem.style + valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]); + + // Normalize "", auto, and prepare for extra + val = parseFloat(val) || 0; + } + + // use the active box-sizing model to add/subtract + // irrelevant styles + return (val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), + valueIsBorderBox, styles)) + + "px"; + } + + jQuery.extend({ + + // Add in style property hooks for overriding + // the default + // behavior of getting and setting a style + // property + cssHooks : { + opacity : { + get : function(elem, computed) { + if (computed) { + + // We should always get a number + // back from opacity + var ret = curCSS(elem, "opacity"); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these + // possibly-unitless properties + cssNumber : { + "animationIterationCount" : true, + "columnCount" : true, + "fillOpacity" : true, + "flexGrow" : true, + "flexShrink" : true, + "fontWeight" : true, + "lineHeight" : true, + "opacity" : true, + "order" : true, + "orphans" : true, + "widows" : true, + "zIndex" : true, + "zoom" : true + }, + + // Add in properties whose names you wish to fix + // before + // setting or getting the value + cssProps : { + + // normalize float css property + "float" : support.cssFloat ? "cssFloat" : "styleFloat" + }, + + // Get and set the style property on a DOM Node + style : function(elem, name, value, extra) { + + // Don't set styles on text and comment + // nodes + if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) { + return; + } + + // Make sure that we're working with the + // right name + var ret, type, hooks, origName = jQuery.camelCase(name), style = elem.style; + + name = jQuery.cssProps[origName] + || (jQuery.cssProps[origName] = vendorPropName(origName) || origName); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; + + // Check if we're setting a value + if (value !== undefined) { + type = typeof value; + + // Convert "+=" or "-=" to relative + // numbers (#7345) + if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) { + value = adjustCSS(elem, name, ret); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values + // aren't set. See: #7116 + if (value == null || value !== value) { + return; + } + + // If a number was passed in, add the + // unit (except for certain CSS + // properties) + if (type === "number") { + value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px"); + } + + // Fixes #8908, it can be done more + // correctly by specifing setters in + // cssHooks, + // but it would mean to define eight + // (for every problematic property) + // identical functions + if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) { + style[name] = "inherit"; + } + + // If a hook was provided, use that + // value, otherwise just set the + // specified value + if (!hooks || !("set" in hooks) + || (value = hooks.set(elem, value, extra)) !== undefined) { + + // Support: IE + // Swallow errors from 'invalid' CSS + // values (#5509) + try { + style[name] = value; + } catch (e) { + } + } + + } else { + + // If a hook was provided get the + // non-computed value from there + if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) { + + return ret; + } + + // Otherwise just get the value from the + // style object + return style[name]; + } + }, + + css : function(elem, name, extra, styles) { + var num, val, hooks, origName = jQuery.camelCase(name); + + // Make sure that we're working with the + // right name + name = jQuery.cssProps[origName] + || (jQuery.cssProps[origName] = vendorPropName(origName) || origName); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; + + // If a hook was provided get the computed + // value from there + if (hooks && "get" in hooks) { + val = hooks.get(elem, true, extra); + } + + // Otherwise, if a way to get the computed + // value exists, use that + if (val === undefined) { + val = curCSS(elem, name, styles); + } + + // convert "normal" to computed value + if (val === "normal" && name in cssNormalTransform) { + val = cssNormalTransform[name]; + } + + // Return, converting to number if forced or + // a qualifier was provided and val looks + // numeric + if (extra === "" || extra) { + num = parseFloat(val); + return extra === true || isFinite(num) ? num || 0 : val; + } + return val; + } + }); + + jQuery + .each( + [ "height", "width" ], + function(i, name) { + jQuery.cssHooks[name] = { + get : function(elem, computed, extra) { + if (computed) { + + // certain elements can have + // dimension info if we + // invisibly show them + // however, it must have a + // current display style + // that would benefit from + // this + return rdisplayswap.test(jQuery.css(elem, "display")) + && elem.offsetWidth === 0 ? swap(elem, cssShow, function() { + return getWidthOrHeight(elem, name, extra); + }) : getWidthOrHeight(elem, name, extra); + } + }, + + set : function(elem, value, extra) { + var styles = extra && getStyles(elem); + return setPositiveNumber( + elem, + value, + extra ? augmentWidthOrHeight( + elem, + name, + extra, + support.boxSizing + && jQuery.css(elem, "boxSizing", false, styles) === "border-box", + styles) + : 0); + } + }; + }); + + if (!support.opacity) { + jQuery.cssHooks.opacity = { + get : function(elem, computed) { + + // IE uses filters for opacity + return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter + : elem.style.filter) + || "") ? (0.01 * parseFloat(RegExp.$1)) + "" : computed ? "1" : ""; + }, + + set : function(elem, value) { + var style = elem.style, currentStyle = elem.currentStyle, opacity = jQuery + .isNumeric(value) ? "alpha(opacity=" + value * 100 + ")" : "", filter = currentStyle + && currentStyle.filter || style.filter || ""; + + // IE has trouble with opacity if it does not + // have layout + // Force it by setting the zoom level + style.zoom = 1; + + // if setting opacity to 1, and no other filters + // exist - + // attempt to remove filter attribute #6652 + // if value === "", then remove inline opacity + // #12685 + if ((value >= 1 || value === "") && jQuery.trim(filter.replace(ralpha, "")) === "" + && style.removeAttribute) { + + // Setting style.filter to null, "" & " " + // still leave "filter:" in the cssText + // if "filter:" is present at all, clearType + // is disabled, we want to avoid this + // style.removeAttribute is IE Only, but so + // apparently is this code path... + style.removeAttribute("filter"); + + // if there is no filter style applied in a + // css rule + // or unset inline opacity, we are done + if (value === "" || currentStyle && !currentStyle.filter) { + return; + } + } + + // otherwise, set new filter values + style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + + opacity; + } + }; + } + + jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight, function(elem, computed) { + if (computed) { + return swap(elem, { + "display" : "inline-block" + }, curCSS, [ elem, "marginRight" ]); + } + }); + + jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(elem, computed) { + if (computed) { + return (parseFloat(curCSS(elem, "marginLeft")) || + + // Support: IE<=11+ + // Running getBoundingClientRect on a + // disconnected node in IE throws an error + // Support: IE8 only + // getClientRects() errors on disconnected + // elems + (jQuery.contains(elem.ownerDocument, elem) ? elem.getBoundingClientRect().left + - swap(elem, { + marginLeft : 0 + }, function() { + return elem.getBoundingClientRect().left; + }) : 0)) + + "px"; + } + }); + + // These hooks are used by animate to expand properties + jQuery.each({ + margin : "", + padding : "", + border : "Width" + }, function(prefix, suffix) { + jQuery.cssHooks[prefix + suffix] = { + expand : function(value) { + var i = 0, expanded = {}, + + // assumes a single number if + // not a string + parts = typeof value === "string" ? value.split(" ") : [ value ]; + + for (; i < 4; i++) { + expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0]; + } + + return expanded; + } + }; + + if (!rmargin.test(prefix)) { + jQuery.cssHooks[prefix + suffix].set = setPositiveNumber; + } + }); + + jQuery.fn.extend({ + css : function(name, value) { + return access(this, function(elem, name, value) { + var styles, len, map = {}, i = 0; + + if (jQuery.isArray(name)) { + styles = getStyles(elem); + len = name.length; + + for (; i < len; i++) { + map[name[i]] = jQuery.css(elem, name[i], false, styles); + } + + return map; + } + + return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name); + }, name, value, arguments.length > 1); + }, + show : function() { + return showHide(this, true); + }, + hide : function() { + return showHide(this); + }, + toggle : function(state) { + if (typeof state === "boolean") { + return state ? this.show() : this.hide(); + } + + return this.each(function() { + if (isHidden(this)) { + jQuery(this).show(); + } else { + jQuery(this).hide(); + } + }); + } + }); + + function Tween(elem, options, prop, end, easing) { + return new Tween.prototype.init(elem, options, prop, end, easing); + } + jQuery.Tween = Tween; + + Tween.prototype = { + constructor : Tween, + init : function(elem, options, prop, end, easing, unit) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px"); + }, + cur : function() { + var hooks = Tween.propHooks[this.prop]; + + return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this); + }, + run : function(percent) { + var eased, hooks = Tween.propHooks[this.prop]; + + if (this.options.duration) { + this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, + 0, 1, this.options.duration); + } else { + this.pos = eased = percent; + } + this.now = (this.end - this.start) * eased + this.start; + + if (this.options.step) { + this.options.step.call(this.elem, this.now, this); + } + + if (hooks && hooks.set) { + hooks.set(this); + } else { + Tween.propHooks._default.set(this); + } + return this; + } + }; + + Tween.prototype.init.prototype = Tween.prototype; + + Tween.propHooks = { + _default : { + get : function(tween) { + var result; + + // Use a property on the element directly when + // it is not a DOM element, + // or when there is no matching style property + // that exists. + if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null + && tween.elem.style[tween.prop] == null) { + return tween.elem[tween.prop]; + } + + // passing an empty string as a 3rd parameter to + // .css will automatically + // attempt a parseFloat and fallback to a string + // if the parse fails + // so, simple values such as "10px" are parsed + // to Float. + // complex values such as "rotate(1rad)" are + // returned as is. + result = jQuery.css(tween.elem, tween.prop, ""); + + // Empty strings, null, undefined and "auto" are + // converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set : function(tween) { + + // use step hook for back compat - use cssHook + // if its there - use .style if its + // available and use plain properties where + // available + if (jQuery.fx.step[tween.prop]) { + jQuery.fx.step[tween.prop](tween); + } else if (tween.elem.nodeType === 1 + && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) { + jQuery.style(tween.elem, tween.prop, tween.now + tween.unit); + } else { + tween.elem[tween.prop] = tween.now; + } + } + } + }; + + // Support: IE <=9 + // Panic based approach to setting things on disconnected + // nodes + + Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set : function(tween) { + if (tween.elem.nodeType && tween.elem.parentNode) { + tween.elem[tween.prop] = tween.now; + } + } + }; + + jQuery.easing = { + linear : function(p) { + return p; + }, + swing : function(p) { + return 0.5 - Math.cos(p * Math.PI) / 2; + }, + _default : "swing" + }; + + jQuery.fx = Tween.prototype.init; + + // Back Compat <1.8 extension point + jQuery.fx.step = {}; + + var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; + + // Animations created synchronously will run synchronously + function createFxNow() { + window.setTimeout(function() { + fxNow = undefined; + }); + return (fxNow = jQuery.now()); + } + + // Generate parameters to create a standard animation + function genFx(type, includeWidth) { + var which, attrs = { + height : type + }, i = 0; + + // if we include width, step value is 1 to do all + // cssExpand values, + // if we don't include width, step value is 2 to skip + // over Left and Right + includeWidth = includeWidth ? 1 : 0; + for (; i < 4; i += 2 - includeWidth) { + which = cssExpand[i]; + attrs["margin" + which] = attrs["padding" + which] = type; + } + + if (includeWidth) { + attrs.opacity = attrs.width = type; + } + + return attrs; + } + + function createTween(value, prop, animation) { + var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), index = 0, length = collection.length; + for (; index < length; index++) { + if ((tween = collection[index].call(animation, prop, value))) { + + // we're done with this property + return tween; + } + } + } + + function defaultPrefilter(elem, props, opts) { + /* jshint validthis: true */ + var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType + && isHidden(elem), dataShow = jQuery._data(elem, "fxshow"); + + // handle queue: false promises + if (!opts.queue) { + hooks = jQuery._queueHooks(elem, "fx"); + if (hooks.unqueued == null) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if (!hooks.unqueued) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always(function() { + + // doing this makes sure that the complete + // handler will be called + // before this completes + anim.always(function() { + hooks.unqueued--; + if (!jQuery.queue(elem, "fx").length) { + hooks.empty.fire(); + } + }); + }); + } + + // height/width overflow pass + if (elem.nodeType === 1 && ("height" in props || "width" in props)) { + + // Make sure that nothing sneaks out + // Record all 3 overflow attributes because IE does + // not + // change the overflow attribute when overflowX and + // overflowY are set to the same value + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Set display property to inline-block for + // height/width + // animations on inline elements that are having + // width/height animated + display = jQuery.css(elem, "display"); + + // Test default display if display is currently + // "none" + checkDisplay = display === "none" ? jQuery._data(elem, "olddisplay") + || defaultDisplay(elem.nodeName) : display; + + if (checkDisplay === "inline" && jQuery.css(elem, "float") === "none") { + + // inline-level elements accept inline-block; + // block-level elements need to be inline with + // layout + if (!support.inlineBlockNeedsLayout || defaultDisplay(elem.nodeName) === "inline") { + style.display = "inline-block"; + } else { + style.zoom = 1; + } + } + } + + if (opts.overflow) { + style.overflow = "hidden"; + if (!support.shrinkWrapBlocks()) { + anim.always(function() { + style.overflow = opts.overflow[0]; + style.overflowX = opts.overflow[1]; + style.overflowY = opts.overflow[2]; + }); + } + } + + // show/hide pass + for (prop in props) { + value = props[prop]; + if (rfxtypes.exec(value)) { + delete props[prop]; + toggle = toggle || value === "toggle"; + if (value === (hidden ? "hide" : "show")) { + + // If there is dataShow left over from a + // stopped hide or show + // and we are going to proceed with show, we + // should pretend to be hidden + if (value === "show" && dataShow && dataShow[prop] !== undefined) { + hidden = true; + } else { + continue; + } + } + orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop); + + // Any non-fx value stops us from restoring the + // original display value + } else { + display = undefined; + } + } + + if (!jQuery.isEmptyObject(orig)) { + if (dataShow) { + if ("hidden" in dataShow) { + hidden = dataShow.hidden; + } + } else { + dataShow = jQuery._data(elem, "fxshow", {}); + } + + // store state if its toggle - enables + // .stop().toggle() to "reverse" + if (toggle) { + dataShow.hidden = !hidden; + } + if (hidden) { + jQuery(elem).show(); + } else { + anim.done(function() { + jQuery(elem).hide(); + }); + } + anim.done(function() { + var prop; + jQuery._removeData(elem, "fxshow"); + for (prop in orig) { + jQuery.style(elem, prop, orig[prop]); + } + }); + for (prop in orig) { + tween = createTween(hidden ? dataShow[prop] : 0, prop, anim); + + if (!(prop in dataShow)) { + dataShow[prop] = tween.start; + if (hidden) { + tween.end = tween.start; + tween.start = prop === "width" || prop === "height" ? 1 : 0; + } + } + } + + // If this is a noop like .hide().hide(), restore an + // overwritten display value + } else if ((display === "none" ? defaultDisplay(elem.nodeName) : display) === "inline") { + style.display = display; + } + } + + function propFilter(props, specialEasing) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for (index in props) { + name = jQuery.camelCase(index); + easing = specialEasing[name]; + value = props[index]; + if (jQuery.isArray(value)) { + easing = value[1]; + value = props[index] = value[0]; + } + + if (index !== name) { + props[name] = value; + delete props[index]; + } + + hooks = jQuery.cssHooks[name]; + if (hooks && "expand" in hooks) { + value = hooks.expand(value); + delete props[name]; + + // not quite $.extend, this wont overwrite keys + // already present. + // also - reusing 'index' from above because we + // have the correct "name" + for (index in value) { + if (!(index in props)) { + props[index] = value[index]; + specialEasing[index] = easing; + } + } + } else { + specialEasing[name] = easing; + } + } + } + + function Animation(elem, properties, options) { + var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery + .Deferred().always(function() { + + // don't match elem in the :animated + // selector + delete tick.elem; + }), tick = function() { + if (stopped) { + return false; + } + var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + + animation.duration - currentTime), + + // Support: Android 2.3 + // Archaic crash bug won't allow us to use `1 - ( + // 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; + + for (; index < length; index++) { + animation.tweens[index].run(percent); + } + + deferred.notifyWith(elem, [ animation, percent, remaining ]); + + if (percent < 1 && length) { + return remaining; + } else { + deferred.resolveWith(elem, [ animation ]); + return false; + } + }, animation = deferred.promise({ + elem : elem, + props : jQuery.extend({}, properties), + opts : jQuery.extend(true, { + specialEasing : {}, + easing : jQuery.easing._default + }, options), + originalProperties : properties, + originalOptions : options, + startTime : fxNow || createFxNow(), + duration : options.duration, + tweens : [], + createTween : function(prop, end) { + var tween = jQuery.Tween(elem, animation.opts, prop, end, + animation.opts.specialEasing[prop] || animation.opts.easing); + animation.tweens.push(tween); + return tween; + }, + stop : function(gotoEnd) { + var index = 0, + + // if we are going to the end, we want to run + // all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if (stopped) { + return this; + } + stopped = true; + for (; index < length; index++) { + animation.tweens[index].run(1); + } + + // resolve when we played the last frame + // otherwise, reject + if (gotoEnd) { + deferred.notifyWith(elem, [ animation, 1, 0 ]); + deferred.resolveWith(elem, [ animation, gotoEnd ]); + } else { + deferred.rejectWith(elem, [ animation, gotoEnd ]); + } + return this; + } + }), props = animation.props; + + propFilter(props, animation.opts.specialEasing); + + for (; index < length; index++) { + result = Animation.prefilters[index].call(animation, elem, props, animation.opts); + if (result) { + if (jQuery.isFunction(result.stop)) { + jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy( + result.stop, result); + } + return result; + } + } + + jQuery.map(props, createTween, animation); + + if (jQuery.isFunction(animation.opts.start)) { + animation.opts.start.call(elem, animation); + } + + jQuery.fx.timer(jQuery.extend(tick, { + elem : elem, + anim : animation, + queue : animation.opts.queue + })); + + // attach callbacks from options + return animation.progress(animation.opts.progress).done(animation.opts.done, + animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always); + } + + jQuery.Animation = jQuery.extend(Animation, { + + tweeners : { + "*" : [ function(prop, value) { + var tween = this.createTween(prop, value); + adjustCSS(tween.elem, prop, rcssNum.exec(value), tween); + return tween; + } ] + }, + + tweener : function(props, callback) { + if (jQuery.isFunction(props)) { + callback = props; + props = [ "*" ]; + } else { + props = props.match(rnotwhite); + } + + var prop, index = 0, length = props.length; + + for (; index < length; index++) { + prop = props[index]; + Animation.tweeners[prop] = Animation.tweeners[prop] || []; + Animation.tweeners[prop].unshift(callback); + } + }, + + prefilters : [ defaultPrefilter ], + + prefilter : function(callback, prepend) { + if (prepend) { + Animation.prefilters.unshift(callback); + } else { + Animation.prefilters.push(callback); + } + } + }); + + jQuery.speed = function(speed, easing, fn) { + var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : { + complete : fn || !fn && easing || jQuery.isFunction(speed) && speed, + duration : speed, + easing : fn && easing || easing && !jQuery.isFunction(easing) && easing + }; + + opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration + : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] + : jQuery.fx.speeds._default; + + // normalize opt.queue - true/undefined/null -> "fx" + if (opt.queue == null || opt.queue === true) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if (jQuery.isFunction(opt.old)) { + opt.old.call(this); + } + + if (opt.queue) { + jQuery.dequeue(this, opt.queue); + } + }; + + return opt; + }; + + jQuery.fn + .extend({ + fadeTo : function(speed, to, easing, callback) { + + // show any hidden elements after setting + // opacity to 0 + return this.filter(isHidden).css("opacity", 0).show() + + // animate to the value specified + .end().animate({ + opacity : to + }, speed, easing, callback); + }, + animate : function(prop, speed, easing, callback) { + var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, + callback), doAnimation = function() { + + // Operate on a copy of prop so + // per-property easing won't be lost + var anim = Animation(this, jQuery.extend({}, prop), optall); + + // Empty animations, or finishing + // resolves immediately + if (empty || jQuery._data(this, "finish")) { + anim.stop(true); + } + }; + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? this.each(doAnimation) : this.queue( + optall.queue, doAnimation); + }, + stop : function(type, clearQueue, gotoEnd) { + var stopQueue = function(hooks) { + var stop = hooks.stop; + delete hooks.stop; + stop(gotoEnd); + }; + + if (typeof type !== "string") { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if (clearQueue && type !== false) { + this.queue(type || "fx", []); + } + + return this + .each(function() { + var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = jQuery + ._data(this); + + if (index) { + if (data[index] && data[index].stop) { + stopQueue(data[index]); + } + } else { + for (index in data) { + if (data[index] && data[index].stop && rrun.test(index)) { + stopQueue(data[index]); + } + } + } + + for (index = timers.length; index--;) { + if (timers[index].elem === this + && (type == null || timers[index].queue === type)) { + + timers[index].anim.stop(gotoEnd); + dequeue = false; + timers.splice(index, 1); + } + } + + // start the next in the queue + // if the last step wasn't + // forced + // timers currently will call + // their complete callbacks, + // which will dequeue + // but only if they were gotoEnd + if (dequeue || !gotoEnd) { + jQuery.dequeue(this, type); + } + }); + }, + finish : function(type) { + if (type !== false) { + type = type || "fx"; + } + return this + .each(function() { + var index, data = jQuery._data(this), queue = data[type + "queue"], hooks = data[type + + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length + : 0; + + // enable finishing flag on + // private data + data.finish = true; + + // empty the queue first + jQuery.queue(this, type, []); + + if (hooks && hooks.stop) { + hooks.stop.call(this, true); + } + + // look for any active + // animations, and finish them + for (index = timers.length; index--;) { + if (timers[index].elem === this && timers[index].queue === type) { + timers[index].anim.stop(true); + timers.splice(index, 1); + } + } + + // look for any animations in + // the old queue and finish them + for (index = 0; index < length; index++) { + if (queue[index] && queue[index].finish) { + queue[index].finish.call(this); + } + } + + // turn off finishing flag + delete data.finish; + }); + } + }); + + jQuery.each([ "toggle", "show", "hide" ], function(i, name) { + var cssFn = jQuery.fn[name]; + jQuery.fn[name] = function(speed, easing, callback) { + return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this + .animate(genFx(name, true), speed, easing, callback); + }; + }); + + // Generate shortcuts for custom animations + jQuery.each({ + slideDown : genFx("show"), + slideUp : genFx("hide"), + slideToggle : genFx("toggle"), + fadeIn : { + opacity : "show" + }, + fadeOut : { + opacity : "hide" + }, + fadeToggle : { + opacity : "toggle" + } + }, function(name, props) { + jQuery.fn[name] = function(speed, easing, callback) { + return this.animate(props, speed, easing, callback); + }; + }); + + jQuery.timers = []; + jQuery.fx.tick = function() { + var timer, timers = jQuery.timers, i = 0; + + fxNow = jQuery.now(); + + for (; i < timers.length; i++) { + timer = timers[i]; + + // Checks the timer has not already been removed + if (!timer() && timers[i] === timer) { + timers.splice(i--, 1); + } + } + + if (!timers.length) { + jQuery.fx.stop(); + } + fxNow = undefined; + }; + + jQuery.fx.timer = function(timer) { + jQuery.timers.push(timer); + if (timer()) { + jQuery.fx.start(); + } else { + jQuery.timers.pop(); + } + }; + + jQuery.fx.interval = 13; + + jQuery.fx.start = function() { + if (!timerId) { + timerId = window.setInterval(jQuery.fx.tick, jQuery.fx.interval); + } + }; + + jQuery.fx.stop = function() { + window.clearInterval(timerId); + timerId = null; + }; + + jQuery.fx.speeds = { + slow : 600, + fast : 200, + + // Default speed + _default : 400 + }; + + // Based off of the plugin by Clint Helfers, with + // permission. + // http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ + jQuery.fn.delay = function(time, type) { + time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; + type = type || "fx"; + + return this.queue(type, function(next, hooks) { + var timeout = window.setTimeout(next, time); + hooks.stop = function() { + window.clearTimeout(timeout); + }; + }); + }; + + (function() { + var a, input = document.createElement("input"), div = document.createElement("div"), select = document + .createElement("select"), opt = select.appendChild(document.createElement("option")); + + // Setup + div = document.createElement("div"); + div.setAttribute("className", "t"); + div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; + a = div.getElementsByTagName("a")[0]; + + // Support: Windows Web Apps (WWA) + // `type` must use .setAttribute for WWA (#14901) + input.setAttribute("type", "checkbox"); + div.appendChild(input); + + a = div.getElementsByTagName("a")[0]; + + // First batch of tests. + a.style.cssText = "top:1px"; + + // Test setAttribute on camelCase class. + // If it works, we need attrFixes when doing + // get/setAttribute (ie6/7) + support.getSetAttribute = div.className !== "t"; + + // Get the style information from getAttribute + // (IE uses .cssText instead) + support.style = /top/.test(a.getAttribute("style")); + + // Make sure that URLs aren't manipulated + // (IE normalizes it by default) + support.hrefNormalized = a.getAttribute("href") === "/a"; + + // Check the default checkbox/radio value ("" on WebKit; + // "on" elsewhere) + support.checkOn = !!input.value; + + // Make sure that a selected-by-default option has a + // working selected property. + // (WebKit defaults to false instead of true, IE too, if + // it's in an optgroup) + support.optSelected = opt.selected; + + // Tests for enctype support on a form (#6743) + support.enctype = !!document.createElement("form").enctype; + + // Make sure that the options inside disabled selects + // aren't marked as disabled + // (WebKit marks them as disabled) + select.disabled = true; + support.optDisabled = !opt.disabled; + + // Support: IE8 only + // Check if we can trust getAttribute("value") + input = document.createElement("input"); + input.setAttribute("value", ""); + support.input = input.getAttribute("value") === ""; + + // Check if an input maintains its value after becoming + // a radio + input.value = "t"; + input.setAttribute("type", "radio"); + support.radioValue = input.value === "t"; + })(); + + var rreturn = /\r/g, rspaces = /[\x20\t\r\n\f]+/g; + + jQuery.fn.extend({ + val : function(value) { + var hooks, ret, isFunction, elem = this[0]; + + if (!arguments.length) { + if (elem) { + hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()]; + + if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) { + return ret; + } + + ret = elem.value; + + return typeof ret === "string" ? + + // handle most common string cases + ret.replace(rreturn, "") : + + // handle cases where value is + // null/undef or number + ret == null ? "" : ret; + } + + return; + } + + isFunction = jQuery.isFunction(value); + + return this.each(function(i) { + var val; + + if (this.nodeType !== 1) { + return; + } + + if (isFunction) { + val = value.call(this, i, jQuery(this).val()); + } else { + val = value; + } + + // Treat null/undefined as ""; + // convert numbers to string + if (val == null) { + val = ""; + } else if (typeof val === "number") { + val += ""; + } else if (jQuery.isArray(val)) { + val = jQuery.map(val, function(value) { + return value == null ? "" : value + ""; + }); + } + + hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; + + // If set returns undefined, + // fall back to normal setting + if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) { + this.value = val; + } + }); + } + }); + + jQuery + .extend({ + valHooks : { + option : { + get : function(elem) { + var val = jQuery.find.attr(elem, "value"); + return val != null ? val : + + // Support: IE10-11+ + // option.text throws exceptions + // (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + jQuery.trim(jQuery.text(elem)).replace(rspaces, " "); + } + }, + select : { + get : function(elem) { + var value, option, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one" + || index < 0, values = one ? null : [], max = one ? index + 1 + : options.length, i = index < 0 ? max : one ? index : 0; + + // Loop through all the selected + // options + for (; i < max; i++) { + option = options[i]; + + // oldIE doesn't update selected + // after form reset (#2551) + if ((option.selected || i === index) + && + + // Don't return options + // that are disabled or + // in a disabled + // optgroup + (support.optDisabled ? !option.disabled : option + .getAttribute("disabled") === null) + && (!option.parentNode.disabled || !jQuery.nodeName( + option.parentNode, "optgroup"))) { + + // Get the specific value + // for the option + value = jQuery(option).val(); + + // We don't need an array + // for one selects + if (one) { + return value; + } + + // Multi-Selects return an + // array + values.push(value); + } + } + + return values; + }, + + set : function(elem, value) { + var optionSet, option, options = elem.options, values = jQuery + .makeArray(value), i = options.length; + + while (i--) { + option = options[i]; + + if (jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) { + + // Support: IE6 + // When new option element + // is added to select box we + // need to + // force reflow of newly + // added node in order to + // workaround delay + // of initialization + // properties + try { + option.selected = optionSet = true; + + } catch (_) { + + // Will be executed only + // in IE6 + option.scrollHeight; + } + + } else { + option.selected = false; + } + } + + // Force browsers to behave + // consistently when non-matching + // value is set + if (!optionSet) { + elem.selectedIndex = -1; + } + + return options; + } + } + } + }); + + // Radios and checkboxes getter/setter + jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[this] = { + set : function(elem, value) { + if (jQuery.isArray(value)) { + return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1); + } + } + }; + if (!support.checkOn) { + jQuery.valHooks[this].get = function(elem) { + return elem.getAttribute("value") === null ? "on" : elem.value; + }; + } + }); + + var nodeHook, boolHook, attrHandle = jQuery.expr.attrHandle, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = support.getSetAttribute, getSetInput = support.input; + + jQuery.fn.extend({ + attr : function(name, value) { + return access(this, jQuery.attr, name, value, arguments.length > 1); + }, + + removeAttr : function(name) { + return this.each(function() { + jQuery.removeAttr(this, name); + }); + } + }); + + jQuery.extend({ + attr : function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + + // Don't get/set attributes on text, comment + // and attribute nodes + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + + // Fallback to prop when attributes are not + // supported + if (typeof elem.getAttribute === "undefined") { + return jQuery.prop(elem, name, value); + } + + // All attributes are lowercase + // Grab necessary hook if one is defined + if (nType !== 1 || !jQuery.isXMLDoc(elem)) { + name = name.toLowerCase(); + hooks = jQuery.attrHooks[name] + || (jQuery.expr.match.bool.test(name) ? boolHook : nodeHook); + } + + if (value !== undefined) { + if (value === null) { + jQuery.removeAttr(elem, name); + return; + } + + if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) { + return ret; + } + + elem.setAttribute(name, value + ""); + return value; + } + + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + + ret = jQuery.find.attr(elem, name); + + // Non-existent attributes return null, we + // normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks : { + type : { + set : function(elem, value) { + if (!support.radioValue && value === "radio" && jQuery.nodeName(elem, "input")) { + + // Setting the type on a radio + // button after the value resets + // the value in IE8-9 + // Reset value to default in + // case type is set after value + // during creation + var val = elem.value; + elem.setAttribute("type", value); + if (val) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr : function(elem, value) { + var name, propName, i = 0, attrNames = value && value.match(rnotwhite); + + if (attrNames && elem.nodeType === 1) { + while ((name = attrNames[i++])) { + propName = jQuery.propFix[name] || name; + + // Boolean attributes get special + // treatment (#10870) + if (jQuery.expr.match.bool.test(name)) { + + // Set corresponding property to + // false + if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + elem[propName] = false; + + // Support: IE<9 + // Also clear + // defaultChecked/defaultSelected + // (if appropriate) + } else { + elem[jQuery.camelCase("default-" + name)] = elem[propName] = false; + } + + // See #9699 for explanation of + // this approach (setting first, + // then removal) + } else { + jQuery.attr(elem, name, ""); + } + + elem.removeAttribute(getSetAttribute ? name : propName); + } + } + } + }); + + // Hooks for boolean attributes + boolHook = { + set : function(elem, value, name) { + if (value === false) { + + // Remove boolean attributes when set to false + jQuery.removeAttr(elem, name); + } else if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + + // IE<8 needs the *property* name + elem.setAttribute(!getSetAttribute && jQuery.propFix[name] || name, name); + + } else { + + // Support: IE<9 + // Use defaultChecked and defaultSelected for + // oldIE + elem[jQuery.camelCase("default-" + name)] = elem[name] = true; + } + return name; + } + }; + + jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(i, name) { + var getter = attrHandle[name] || jQuery.find.attr; + + if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + attrHandle[name] = function(elem, name, isXML) { + var ret, handle; + if (!isXML) { + + // Avoid an infinite loop by + // temporarily removing this + // function from the getter + handle = attrHandle[name]; + attrHandle[name] = ret; + ret = getter(elem, name, isXML) != null ? name.toLowerCase() : null; + attrHandle[name] = handle; + } + return ret; + }; + } else { + attrHandle[name] = function(elem, name, isXML) { + if (!isXML) { + return elem[jQuery.camelCase("default-" + name)] ? name.toLowerCase() : null; + } + }; + } + }); + + // fix oldIE attroperties + if (!getSetInput || !getSetAttribute) { + jQuery.attrHooks.value = { + set : function(elem, value, name) { + if (jQuery.nodeName(elem, "input")) { + + // Does not return so that setAttribute is + // also used + elem.defaultValue = value; + } else { + + // Use nodeHook if defined (#1954); + // otherwise setAttribute is fine + return nodeHook && nodeHook.set(elem, value, name); + } + } + }; + } + + // IE6/7 do not support getting/setting some attributes with + // get/setAttribute + if (!getSetAttribute) { + + // Use this for any attribute in IE6/7 + // This fixes almost every IE6/7 issue + nodeHook = { + set : function(elem, value, name) { + + // Set the existing or create a new attribute + // node + var ret = elem.getAttributeNode(name); + if (!ret) { + elem.setAttributeNode((ret = elem.ownerDocument.createAttribute(name))); + } + + ret.value = value += ""; + + // Break association with cloned elements by + // also using setAttribute (#9646) + if (name === "value" || value === elem.getAttribute(name)) { + return value; + } + } + }; + + // Some attributes are constructed with empty-string + // values when not defined + attrHandle.id = attrHandle.name = attrHandle.coords = function(elem, name, isXML) { + var ret; + if (!isXML) { + return (ret = elem.getAttributeNode(name)) && ret.value !== "" ? ret.value : null; + } + }; + + // Fixing value retrieval on a button requires this + // module + jQuery.valHooks.button = { + get : function(elem, name) { + var ret = elem.getAttributeNode(name); + if (ret && ret.specified) { + return ret.value; + } + }, + set : nodeHook.set + }; + + // Set contenteditable to false on removals(#10429) + // Setting to empty string throws an error as an invalid + // value + jQuery.attrHooks.contenteditable = { + set : function(elem, value, name) { + nodeHook.set(elem, value === "" ? false : value, name); + } + }; + + // Set width and height to auto instead of 0 on empty + // string( Bug #8150 ) + // This is for removals + jQuery.each([ "width", "height" ], function(i, name) { + jQuery.attrHooks[name] = { + set : function(elem, value) { + if (value === "") { + elem.setAttribute(name, "auto"); + return value; + } + } + }; + }); + } + + if (!support.style) { + jQuery.attrHooks.style = { + get : function(elem) { + + // Return undefined in the case of empty string + // Note: IE uppercases css property names, but + // if we were to .toLowerCase() + // .cssText, that would destroy case sensitivity + // in URL's, like in "background" + return elem.style.cssText || undefined; + }, + set : function(elem, value) { + return (elem.style.cssText = value + ""); + } + }; + } + + var rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i; + + jQuery.fn.extend({ + prop : function(name, value) { + return access(this, jQuery.prop, name, value, arguments.length > 1); + }, + + removeProp : function(name) { + name = jQuery.propFix[name] || name; + return this.each(function() { + + // try/catch handles cases where IE balks (such + // as removing a property on window) + try { + this[name] = undefined; + delete this[name]; + } catch (e) { + } + }); + } + }); + + jQuery.extend({ + prop : function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + + // Don't get/set properties on text, comment + // and attribute nodes + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + + if (nType !== 1 || !jQuery.isXMLDoc(elem)) { + + // Fix name and attach hooks + name = jQuery.propFix[name] || name; + hooks = jQuery.propHooks[name]; + } + + if (value !== undefined) { + if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) { + return ret; + } + + return (elem[name] = value); + } + + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + + return elem[name]; + }, + + propHooks : { + tabIndex : { + get : function(elem) { + + // elem.tabIndex doesn't always + // return the + // correct value when it hasn't been + // explicitly set + // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + // Use proper attribute + // retrieval(#12072) + var tabindex = jQuery.find.attr(elem, "tabindex"); + + return tabindex ? parseInt(tabindex, 10) : rfocusable.test(elem.nodeName) + || rclickable.test(elem.nodeName) && elem.href ? 0 : -1; + } + } + }, + + propFix : { + "for" : "htmlFor", + "class" : "className" + } + }); + + // Some attributes require a special call on IE + // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx + if (!support.hrefNormalized) { + + // href/src property should get the full normalized URL + // (#10299/#12915) + jQuery.each([ "href", "src" ], function(i, name) { + jQuery.propHooks[name] = { + get : function(elem) { + return elem.getAttribute(name, 4); + } + }; + }); + } + + // Support: Safari, IE9+ + // Accessing the selectedIndex property + // forces the browser to respect setting selected + // on the option + // The getter ensures a default option is selected + // when in an optgroup + if (!support.optSelected) { + jQuery.propHooks.selected = { + get : function(elem) { + var parent = elem.parentNode; + + if (parent) { + parent.selectedIndex; + + // Make sure that it also works with + // optgroups, see #5701 + if (parent.parentNode) { + parent.parentNode.selectedIndex; + } + } + return null; + }, + set : function(elem) { + var parent = elem.parentNode; + if (parent) { + parent.selectedIndex; + + if (parent.parentNode) { + parent.parentNode.selectedIndex; + } + } + } + }; + } + + jQuery.each([ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", + "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { + jQuery.propFix[this.toLowerCase()] = this; + }); + + // IE6/7 call enctype encoding + if (!support.enctype) { + jQuery.propFix.enctype = "encoding"; + } + + var rclass = /[\t\r\n\f]/g; + + function getClass(elem) { + return jQuery.attr(elem, "class") || ""; + } + + jQuery.fn.extend({ + addClass : function(value) { + var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; + + if (jQuery.isFunction(value)) { + return this.each(function(j) { + jQuery(this).addClass(value.call(this, j, getClass(this))); + }); + } + + if (typeof value === "string" && value) { + classes = value.match(rnotwhite) || []; + + while ((elem = this[i++])) { + curValue = getClass(elem); + cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " "); + + if (cur) { + j = 0; + while ((clazz = classes[j++])) { + if (cur.indexOf(" " + clazz + " ") < 0) { + cur += clazz + " "; + } + } + + // only assign if different to + // avoid unneeded rendering. + finalValue = jQuery.trim(cur); + if (curValue !== finalValue) { + jQuery.attr(elem, "class", finalValue); + } + } + } + } + + return this; + }, + + removeClass : function(value) { + var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; + + if (jQuery.isFunction(value)) { + return this.each(function(j) { + jQuery(this).removeClass(value.call(this, j, getClass(this))); + }); + } + + if (!arguments.length) { + return this.attr("class", ""); + } + + if (typeof value === "string" && value) { + classes = value.match(rnotwhite) || []; + + while ((elem = this[i++])) { + curValue = getClass(elem); + + // This expression is here for + // better compressibility (see + // addClass) + cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " "); + + if (cur) { + j = 0; + while ((clazz = classes[j++])) { + + // Remove *all* instances + while (cur.indexOf(" " + clazz + " ") > -1) { + cur = cur.replace(" " + clazz + " ", " "); + } + } + + // Only assign if different to + // avoid unneeded rendering. + finalValue = jQuery.trim(cur); + if (curValue !== finalValue) { + jQuery.attr(elem, "class", finalValue); + } + } + } + } + + return this; + }, + + toggleClass : function(value, stateVal) { + var type = typeof value; + + if (typeof stateVal === "boolean" && type === "string") { + return stateVal ? this.addClass(value) : this.removeClass(value); + } + + if (jQuery.isFunction(value)) { + return this.each(function(i) { + jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal); + }); + } + + return this.each(function() { + var className, i, self, classNames; + + if (type === "string") { + + // Toggle individual class + // names + i = 0; + self = jQuery(this); + classNames = value.match(rnotwhite) || []; + + while ((className = classNames[i++])) { + + // Check each className + // given, space + // separated list + if (self.hasClass(className)) { + self.removeClass(className); + } else { + self.addClass(className); + } + } + + // Toggle whole class name + } else if (value === undefined || type === "boolean") { + className = getClass(this); + if (className) { + + // store className if + // set + jQuery._data(this, "__className__", className); + } + + // If the element has a + // class name or if we're + // passed "false", + // then remove the whole + // classname (if there was + // one, the above saved it). + // Otherwise bring back + // whatever was previously + // saved (if anything), + // falling back to the empty + // string if nothing was + // stored. + jQuery.attr(this, "class", className || value === false ? "" : jQuery._data(this, + "__className__") + || ""); + } + }); + }, + + hasClass : function(selector) { + var className, elem, i = 0; + + className = " " + selector + " "; + while ((elem = this[i++])) { + if (elem.nodeType === 1 + && (" " + getClass(elem) + " ").replace(rclass, " ").indexOf(className) > -1) { + return true; + } + } + + return false; + } + }); + + // Return jQuery for attributes-only inclusion + + jQuery.each(("blur focus focusin focusout load resize scroll unload click dblclick " + + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + + "change select submit keydown keypress keyup error contextmenu").split(" "), function(i, + name) { + + // Handle event binding + jQuery.fn[name] = function(data, fn) { + return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name); + }; + }); + + jQuery.fn.extend({ + hover : function(fnOver, fnOut) { + return this.mouseenter(fnOver).mouseleave(fnOut || fnOver); + } + }); + + var location = window.location; + + var nonce = jQuery.now(); + + var rquery = (/\?/); + + var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g; + + jQuery.parseJSON = function(data) { + + // Attempt to parse using the native JSON parser first + if (window.JSON && window.JSON.parse) { + + // Support: Android 2.3 + // Workaround failure to string-cast null input + return window.JSON.parse(data + ""); + } + + var requireNonComma, depth = null, str = jQuery.trim(data + ""); + + // Guard against invalid (and possibly dangerous) input + // by ensuring that nothing remains + // after removing valid tokens + return str && !jQuery.trim(str.replace(rvalidtokens, function(token, comma, open, close) { + + // Force termination if we see a + // misplaced comma + if (requireNonComma && comma) { + depth = 0; + } + + // Perform no more replacements + // after returning to outermost + // depth + if (depth === 0) { + return token; + } + + // Commas must not follow "[", "{", + // or "," + requireNonComma = open || comma; + + // Determine new depth + // array/object open ("[" or "{"): + // depth += true - false (increment) + // array/object close ("]" or "}"): + // depth += false - true (decrement) + // other cases ("," or primitive): + // depth += true - true (numeric + // cast) + depth += !close - !open; + + // Remove this token + return ""; + })) ? (Function("return " + str))() : jQuery.error("Invalid JSON: " + data); + }; + + // Cross-browser xml parsing + jQuery.parseXML = function(data) { + var xml, tmp; + if (!data || typeof data !== "string") { + return null; + } + try { + if (window.DOMParser) { // Standard + tmp = new window.DOMParser(); + xml = tmp.parseFromString(data, "text/xml"); + } else { // IE + xml = new window.ActiveXObject("Microsoft.XMLDOM"); + xml.async = "false"; + xml.loadXML(data); + } + } catch (e) { + xml = undefined; + } + if (!xml || !xml.documentElement || xml.getElementsByTagName("parsererror").length) { + jQuery.error("Invalid XML: " + data); + } + return xml; + }; + + var rhash = /#.*$/, rts = /([?&])_=[^&]*/, + + // IE leaves an \r character at EOL + rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, + + /* + * Prefilters 1) They are useful to introduce custom + * dataTypes (see ajax/jsonp.js for an example) 2) These are + * called: - BEFORE asking for a transport - AFTER param + * serialization (s.data is a string if s.processData is + * true) 3) key is the dataType 4) the catchall symbol "*" + * can be used 5) execution will start with transport + * dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* + * Transports bindings 1) key is the dataType 2) the + * catchall symbol "*" can be used 3) selection will start + * with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (#10098); must appease + // lint and evade compression + allTypes = "*/".concat("*"), + + // Document location + ajaxLocation = location.href, + + // Segment location into parts + ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || []; + + // Base "constructor" for jQuery.ajaxPrefilter and + // jQuery.ajaxTransport + function addToPrefiltersOrTransports(structure) { + + // dataTypeExpression is optional and defaults to "*" + return function(dataTypeExpression, func) { + + if (typeof dataTypeExpression !== "string") { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || []; + + if (jQuery.isFunction(func)) { + + // For each dataType in the dataTypeExpression + while ((dataType = dataTypes[i++])) { + + // Prepend if requested + if (dataType.charAt(0) === "+") { + dataType = dataType.slice(1) || "*"; + (structure[dataType] = structure[dataType] || []).unshift(func); + + // Otherwise append + } else { + (structure[dataType] = structure[dataType] || []).push(func); + } + } + } + }; + } + + // Base inspection function for prefilters and transports + function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) { + + var inspected = {}, seekingTransport = (structure === transports); + + function inspect(dataType) { + var selected; + inspected[dataType] = true; + jQuery.each(structure[dataType] || [], function(_, prefilterOrFactory) { + var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR); + if (typeof dataTypeOrTransport === "string" && !seekingTransport + && !inspected[dataTypeOrTransport]) { + + options.dataTypes.unshift(dataTypeOrTransport); + inspect(dataTypeOrTransport); + return false; + } else if (seekingTransport) { + return !(selected = dataTypeOrTransport); + } + }); + return selected; + } + + return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*"); + } + + // A special extend for ajax options + // that takes "flat" options (not to be deep extended) + // Fixes #9887 + function ajaxExtend(target, src) { + var deep, key, flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for (key in src) { + if (src[key] !== undefined) { + (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key]; + } + } + if (deep) { + jQuery.extend(true, target, deep); + } + + return target; + } + + /* + * Handles responses to an ajax request: - finds the right + * dataType (mediates between content-type and expected + * dataType) - returns the corresponding response + */ + function ajaxHandleResponses(s, jqXHR, responses) { + var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the + // process + while (dataTypes[0] === "*") { + dataTypes.shift(); + if (ct === undefined) { + ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"); + } + } + + // Check if we're dealing with a known content-type + if (ct) { + for (type in contents) { + if (contents[type] && contents[type].test(ct)) { + dataTypes.unshift(type); + break; + } + } + } + + // Check to see if we have a response for the expected + // dataType + if (dataTypes[0] in responses) { + finalDataType = dataTypes[0]; + } else { + + // Try convertible dataTypes + for (type in responses) { + if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) { + finalDataType = type; + break; + } + if (!firstDataType) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if (finalDataType) { + if (finalDataType !== dataTypes[0]) { + dataTypes.unshift(finalDataType); + } + return responses[finalDataType]; + } + } + + /* + * Chain conversions given the request and the original + * response Also sets the responseXXX fields on the jqXHR + * instance + */ + function ajaxConvert(s, response, jqXHR, isSuccess) { + var conv2, current, conv, tmp, prev, converters = {}, + + // Work with a copy of dataTypes in case we need to + // modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if (dataTypes[1]) { + for (conv in s.converters) { + converters[conv.toLowerCase()] = s.converters[conv]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while (current) { + + if (s.responseFields[current]) { + jqXHR[s.responseFields[current]] = response; + } + + // Apply the dataFilter if provided + if (!prev && isSuccess && s.dataFilter) { + response = s.dataFilter(response, s.dataType); + } + + prev = current; + current = dataTypes.shift(); + + if (current) { + + // There's only work to do if current dataType + // is non-auto + if (current === "*") { + + current = prev; + + // Convert response if prev dataType is + // non-auto and differs from current + } else if (prev !== "*" && prev !== current) { + + // Seek a direct converter + conv = converters[prev + " " + current] || converters["* " + current]; + + // If none found, seek a pair + if (!conv) { + for (conv2 in converters) { + + // If conv2 outputs current + tmp = conv2.split(" "); + if (tmp[1] === current) { + + // If prev can be converted to + // accepted input + conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]]; + if (conv) { + + // Condense equivalence + // converters + if (conv === true) { + conv = converters[conv2]; + + // Otherwise, insert the + // intermediate dataType + } else if (converters[conv2] !== true) { + current = tmp[0]; + dataTypes.unshift(tmp[1]); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if (conv !== true) { + + // Unless errors are allowed to bubble, + // catch and return them + if (conv && s["throws"]) { // jscs:ignore + // requireDotNotation + response = conv(response); + } else { + try { + response = conv(response); + } catch (e) { + return { + state : "parsererror", + error : conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { + state : "success", + data : response + }; + } + + jQuery + .extend({ + + // Counter for holding the number of active + // queries + active : 0, + + // Last-Modified header cache for next request + lastModified : {}, + etag : {}, + + ajaxSettings : { + url : ajaxLocation, + type : "GET", + isLocal : rlocalProtocol.test(ajaxLocParts[1]), + global : true, + processData : true, + async : true, + contentType : "application/x-www-form-urlencoded; charset=UTF-8", + /* + * timeout: 0, data: null, dataType: null, + * username: null, password: null, cache: + * null, throws: false, traditional: false, + * headers: {}, + */ + + accepts : { + "*" : allTypes, + text : "text/plain", + html : "text/html", + xml : "application/xml, text/xml", + json : "application/json, text/javascript" + }, + + contents : { + xml : /\bxml\b/, + html : /\bhtml/, + json : /\bjson\b/ + }, + + responseFields : { + xml : "responseXML", + text : "responseText", + json : "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") + // and destination types with a single space + converters : { + + // Convert anything to text + "* text" : String, + + // Text to html (true = no + // transformation) + "text html" : true, + + // Evaluate text as a json expression + "text json" : jQuery.parseJSON, + + // Parse text as xml + "text xml" : jQuery.parseXML + }, + + // For options that shouldn't be deep + // extended: + // you can add your own custom options here + // if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions : { + url : true, + context : true + } + }, + + // Creates a full fledged settings object into + // target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into + // ajaxSettings. + ajaxSetup : function(target, settings) { + return settings ? + + // Building a settings object + ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : + + // Extending ajaxSettings + ajaxExtend(jQuery.ajaxSettings, target); + }, + + ajaxPrefilter : addToPrefiltersOrTransports(prefilters), + ajaxTransport : addToPrefiltersOrTransports(transports), + + // Main method + ajax : function(url, options) { + + // If url is an object, simulate pre-1.5 + // signature + if (typeof url === "object") { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var + + // Cross-domain detection vars + parts, + + // Loop variable + i, + + // URL without anti-cache param + cacheURL, + + // Response headers as string + responseHeadersString, + + // timeout handle + timeoutTimer, + + // To know if global events are to be + // dispatched + fireGlobals, + + transport, + + // Response headers + responseHeaders, + + // Create the final options object + s = jQuery.ajaxSetup({}, options), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is + // callbackContext if it is a DOM node or + // jQuery collection + globalEventContext = s.context + && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) + : jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks("once memory"), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, requestHeadersNames = {}, + + // The jqXHR state + state = 0, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState : 0, + + // Builds headers hashtable if needed + getResponseHeader : function(key) { + var match; + if (state === 2) { + if (!responseHeaders) { + responseHeaders = {}; + while ((match = rheaders.exec(responseHeadersString))) { + responseHeaders[match[1].toLowerCase()] = match[2]; + } + } + match = responseHeaders[key.toLowerCase()]; + } + return match == null ? null : match; + }, + + // Raw string + getAllResponseHeaders : function() { + return state === 2 ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader : function(name, value) { + var lname = name.toLowerCase(); + if (!state) { + name = requestHeadersNames[lname] = requestHeadersNames[lname] || name; + requestHeaders[name] = value; + } + return this; + }, + + // Overrides response content-type + // header + overrideMimeType : function(type) { + if (!state) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode : function(map) { + var code; + if (map) { + if (state < 2) { + for (code in map) { + + // Lazy-add the new + // callback in a way + // that preserves old + // ones + statusCode[code] = [ statusCode[code], map[code] ]; + } + } else { + + // Execute the appropriate + // callbacks + jqXHR.always(map[jqXHR.status]); + } + } + return this; + }, + + // Cancel the request + abort : function(statusText) { + var finalText = statusText || strAbort; + if (transport) { + transport.abort(finalText); + } + done(0, finalText); + return this; + } + }; + + // Attach deferreds + deferred.promise(jqXHR).complete = completeDeferred.add; + jqXHR.success = jqXHR.done; + jqXHR.error = jqXHR.fail; + + // Remove hash character (#7531: and string + // promotion) + // Add protocol if not provided (#5866: IE7 + // issue with protocol-less urls) + // Handle falsy url in the settings object + // (#10093: consistency with old signature) + // We also use the url parameter if + // available + s.url = ((url || s.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, + ajaxLocParts[1] + "//"); + + // Alias method option to type as per ticket + // #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(rnotwhite) + || [ "" ]; + + // A cross-domain request is in order when + // we have a protocol:host:port mismatch + if (s.crossDomain == null) { + parts = rurl.exec(s.url.toLowerCase()); + s.crossDomain = !!(parts && (parts[1] !== ajaxLocParts[1] + || parts[2] !== ajaxLocParts[2] || (parts[3] || (parts[1] === "http:" ? "80" + : "443")) !== (ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? "80" + : "443")))); + } + + // Convert data if not already a string + if (s.data && s.processData && typeof s.data !== "string") { + s.data = jQuery.param(s.data, s.traditional); + } + + // Apply prefilters + inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); + + // If request was aborted inside a + // prefilter, stop there + if (state === 2) { + return jqXHR; + } + + // We can fire global events as of now if + // asked to + // Don't fire events if jQuery.event is + // undefined in an AMD-usage scenario + // (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if (fireGlobals && jQuery.active++ === 0) { + jQuery.event.trigger("ajaxStart"); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test(s.type); + + // Save the URL in case we're toying with + // the If-Modified-Since + // and/or If-None-Match header later on + cacheURL = s.url; + + // More options handling for requests with + // no content + if (!s.hasContent) { + + // If data is available, append data to + // url + if (s.data) { + cacheURL = (s.url += (rquery.test(cacheURL) ? "&" : "?") + s.data); + + // #9682: remove data so that it's + // not used in an eventual retry + delete s.data; + } + + // Add anti-cache in url if needed + if (s.cache === false) { + s.url = rts.test(cacheURL) ? + + // If there is already a '_' + // parameter, set its value + cacheURL.replace(rts, "$1_=" + nonce++) : + + // Otherwise add one to the + // end + cacheURL + (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce++; + } + } + + // Set the If-Modified-Since and/or + // If-None-Match header, if in ifModified + // mode. + if (s.ifModified) { + if (jQuery.lastModified[cacheURL]) { + jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]); + } + if (jQuery.etag[cacheURL]) { + jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]); + } + } + + // Set the correct header, if data is being + // sent + if (s.data && s.hasContent && s.contentType !== false || options.contentType) { + jqXHR.setRequestHeader("Content-Type", s.contentType); + } + + // Set the Accepts header for the server, + // depending on the dataType + jqXHR.setRequestHeader("Accept", + s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") + : s.accepts["*"]); + + // Check for headers option + for (i in s.headers) { + jqXHR.setRequestHeader(i, s.headers[i]); + } + + // Allow custom headers/mimetypes and early + // abort + if (s.beforeSend + && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + for (i in { + success : 1, + error : 1, + complete : 1 + }) { + jqXHR[i](s[i]); + } + + // Get transport + transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); + + // If no transport, we auto-abort + if (!transport) { + done(-1, "No Transport"); + } else { + jqXHR.readyState = 1; + + // Send global event + if (fireGlobals) { + globalEventContext.trigger("ajaxSend", [ jqXHR, s ]); + } + + // If request was aborted inside + // ajaxSend, stop there + if (state === 2) { + return jqXHR; + } + + // Timeout + if (s.async && s.timeout > 0) { + timeoutTimer = window.setTimeout(function() { + jqXHR.abort("timeout"); + }, s.timeout); + } + + try { + state = 1; + transport.send(requestHeaders, done); + } catch (e) { + + // Propagate exception as error if + // not done + if (state < 2) { + done(-1, e); + + // Simply rethrow otherwise + } else { + throw e; + } + } + } + + // Callback for when everything is done + function done(status, nativeStatusText, responses, headers) { + var isSuccess, success, error, response, modified, statusText = nativeStatusText; + + // Called once + if (state === 2) { + return; + } + + // State is "done" now + state = 2; + + // Clear timeout if it exists + if (timeoutTimer) { + window.clearTimeout(timeoutTimer); + } + + // Dereference transport for early + // garbage collection + // (no matter how long the jqXHR object + // will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if (responses) { + response = ajaxHandleResponses(s, jqXHR, responses); + } + + // Convert no matter what (that way + // responseXXX fields are always set) + response = ajaxConvert(s, response, jqXHR, isSuccess); + + // If successful, handle type chaining + if (isSuccess) { + + // Set the If-Modified-Since and/or + // If-None-Match header, if in + // ifModified mode. + if (s.ifModified) { + modified = jqXHR.getResponseHeader("Last-Modified"); + if (modified) { + jQuery.lastModified[cacheURL] = modified; + } + modified = jqXHR.getResponseHeader("etag"); + if (modified) { + jQuery.etag[cacheURL] = modified; + } + } + + // if no content + if (status === 204 || s.type === "HEAD") { + statusText = "nocontent"; + + // if not modified + } else if (status === 304) { + statusText = "notmodified"; + + // If we have data, let's + // convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // We extract error from statusText + // then normalize statusText and + // status for non-aborts + error = statusText; + if (status || !statusText) { + statusText = "error"; + if (status < 0) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = (nativeStatusText || statusText) + ""; + + // Success/Error + if (isSuccess) { + deferred.resolveWith(callbackContext, [ success, statusText, jqXHR ]); + } else { + deferred.rejectWith(callbackContext, [ jqXHR, statusText, error ]); + } + + // Status-dependent callbacks + jqXHR.statusCode(statusCode); + statusCode = undefined; + + if (fireGlobals) { + globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [ + jqXHR, s, isSuccess ? success : error ]); + } + + // Complete + completeDeferred.fireWith(callbackContext, [ jqXHR, statusText ]); + + if (fireGlobals) { + globalEventContext.trigger("ajaxComplete", [ jqXHR, s ]); + + // Handle the global AJAX counter + if (!(--jQuery.active)) { + jQuery.event.trigger("ajaxStop"); + } + } + } + + return jqXHR; + }, + + getJSON : function(url, data, callback) { + return jQuery.get(url, data, callback, "json"); + }, + + getScript : function(url, callback) { + return jQuery.get(url, undefined, callback, "script"); + } + }); + + jQuery.each([ "get", "post" ], function(i, method) { + jQuery[method] = function(url, data, callback, type) { + + // shift arguments if data argument was omitted + if (jQuery.isFunction(data)) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must + // have .url) + return jQuery.ajax(jQuery.extend({ + url : url, + type : method, + dataType : type, + data : data, + success : callback + }, jQuery.isPlainObject(url) && url)); + }; + }); + + jQuery._evalUrl = function(url) { + return jQuery.ajax({ + url : url, + + // Make this explicit, since user can override this + // through ajaxSetup (#11264) + type : "GET", + dataType : "script", + cache : true, + async : false, + global : false, + "throws" : true + }); + }; + + jQuery.fn.extend({ + wrapAll : function(html) { + if (jQuery.isFunction(html)) { + return this.each(function(i) { + jQuery(this).wrapAll(html.call(this, i)); + }); + } + + if (this[0]) { + + // The elements to wrap the target + // around + var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true); + + if (this[0].parentNode) { + wrap.insertBefore(this[0]); + } + + wrap.map(function() { + var elem = this; + + while (elem.firstChild && elem.firstChild.nodeType === 1) { + elem = elem.firstChild; + } + + return elem; + }).append(this); + } + + return this; + }, + + wrapInner : function(html) { + if (jQuery.isFunction(html)) { + return this.each(function(i) { + jQuery(this).wrapInner(html.call(this, i)); + }); + } + + return this.each(function() { + var self = jQuery(this), contents = self.contents(); + + if (contents.length) { + contents.wrapAll(html); + + } else { + self.append(html); + } + }); + }, + + wrap : function(html) { + var isFunction = jQuery.isFunction(html); + + return this.each(function(i) { + jQuery(this).wrapAll(isFunction ? html.call(this, i) : html); + }); + }, + + unwrap : function() { + return this.parent().each(function() { + if (!jQuery.nodeName(this, "body")) { + jQuery(this).replaceWith(this.childNodes); + } + }).end(); + } + }); + + function getDisplay(elem) { + return elem.style && elem.style.display || jQuery.css(elem, "display"); + } + + function filterHidden(elem) { + + // Disconnected elements are considered hidden + if (!jQuery.contains(elem.ownerDocument || document, elem)) { + return true; + } + while (elem && elem.nodeType === 1) { + if (getDisplay(elem) === "none" || elem.type === "hidden") { + return true; + } + elem = elem.parentNode; + } + return false; + } + + jQuery.expr.filters.hidden = function(elem) { + + // Support: Opera <= 12.12 + // Opera reports offsetWidths and offsetHeights less + // than zero on some elements + return support.reliableHiddenOffsets() ? (elem.offsetWidth <= 0 && elem.offsetHeight <= 0 && !elem + .getClientRects().length) + : filterHidden(elem); + }; + + jQuery.expr.filters.visible = function(elem) { + return !jQuery.expr.filters.hidden(elem); + }; + + var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; + + function buildParams(prefix, obj, traditional, add) { + var name; + + if (jQuery.isArray(obj)) { + + // Serialize array item. + jQuery.each(obj, function(i, v) { + if (traditional || rbracket.test(prefix)) { + + // Treat each array item as a scalar. + add(prefix, v); + + } else { + + // Item is non-scalar (array or object), + // encode its numeric index. + buildParams(prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]", v, + traditional, add); + } + }); + + } else if (!traditional && jQuery.type(obj) === "object") { + + // Serialize object item. + for (name in obj) { + buildParams(prefix + "[" + name + "]", obj[name], traditional, add); + } + + } else { + + // Serialize scalar item. + add(prefix, obj); + } + } + + // Serialize an array of form elements or a set of + // key/values into a query string + jQuery.param = function(a, traditional) { + var prefix, s = [], add = function(key, value) { + + // If value is a function, invoke it and return its + // value + value = jQuery.isFunction(value) ? value() : (value == null ? "" : value); + s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value); + }; + + // Set traditional to true for jQuery <= 1.3.2 behavior. + if (traditional === undefined) { + traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; + } + + // If an array was passed in, assume that it is an array + // of form elements. + if (jQuery.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) { + + // Serialize the form elements + jQuery.each(a, function() { + add(this.name, this.value); + }); + + } else { + + // If traditional, encode the "old" way (the way + // 1.3.2 or older + // did it), otherwise encode params recursively. + for (prefix in a) { + buildParams(prefix, a[prefix], traditional, add); + } + } + + // Return the resulting serialization + return s.join("&").replace(r20, "+"); + }; + + jQuery.fn.extend({ + serialize : function() { + return jQuery.param(this.serializeArray()); + }, + serializeArray : function() { + return this.map(function() { + + // Can add propHook for + // "elements" to filter + // or add form elements + var elements = jQuery.prop(this, "elements"); + return elements ? jQuery.makeArray(elements) : this; + }).filter( + function() { + var type = this.type; + + // Use .is(":disabled") + // so that + // fieldset[disabled] + // works + return this.name && !jQuery(this).is(":disabled") + && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) + && (this.checked || !rcheckableType.test(type)); + }).map(function(i, elem) { + var val = jQuery(this).val(); + + return val == null ? null : jQuery.isArray(val) ? jQuery.map(val, function(val) { + return { + name : elem.name, + value : val.replace(rCRLF, "\r\n") + }; + }) : { + name : elem.name, + value : val.replace(rCRLF, "\r\n") + }; + }).get(); + } + }); + + // Create the request object + // (This is still attached to ajaxSettings for backward + // compatibility) + jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ? + + // Support: IE6-IE8 + function() { + + // XHR cannot access local files, always use ActiveX for + // that case + if (this.isLocal) { + return createActiveXHR(); + } + + // Support: IE 9-11 + // IE seems to error on cross-domain PATCH requests when + // ActiveX XHR + // is used. In IE 9+ always use the native XHR. + // Note: this condition won't catch Edge as it doesn't + // define + // document.documentMode but it also doesn't support + // ActiveX so it won't + // reach this code. + if (document.documentMode > 8) { + return createStandardXHR(); + } + + // Support: IE<9 + // oldIE XHR does not support non-RFC2616 methods + // (#13240) + // See + // http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx + // and + // http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 + // Although this check for six methods instead of eight + // since IE also does not support "trace" and "connect" + return /^(get|post|head|put|delete|options)$/i.test(this.type) && createStandardXHR() + || createActiveXHR(); + } : + + // For all other browsers, use the standard + // XMLHttpRequest object + createStandardXHR; + + var xhrId = 0, xhrCallbacks = {}, xhrSupported = jQuery.ajaxSettings.xhr(); + + // Support: IE<10 + // Open requests must be manually aborted on unload (#5280) + // See https://support.microsoft.com/kb/2856746 for more + // info + if (window.attachEvent) { + window.attachEvent("onunload", function() { + for ( var key in xhrCallbacks) { + xhrCallbacks[key](undefined, true); + } + }); + } + + // Determine support properties + support.cors = !!xhrSupported && ("withCredentials" in xhrSupported); + xhrSupported = support.ajax = !!xhrSupported; + + // Create transport if the browser can provide an xhr + if (xhrSupported) { + + jQuery.ajaxTransport(function(options) { + + // Cross domain only allowed if supported + // through XMLHttpRequest + if (!options.crossDomain || support.cors) { + + var callback; + + return { + send : function(headers, complete) { + var i, xhr = options.xhr(), id = ++xhrId; + + // Open the socket + xhr.open(options.type, options.url, options.async, options.username, + options.password); + + // Apply custom fields if + // provided + if (options.xhrFields) { + for (i in options.xhrFields) { + xhr[i] = options.xhrFields[i]; + } + } + + // Override mime type if needed + if (options.mimeType && xhr.overrideMimeType) { + xhr.overrideMimeType(options.mimeType); + } + + // X-Requested-With header + // For cross-domain requests, + // seeing as conditions for a + // preflight are + // akin to a jigsaw puzzle, we + // simply never set it to be + // sure. + // (it can always be set on a + // per-request basis or even + // using ajaxSetup) + // For same-domain requests, + // won't change header if + // already provided. + if (!options.crossDomain && !headers["X-Requested-With"]) { + headers["X-Requested-With"] = "XMLHttpRequest"; + } + + // Set headers + for (i in headers) { + + // Support: IE<9 + // IE's ActiveXObject throws + // a 'Type Mismatch' + // exception when setting + // request header to a + // null-value. + // + // To keep consistent with + // other XHR + // implementations, cast the + // value + // to string and ignore + // `undefined`. + if (headers[i] !== undefined) { + xhr.setRequestHeader(i, headers[i] + ""); + } + } + + // Do send the request + // This may raise an exception + // which is actually + // handled in jQuery.ajax (so no + // try/catch here) + xhr.send((options.hasContent && options.data) || null); + + // Listener + callback = function(_, isAbort) { + var status, statusText, responses; + + // Was never called and is + // aborted or complete + if (callback && (isAbort || xhr.readyState === 4)) { + + // Clean up + delete xhrCallbacks[id]; + callback = undefined; + xhr.onreadystatechange = jQuery.noop; + + // Abort manually if + // needed + if (isAbort) { + if (xhr.readyState !== 4) { + xhr.abort(); + } + } else { + responses = {}; + status = xhr.status; + + // Support: IE<10 + // Accessing + // binary-data + // responseText + // throws an + // exception + // (#11426) + if (typeof xhr.responseText === "string") { + responses.text = xhr.responseText; + } + + // Firefox throws an + // exception when + // accessing + // statusText for + // faulty + // cross-domain + // requests + try { + statusText = xhr.statusText; + } catch (e) { + + // We normalize + // with Webkit + // giving an + // empty + // statusText + statusText = ""; + } + + // Filter status for + // non standard + // behaviors + + // If the request is + // local and we have + // data: assume a + // success + // (success with no + // data won't get + // notified, that's + // the best we + // can do given + // current + // implementations) + if (!status && options.isLocal && !options.crossDomain) { + status = responses.text ? 200 : 404; + + // IE - #1450: + // sometimes + // returns 1223 + // when it + // should be 204 + } else if (status === 1223) { + status = 204; + } + } + } + + // Call complete if needed + if (responses) { + complete(status, statusText, responses, xhr.getAllResponseHeaders()); + } + }; + + // Do send the request + // `xhr.send` may raise an + // exception, but it will be + // handled in jQuery.ajax (so no + // try/catch here) + if (!options.async) { + + // If we're in sync mode we + // fire the callback + callback(); + } else if (xhr.readyState === 4) { + + // (IE6 & IE7) if it's in + // cache and has been + // retrieved directly we + // need to fire the callback + window.setTimeout(callback); + } else { + + // Register the callback, + // but delay it in case + // `xhr.send` throws + // Add to the list of active + // xhr callbacks + xhr.onreadystatechange = xhrCallbacks[id] = callback; + } + }, + + abort : function() { + if (callback) { + callback(undefined, true); + } + } + }; + } + }); + } + + // Functions to create xhrs + function createStandardXHR() { + try { + return new window.XMLHttpRequest(); + } catch (e) { + } + } + + function createActiveXHR() { + try { + return new window.ActiveXObject("Microsoft.XMLHTTP"); + } catch (e) { + } + } + + // Install script dataType + jQuery.ajaxSetup({ + accepts : { + script : "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents : { + script : /\b(?:java|ecma)script\b/ + }, + converters : { + "text script" : function(text) { + jQuery.globalEval(text); + return text; + } + } + }); + + // Handle cache's special case and global + jQuery.ajaxPrefilter("script", function(s) { + if (s.cache === undefined) { + s.cache = false; + } + if (s.crossDomain) { + s.type = "GET"; + s.global = false; + } + }); + + // Bind script tag hack transport + jQuery.ajaxTransport("script", + function(s) { + + // This transport only deals with cross + // domain requests + if (s.crossDomain) { + + var script, head = document.head || jQuery("head")[0] || document.documentElement; + + return { + + send : function(_, callback) { + + script = document.createElement("script"); + + script.async = true; + + if (s.scriptCharset) { + script.charset = s.scriptCharset; + } + + script.src = s.url; + + // Attach handlers for all + // browsers + script.onload = script.onreadystatechange = function(_, isAbort) { + + if (isAbort || !script.readyState + || /loaded|complete/.test(script.readyState)) { + + // Handle memory + // leak in IE + script.onload = script.onreadystatechange = null; + + // Remove the script + if (script.parentNode) { + script.parentNode.removeChild(script); + } + + // Dereference the + // script + script = null; + + // Callback if not + // abort + if (!isAbort) { + callback(200, "success"); + } + } + }; + + // Circumvent IE6 bugs with + // base elements (#2709 and + // #4378) by prepending + // Use native DOM + // manipulation to avoid our + // domManip AJAX trickery + head.insertBefore(script, head.firstChild); + }, + + abort : function() { + if (script) { + script.onload(undefined, true); + } + } + }; + } + }); + + var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/; + + // Default jsonp settings + jQuery.ajaxSetup({ + jsonp : "callback", + jsonpCallback : function() { + var callback = oldCallbacks.pop() || (jQuery.expando + "_" + (nonce++)); + this[callback] = true; + return callback; + } + }); + + // Detect, normalize options and install callbacks for jsonp + // requests + jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) { + + var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false + && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" + && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 + && rjsonp.test(s.data) && "data"); + + // Handle iff the expected data type is + // "jsonp" or we have a parameter to set + if (jsonProp || s.dataTypes[0] === "jsonp") { + + // Get callback name, remembering + // preexisting value associated with + // it + callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() + : s.jsonpCallback; + + // Insert callback into url or form + // data + if (jsonProp) { + s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName); + } else if (s.jsonp !== false) { + s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName; + } + + // Use data converter to retrieve + // json after script execution + s.converters["script json"] = function() { + if (!responseContainer) { + jQuery.error(callbackName + " was not called"); + } + return responseContainer[0]; + }; + + // force json dataType + s.dataTypes[0] = "json"; + + // Install callback + overwritten = window[callbackName]; + window[callbackName] = function() { + responseContainer = arguments; + }; + + // Clean-up function (fires after + // converters) + jqXHR.always(function() { + + // If previous value + // didn't exist - remove + // it + if (overwritten === undefined) { + jQuery(window).removeProp(callbackName); + + // Otherwise restore + // preexisting value + } else { + window[callbackName] = overwritten; + } + + // Save back as free + if (s[callbackName]) { + + // make sure that + // re-using the + // options doesn't + // screw things + // around + s.jsonpCallback = originalSettings.jsonpCallback; + + // save the callback + // name for future + // use + oldCallbacks.push(callbackName); + } + + // Call if it was a + // function and we have + // a response + if (responseContainer && jQuery.isFunction(overwritten)) { + overwritten(responseContainer[0]); + } + + responseContainer = overwritten = undefined; + }); + + // Delegate to script + return "script"; + } + }); + + // data: string of html + // context (optional): If specified, the fragment will be + // created in this context, + // defaults to document + // keepScripts (optional): If true, will include scripts + // passed in the html string + jQuery.parseHTML = function(data, context, keepScripts) { + if (!data || typeof data !== "string") { + return null; + } + if (typeof context === "boolean") { + keepScripts = context; + context = false; + } + context = context || document; + + var parsed = rsingleTag.exec(data), scripts = !keepScripts && []; + + // Single tag + if (parsed) { + return [ context.createElement(parsed[1]) ]; + } + + parsed = buildFragment([ data ], context, scripts); + + if (scripts && scripts.length) { + jQuery(scripts).remove(); + } + + return jQuery.merge([], parsed.childNodes); + }; + + // Keep a copy of the old load method + var _load = jQuery.fn.load; + + /** + * Load a url into a page + */ + jQuery.fn.load = function(url, params, callback) { + if (typeof url !== "string" && _load) { + return _load.apply(this, arguments); + } + + var selector, type, response, self = this, off = url.indexOf(" "); + + if (off > -1) { + selector = jQuery.trim(url.slice(off, url.length)); + url = url.slice(0, off); + } + + // If it's a function + if (jQuery.isFunction(params)) { + + // We assume that it's the callback + callback = params; + params = undefined; + + // Otherwise, build a param string + } else if (params && typeof params === "object") { + type = "POST"; + } + + // If we have elements to modify, make the request + if (self.length > 0) { + jQuery.ajax({ + url : url, + + // If "type" variable is undefined, then + // "GET" method will be used. + // Make value of this field explicit + // since + // user can override it through + // ajaxSetup method + type : type || "GET", + dataType : "html", + data : params + }).done(function(responseText) { + + // Save response for use in + // complete callback + response = arguments; + + self.html(selector ? + + // If a selector was + // specified, locate the + // right elements in a + // dummy div + // Exclude scripts to + // avoid IE 'Permission + // Denied' errors + jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : + + // Otherwise use + // the full + // result + responseText); + + // If the request succeeds, this + // function gets "data", + // "status", "jqXHR" + // but they are ignored because + // response was set above. + // If it fails, this function + // gets "jqXHR", "status", + // "error" + }).always(callback && function(jqXHR, status) { + self.each(function() { + callback.apply(this, response || [ jqXHR.responseText, status, jqXHR ]); + }); + }); + } + + return this; + }; + + // Attach a bunch of functions for handling common AJAX + // events + jQuery.each([ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], + function(i, type) { + jQuery.fn[type] = function(fn) { + return this.on(type, fn); + }; + }); + + jQuery.expr.filters.animated = function(elem) { + return jQuery.grep(jQuery.timers, function(fn) { + return elem === fn.elem; + }).length; + }; + + /** + * Gets a window from an element + */ + function getWindow(elem) { + return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 ? elem.defaultView + || elem.parentWindow : false; + } + + jQuery.offset = { + setOffset : function(elem, options, i) { + var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery + .css(elem, "position"), curElem = jQuery(elem), props = {}; + + // set position first, in-case top/left are set even + // on static elem + if (position === "static") { + elem.style.position = "relative"; + } + + curOffset = curElem.offset(); + curCSSTop = jQuery.css(elem, "top"); + curCSSLeft = jQuery.css(elem, "left"); + calculatePosition = (position === "absolute" || position === "fixed") + && jQuery.inArray("auto", [ curCSSTop, curCSSLeft ]) > -1; + + // need to be able to calculate position if either + // top or left + // is auto and position is either absolute or fixed + if (calculatePosition) { + curPosition = curElem.position(); + curTop = curPosition.top; + curLeft = curPosition.left; + } else { + curTop = parseFloat(curCSSTop) || 0; + curLeft = parseFloat(curCSSLeft) || 0; + } + + if (jQuery.isFunction(options)) { + + // Use jQuery.extend here to allow modification + // of coordinates argument (gh-1848) + options = options.call(elem, i, jQuery.extend({}, curOffset)); + } + + if (options.top != null) { + props.top = (options.top - curOffset.top) + curTop; + } + if (options.left != null) { + props.left = (options.left - curOffset.left) + curLeft; + } + + if ("using" in options) { + options.using.call(elem, props); + } else { + curElem.css(props); + } + } + }; + + jQuery.fn.extend({ + offset : function(options) { + if (arguments.length) { + return options === undefined ? this : this.each(function(i) { + jQuery.offset.setOffset(this, options, i); + }); + } + + var docElem, win, box = { + top : 0, + left : 0 + }, elem = this[0], doc = elem && elem.ownerDocument; + + if (!doc) { + return; + } + + docElem = doc.documentElement; + + // Make sure it's not a disconnected DOM + // node + if (!jQuery.contains(docElem, elem)) { + return box; + } + + // If we don't have gBCR, just use 0,0 + // rather than error + // BlackBerry 5, iOS 3 (original iPhone) + if (typeof elem.getBoundingClientRect !== "undefined") { + box = elem.getBoundingClientRect(); + } + win = getWindow(doc); + return { + top : box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0), + left : box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0) + }; + }, + + position : function() { + if (!this[0]) { + return; + } + + var offsetParent, offset, parentOffset = { + top : 0, + left : 0 + }, elem = this[0]; + + // Fixed elements are offset from window + // (parentOffset = {top:0, left: 0}, + // because it is its only offset parent + if (jQuery.css(elem, "position") === "fixed") { + + // we assume that getBoundingClientRect + // is available when computed position + // is fixed + offset = elem.getBoundingClientRect(); + } else { + + // Get *real* offsetParent + offsetParent = this.offsetParent(); + + // Get correct offsets + offset = this.offset(); + if (!jQuery.nodeName(offsetParent[0], "html")) { + parentOffset = offsetParent.offset(); + } + + // Add offsetParent borders + parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true); + parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true); + } + + // Subtract parent offsets and element + // margins + // note: when an element has margin: auto + // the offsetLeft and marginLeft + // are the same in Safari causing + // offset.left to incorrectly be 0 + return { + top : offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true), + left : offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true) + }; + }, + + offsetParent : function() { + return this.map(function() { + var offsetParent = this.offsetParent; + + while (offsetParent + && (!jQuery.nodeName(offsetParent, "html") && jQuery.css(offsetParent, + "position") === "static")) { + offsetParent = offsetParent.offsetParent; + } + return offsetParent || documentElement; + }); + } + }); + + // Create scrollLeft and scrollTop methods + jQuery.each({ + scrollLeft : "pageXOffset", + scrollTop : "pageYOffset" + }, function(method, prop) { + var top = /Y/.test(prop); + + jQuery.fn[method] = function(val) { + return access(this, function(elem, method, val) { + var win = getWindow(elem); + + if (val === undefined) { + return win ? (prop in win) ? win[prop] : win.document.documentElement[method] + : elem[method]; + } + + if (win) { + win.scrollTo(!top ? val : jQuery(win).scrollLeft(), top ? val : jQuery(win) + .scrollTop()); + + } else { + elem[method] = val; + } + }, method, val, arguments.length, null); + }; + }); + + // Support: Safari<7-8+, Chrome<37-44+ + // Add the top/left cssHooks using jQuery.fn.position + // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 + // getComputedStyle returns percent when specified for + // top/left/bottom/right + // rather than make the css module depend on the offset + // module, we just check for it here + jQuery.each([ "top", "left" ], function(i, prop) { + jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, computed) { + if (computed) { + computed = curCSS(elem, prop); + + // if curCSS returns + // percentage, fallback + // to offset + return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed; + } + }); + }); + + // Create innerHeight, innerWidth, height, width, + // outerHeight and outerWidth methods + jQuery.each({ + Height : "height", + Width : "width" + }, function(name, type) { + jQuery.each({ + padding : "inner" + name, + content : type, + "" : "outer" + name + }, + function(defaultExtra, funcName) { + + // margin is only + // for outerHeight, + // outerWidth + jQuery.fn[funcName] = function(margin, value) { + var chainable = arguments.length + && (defaultExtra || typeof margin !== "boolean"), extra = defaultExtra + || (margin === true || value === true ? "margin" : "border"); + + return access(this, function(elem, type, value) { + var doc; + + if (jQuery.isWindow(elem)) { + + // As + // of + // 5/8/2012 + // this + // will + // yield + // incorrect + // results + // for + // Mobile + // Safari, + // but + // there + // isn't + // a + // whole + // lot + // we + // can + // do. + // See + // pull + // request + // at + // this + // URL + // for + // discussion: + // https://github.com/jquery/jquery/pull/764 + return elem.document.documentElement["client" + name]; + } + + // Get + // document + // width + // or + // height + if (elem.nodeType === 9) { + doc = elem.documentElement; + + // Either + // scroll[Width/Height] + // or + // offset[Width/Height] + // or + // client[Width/Height], + // whichever + // is + // greatest + // unfortunately, + // this + // causes + // bug + // #3838 + // in + // IE6/8 + // only, + // but + // there + // is + // currently + // no + // good, + // small + // way + // to + // fix + // it. + return Math.max(elem.body["scroll" + name], doc["scroll" + name], + elem.body["offset" + name], doc["offset" + name], doc["client" + + name]); + } + + return value === undefined ? + + // Get + // width + // or + // height + // on + // the + // element, + // requesting + // but + // not + // forcing + // parseFloat + jQuery.css(elem, type, extra) : + + // Set + // width + // or + // height + // on + // the + // element + jQuery.style(elem, type, value, extra); + }, type, chainable ? margin : undefined, chainable, null); + }; + }); + }); + + jQuery.fn.extend({ + + bind : function(types, data, fn) { + return this.on(types, null, data, fn); + }, + unbind : function(types, fn) { + return this.off(types, null, fn); + }, + + delegate : function(selector, types, data, fn) { + return this.on(types, selector, data, fn); + }, + undelegate : function(selector, types, fn) { + + // ( namespace ) or ( selector, types [, fn] ) + return arguments.length === 1 ? this.off(selector, "**") : this.off(types, + selector || "**", fn); + } + }); + + // The number of elements contained in the matched element + // set + jQuery.fn.size = function() { + return this.length; + }; + + jQuery.fn.andSelf = jQuery.fn.addBack; + + // Register as a named AMD module, since jQuery can be + // concatenated with other + // files that may use define, but not via a proper + // concatenation script that + // understands anonymous AMD modules. A named AMD is safest + // and most robust + // way to register. Lowercase jquery is used because AMD + // module names are + // derived from file names, and jQuery is normally delivered + // in a lowercase + // file name. Do this after creating the global so that if + // an AMD module wants + // to call noConflict to hide this version of jQuery, it + // will work. + + // Note that for maximum portability, libraries that are not + // jQuery should + // declare themselves as anonymous modules, and avoid + // setting a global if an + // AMD loader is present. jQuery is a special case. For more + // information, see + // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon + + if (typeof define === "function" && define.amd) { + define("jquery", [], function() { + return jQuery; + }); + } + + var + + // Map over jQuery in case of overwrite + _jQuery = window.jQuery, + + // Map over the $ in case of overwrite + _$ = window.$; + + jQuery.noConflict = function(deep) { + if (window.$ === jQuery) { + window.$ = _$; + } + + if (deep && window.jQuery === jQuery) { + window.jQuery = _jQuery; + } + + return jQuery; + }; + + // Expose jQuery and $ identifiers, even in + // AMD (#7102#comment:10, + // https://github.com/jquery/jquery/pull/557) + // and CommonJS for browser emulators (#13566) + if (!noGlobal) { + window.jQuery = window.$ = jQuery; + } + + return jQuery; + })); diff --git a/client/client-deployment/pom.xml b/client/client-deployment/pom.xml new file mode 100644 index 000000000..f4ecfe7af --- /dev/null +++ b/client/client-deployment/pom.xml @@ -0,0 +1,191 @@ +<!-- + ============LICENSE_START======================================================= + Copyright (C) 2018 Ericsson. All rights reserved. + ================================================================================ + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + SPDX-License-Identifier: Apache-2.0 + ============LICENSE_END========================================================= +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.onap.policy.apex-pdp.client</groupId> + <artifactId>client</artifactId> + <version>2.0.0-SNAPSHOT</version> + </parent> + + <artifactId>client-deployment</artifactId> + <name>${project.artifactId}</name> + <description>Web client for deploying models in Apex engine</description> + + <dependencies> + <dependency> + <groupId>org.onap.policy.apex-pdp.core</groupId> + <artifactId>core-deployment</artifactId> + <version>${project.version}</version> + </dependency> + <dependency> + <groupId>org.onap.policy.apex-pdp.client</groupId> + <artifactId>client-common</artifactId> + <version>${project.version}</version> + <classifier>resources</classifier> + <type>zip</type> + <scope>provided</scope> + </dependency> + <dependency> + <groupId>org.glassfish.jersey.containers</groupId> + <artifactId>jersey-container-grizzly2-http</artifactId> + <version>${version.jersey}</version> + </dependency> + <dependency> + <groupId>org.glassfish.jersey.media</groupId> + <artifactId>jersey-media-multipart</artifactId> + <version>${version.jersey}</version> + </dependency> + <dependency> + <groupId>org.glassfish.jersey.containers</groupId> + <artifactId>jersey-container-servlet-core</artifactId> + <version>${version.jersey}</version> + </dependency> + <dependency> + <groupId>org.glassfish.jersey.inject</groupId> + <artifactId>jersey-hk2</artifactId> + <version>${version.jersey}</version> + </dependency> + <dependency> + <groupId>commons-cli</groupId> + <artifactId>commons-cli</artifactId> + <version>${version.commons-cli}</version> + </dependency> + </dependencies> + + <build> + <defaultGoal>install</defaultGoal> + <outputDirectory>${project.build.directory}/classes</outputDirectory> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-dependency-plugin</artifactId> + <executions> + <execution> + <id>unpack-client-deployment-shared-resources</id> + <goals> + <goal>unpack-dependencies</goal> + </goals> + <phase>generate-resources</phase> + <configuration> + <outputDirectory>${project.build.directory}/${project.artifactId}-${project.version}</outputDirectory> + <includeArtifacIds>client-common</includeArtifacIds> + <includeGroupIds>${project.groupId}</includeGroupIds> + <excludeTransitive>true</excludeTransitive> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-shade-plugin</artifactId> + <executions> + <execution> + <phase>package</phase> + <goals> + <goal>shade</goal> + </goals> + </execution> + </executions> + <configuration> + <finalName>${project.artifactId}-uber-${project.version}</finalName> + <shadedArtifactAttached>true</shadedArtifactAttached> + <shadedClassifierName>deployment</shadedClassifierName> + <artifactSet> + <includes> + <include>*:*</include> + </includes> + </artifactSet> + <filters> + <filter> + <artifact>*:*</artifact> + <excludes> + <exclude>META-INF/*.SF</exclude> + <exclude>META-INF/*.DSA</exclude> + <exclude>META-INF/*.RSA</exclude> + </excludes> + </filter> + </filters> + <transformers> + <transformer + implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" /> + <transformer + implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer"> + <resource>reference.conf</resource> + </transformer> + <transformer + implementation="org.apache.maven.plugins.shade.resource.DontIncludeResourceTransformer"> + <resource>log4j.properties</resource> + </transformer> + <transformer + implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> + <mainClass>org.onap.policy.apex.client.deployment.rest.ApexDeploymentRestMain</mainClass> + </transformer> + </transformers> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-war-plugin</artifactId> + <version>2.6</version> + <configuration> + <classifier>ui</classifier> + <warSourceDirectory>src/main/resources/webapp</warSourceDirectory> + <webXml>src/main/resources/webapp/WEB-INF/web.xml</webXml> + </configuration> + <executions> + <execution> + <phase>prepare-package</phase> + <goals> + <goal>war</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>build-helper-maven-plugin</artifactId> + <version>3.0.0</version> + <executions> + <execution> + <id>attach-artifacts</id> + <phase>package</phase> + <goals> + <goal>attach-artifact</goal> + </goals> + <configuration> + <artifacts> + <artifact> + <file>${project.build.directory}/${project.artifactId}-${project.version}-ui.war</file> + <type>war</type> + </artifact> + <artifact> + <file>${project.build.directory}/${project.artifactId}-uber-${project.version}.jar</file> + <type>uber.jar</type> + </artifact> + </artifacts> + </configuration> + </execution> + </executions> + </plugin> + </plugins> + </build> +</project>
\ No newline at end of file diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRest.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRest.java new file mode 100644 index 000000000..b6ed37d80 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRest.java @@ -0,0 +1,84 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import org.glassfish.grizzly.http.server.HttpServer; +import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; +import org.glassfish.jersey.media.multipart.MultiPartFeature; +import org.glassfish.jersey.server.ResourceConfig; +import org.onap.policy.apex.model.utilities.Assertions; +import org.slf4j.ext.XLogger; +import org.slf4j.ext.XLoggerFactory; + +/** + * This class is used to launch the services. It creates a Grizzly embedded web server and runs the services. + */ +public class ApexDeploymentRest { + // Logger for this class + private static final XLogger logger = XLoggerFactory.getXLogger(ApexDeploymentRest.class); + + // The HTTP server exposing JAX-RS resources defined in this application. + private HttpServer server; + + /** + * Starts the HTTP server for the Apex services client on the default base URI and with the default REST packages + */ + public ApexDeploymentRest() { + this(new ApexDeploymentRestParameters()); + } + + /** + * Starts the HTTP server for the Apex services client + * + * @param parameters: The Apex parameters to use to start the server + */ + public ApexDeploymentRest(final ApexDeploymentRestParameters parameters) { + Assertions.argumentNotNull(parameters, "parameters may not be null"); + + logger.debug("Apex services RESTful client starting . . ."); + + // Create a resource configuration that scans for JAX-RS resources and providers + // in org.onap.policy.apex.client.deployment.rest package + final ResourceConfig rc = new ResourceConfig().packages(parameters.getRESTPackages()); + + // Add MultiPartFeature class for jersey-media-multipart + rc.register(MultiPartFeature.class); + + // create and start a new instance of grizzly http server + // exposing the Jersey application at BASE_URI + server = GrizzlyHttpServerFactory.createHttpServer(parameters.getBaseURI(), rc); + + // Add static content + server.getServerConfiguration().addHttpHandler(new org.glassfish.grizzly.http.server.CLStaticHttpHandler( + ApexDeploymentRestMain.class.getClassLoader(), "/webapp/"), parameters.getStaticPath()); + + logger.debug("Apex services RESTful client started"); + } + + /** + * Shut down the web server + */ + public void shutdown() { + logger.debug("Apex services RESTful client shutting down . . ."); + server.shutdown(); + logger.debug("Apex services RESTful client shut down"); + } +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestMain.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestMain.java new file mode 100644 index 000000000..6e7220487 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestMain.java @@ -0,0 +1,192 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import java.io.PrintStream; + +/** + * User: ewatkmi Date: 31 Jul 2017 + */ +public class ApexDeploymentRestMain { + // Services state + public enum ServicesState { + STOPPED, READY, INITIALIZING, RUNNING + }; + + private ServicesState state = ServicesState.STOPPED; + + // The parameters for the client + private ApexDeploymentRestParameters parameters = null; + + // Output and error streams for messages + private final PrintStream outStream; + + // The Apex services client this class is running + private ApexDeploymentRest apexDeploymentRest = null; + + /** + * Main method, main entry point for command + * + * @param args The command line arguments for the client + */ + public static void main(final String[] args) { + try { + final ApexDeploymentRestMain restMain = new ApexDeploymentRestMain(args, System.out); + restMain.init(); + } catch (final Exception e) { + System.err.println(e.getMessage()); + } + } + + /** + * Constructor, kicks off the rest service + * + * @param args The command line arguments for the RESTful service + * @param outStream The stream for output messages + */ + public ApexDeploymentRestMain(final String[] args, final PrintStream outStream) { + // Save the streams for output and error + this.outStream = outStream; + + // Client parameter parsing + final ApexDeploymentRestParameterParser parser = new ApexDeploymentRestParameterParser(); + + try { + // Get and check the parameters + parameters = parser.parse(args); + } catch (final ApexDeploymentRestParameterException e) { + throw new ApexDeploymentRestParameterException( + "Apex Services REST endpoint (" + this.toString() + ") parameter error, " + e.getMessage() + '\n' + + parser.getHelp(ApexDeploymentRestMain.class.getCanonicalName())); + } + + if (parameters.isHelpSet()) { + throw new ApexDeploymentRestParameterException( + parser.getHelp(ApexDeploymentRestMain.class.getCanonicalName())); + } + + // Validate the parameters + final String validationMessage = parameters.validate(); + if (validationMessage.length() > 0) { + throw new ApexDeploymentRestParameterException( + "Apex Services REST endpoint (" + this.toString() + ") parameters invalid, " + validationMessage + + '\n' + parser.getHelp(ApexDeploymentRestMain.class.getCanonicalName())); + } + + state = ServicesState.READY; + } + + /** + * Initialize the rest service + */ + public void init() { + outStream.println("Apex Services REST endpoint (" + this.toString() + ") starting at " + + parameters.getBaseURI().toString() + " . . ."); + + try { + state = ServicesState.INITIALIZING; + + // Start the REST service + apexDeploymentRest = new ApexDeploymentRest(parameters); + + // Add a shutdown hook to shut down the rest services when the process is exiting + Runtime.getRuntime().addShutdownHook(new Thread(new ApexServicesShutdownHook())); + + state = ServicesState.RUNNING; + + if (parameters.getTimeToLive() == ApexDeploymentRestParameters.INFINITY_TIME_TO_LIVE) { + outStream.println("Apex Services REST endpoint (" + this.toString() + ") started at " + + parameters.getBaseURI().toString()); + } else { + outStream.println("Apex Services REST endpoint (" + this.toString() + ") started"); + } + + // Find out how long is left to wait + long timeRemaining = parameters.getTimeToLive(); + while (timeRemaining == ApexDeploymentRestParameters.INFINITY_TIME_TO_LIVE || timeRemaining > 0) { + // decrement the time to live in the non-infinity case + if (timeRemaining > 0) { + timeRemaining--; + } + + // Wait for a second + Thread.sleep(1000); + } + } catch (final Exception e) { + outStream.println( + "Apex Services REST endpoint (" + this.toString() + ") failed at with error: " + e.getMessage()); + } finally { + if (apexDeploymentRest != null) { + apexDeploymentRest.shutdown(); + apexDeploymentRest = null; + } + state = ServicesState.STOPPED; + } + + } + + /** + * Get services state. + * + * @return the service state + */ + public ServicesState getState() { + return state; + } + + @Override + public String toString() { + final StringBuilder ret = new StringBuilder(); + ret.append(this.getClass().getSimpleName()).append(": Config=[").append(this.parameters).append("], State=") + .append(this.getState()); + return ret.toString(); + } + + /** + * Explicitly shut down the services + */ + public void shutdown() { + if (apexDeploymentRest != null) { + outStream.println("Apex Services REST endpoint (" + this.toString() + ") shutting down"); + apexDeploymentRest.shutdown(); + } + state = ServicesState.STOPPED; + outStream.println("Apex Services REST endpoint (" + this.toString() + ") shut down"); + } + + /** + * This class is a shutdown hook for the Apex services command + */ + private class ApexServicesShutdownHook implements Runnable { + /* + * (non-Javadoc) + * + * @see java.lang.Runnable#run() + */ + @Override + public void run() { + if (apexDeploymentRest != null) { + apexDeploymentRest.shutdown(); + } + } + } + +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterException.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterException.java new file mode 100644 index 000000000..87785b7f3 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterException.java @@ -0,0 +1,49 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +/** + * A run time exception used to report parsing and parameter input errors. + * + * User: ewatkmi Date: 31 Jul 2017 + */ +public class ApexDeploymentRestParameterException extends IllegalArgumentException { + private static final long serialVersionUID = 6520231162404452427L; + + /** + * Create an ApexServicesRestParameterException with a message + * + * @param message the message + */ + public ApexDeploymentRestParameterException(final String message) { + super(message); + } + + /** + * Create an ApexServicesRestParameterException with a message and an exception. + * + * @param message the message + * @param throwable The exception that caused the exception + */ + public ApexDeploymentRestParameterException(final String message, final Throwable throwable) { + super(message, throwable); + } +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterParser.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterParser.java new file mode 100644 index 000000000..35ad9cdde --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameterParser.java @@ -0,0 +1,116 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Arrays; + +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.DefaultParser; +import org.apache.commons.cli.HelpFormatter; +import org.apache.commons.cli.Option; +import org.apache.commons.cli.Options; +import org.apache.commons.cli.ParseException; + +/** + * This class reads and handles command line parameters to the Apex RESTful services + * + * User: ewatkmi Date: 31 Jul 2017 + */ +public class ApexDeploymentRestParameterParser { + // Apache Commons CLI options + Options options; + + /** + * Construct the options for the CLI RESTful services + */ + public ApexDeploymentRestParameterParser() { + options = new Options(); + options.addOption("h", "help", false, "outputs the usage of this command"); + options.addOption(Option.builder("p").longOpt("port").desc("port to use for the Apex Services REST calls") + .hasArg().argName("PORT").required(false).type(Number.class).build()); + options.addOption(Option.builder("t").longOpt("time-to-live") + .desc("the amount of time in seconds that the server will run for before terminating").hasArg() + .argName("TIME_TO_LIVE").required(false).type(Number.class).build()); + } + + /** + * Parse the command line options + * + * @param args the arguments + * @return the parsed arguments + */ + public ApexDeploymentRestParameters parse(final String[] args) { + CommandLine commandLine = null; + try { + commandLine = new DefaultParser().parse(options, args); + } catch (final ParseException e) { + throw new ApexDeploymentRestParameterException( + "invalid command line arguments specified : " + e.getMessage()); + } + + final ApexDeploymentRestParameters parameters = new ApexDeploymentRestParameters(); + final String[] remainingArgs = commandLine.getArgs(); + + if (commandLine.getArgs().length > 0) { + throw new ApexDeploymentRestParameterException( + "too many command line arguments specified : " + Arrays.toString(remainingArgs)); + } + + if (commandLine.hasOption('h')) { + parameters.setHelp(true); + } + try { + if (commandLine.hasOption('p')) { + parameters.setRESTPort(((Number) commandLine.getParsedOptionValue("port")).intValue()); + } + } catch (final ParseException e) { + throw new ApexDeploymentRestParameterException("error parsing argument \"port\" :" + e.getMessage(), e); + } + try { + if (commandLine.hasOption('t')) { + parameters.setTimeToLive(((Number) commandLine.getParsedOptionValue("time-to-live")).longValue()); + } + } catch (final ParseException e) { + throw new ApexDeploymentRestParameterException("error parsing argument \"time-to-live\" :" + e.getMessage(), + e); + } + + return parameters; + } + + /** + * Get help information + * + * @param mainClassName the main class name for the help output + * @return help string + */ + public String getHelp(final String mainClassName) { + final StringWriter stringWriter = new StringWriter(); + final PrintWriter stringPrintWriter = new PrintWriter(stringWriter); + + final HelpFormatter helpFormatter = new HelpFormatter(); + helpFormatter.printHelp(stringPrintWriter, 120, mainClassName + " [options...] ", "", options, 0, 0, ""); + + return stringWriter.toString(); + } +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameters.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameters.java new file mode 100644 index 000000000..6151506b8 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestParameters.java @@ -0,0 +1,115 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import java.net.URI; + +/** + * This class reads and handles command line parameters to the Apex RESTful services + * + * User: ewatkmi Date: 31 Jul 2017 + */ +public class ApexDeploymentRestParameters { + public static final int DEFAULT_REST_PORT = 18989; + public static final int INFINITY_TIME_TO_LIVE = -1; + + // Base URI the HTTP server will listen on + private static final String DEFAULT_SERVER_URI_ROOT = "http://localhost:"; + private static final String DEFAULT_REST_PATH = "/apexservices/"; + private static final String DEFAULT_STATIC_PATH = "/"; + + // Package that will field REST requests + public static final String[] DEFAULT_PACKAGES = + new String[] { "com.ericsson.apex.services.client.deployment.rest" }; + + // The services parameters + private boolean helpSet = false; + private int restPort = DEFAULT_REST_PORT; + private long timeToLive = INFINITY_TIME_TO_LIVE; + + public String validate() { + String validationMessage = ""; + validationMessage += validatePort(); + validationMessage += validateTimeToLive(); + + return validationMessage; + } + + public URI getBaseURI() { + return URI.create(DEFAULT_SERVER_URI_ROOT + restPort + DEFAULT_REST_PATH); + } + + public String[] getRESTPackages() { + return DEFAULT_PACKAGES; + } + + public String getStaticPath() { + return DEFAULT_STATIC_PATH; + } + + private String validatePort() { + if (restPort < 1024 || restPort > 65535) { + return "port must be greater than 1023 and less than 65536\n"; + } else { + return ""; + } + } + + private String validateTimeToLive() { + if (timeToLive < -1) { + return "time to live must be greater than -1 (set to -1 to wait forever)\n"; + } else { + return ""; + } + } + + public boolean isHelpSet() { + return helpSet; + } + + public void setHelp(final boolean helpSet) { + this.helpSet = helpSet; + } + + public int getRESTPort() { + return restPort; + } + + public void setRESTPort(final int restPort) { + this.restPort = restPort; + } + + public long getTimeToLive() { + return timeToLive; + } + + public void setTimeToLive(final long timeToLive) { + this.timeToLive = timeToLive; + } + + @Override + public String toString() { + final StringBuilder ret = new StringBuilder(); + ret.append(this.getClass().getSimpleName()).append(": URI=").append(this.getBaseURI()).append(", TTL=") + .append(this.getTimeToLive()).append("sec"); + return ret.toString(); + } +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestResource.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestResource.java new file mode 100644 index 000000000..810b59cc1 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ApexDeploymentRestResource.java @@ -0,0 +1,146 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import com.google.gson.JsonObject; + +import java.io.InputStream; + +import javax.ws.rs.Consumes; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; + +import org.glassfish.jersey.media.multipart.FormDataContentDisposition; +import org.glassfish.jersey.media.multipart.FormDataParam; +import org.onap.policy.apex.core.deployment.ApexDeploymentException; +import org.onap.policy.apex.core.deployment.EngineServiceFacade; +import org.slf4j.ext.XLogger; +import org.slf4j.ext.XLoggerFactory; + +/** + * The class represents the root resource exposed at the base URL<br> + * The url to access this resource would be in the form {@code <baseURL>/rest/....} <br> + * For example: a GET request to the following URL + * {@code http://localhost:18989/apexservices/rest/?hostName=localhost&port=12345} + * + * <b>Note:</b> An allocated {@code hostName} and {@code port} query parameter must be included in all requests. + * Datasets for different {@code hostName} are completely isolated from one another. + * + */ +@Path("deployment/") +@Produces({ MediaType.APPLICATION_JSON }) +@Consumes({ MediaType.APPLICATION_JSON }) + +public class ApexDeploymentRestResource { + // Get a reference to the logger + private static final XLogger LOGGER = XLoggerFactory.getXLogger(ApexDeploymentRestResource.class); + + /** + * Constructor, a new resource director is created for each request. + */ + public ApexDeploymentRestResource() {} + + /** + * Query the engine service for data + * + * @param hostName the host name of the engine service to connect to. + * @param port the port number of the engine service to connect to. + * @return a Response object containing the engines service, status and context data in JSON + */ + @GET + public Response createSession(@QueryParam("hostName") final String hostName, @QueryParam("port") final int port) { + final String host = hostName + ":" + port; + final EngineServiceFacade engineServiceFacade = new EngineServiceFacade(hostName, port); + + try { + engineServiceFacade.init(); + } catch (final ApexDeploymentException e) { + final String errorMessage = "Error connecting to Apex Engine Service at " + host; + LOGGER.warn(errorMessage + "<br>", e); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(errorMessage + "\n" + e.getMessage()) + .build(); + } + + final JsonObject responseObject = new JsonObject(); + + // Engine Service data + responseObject.addProperty("engine_id", engineServiceFacade.getKey().getID()); + responseObject.addProperty("model_id", + engineServiceFacade.getApexModelKey() != null ? engineServiceFacade.getApexModelKey().getID() + : "Not Set"); + responseObject.addProperty("server", hostName); + responseObject.addProperty("port", Integer.toString(port)); + + return Response.ok(responseObject.toString(), MediaType.APPLICATION_JSON).build(); + } + + /** + * Upload a model. + * + * @param hostName the host name of the engine service to connect to. + * @param port the port number of the engine service to connect to. + * @param uploadedInputStream input stream + * @param fileDetail details on the file + * @param ignoreConflicts conflict policy + * @param forceUpdate update policy + * @return a response object in plain text confirming the upload was successful + */ + @POST + @Path("modelupload/") + @Consumes(MediaType.MULTIPART_FORM_DATA) + public Response modelUpload(@FormDataParam("hostName") final String hostName, @FormDataParam("port") final int port, + @FormDataParam("file") final InputStream uploadedInputStream, + @FormDataParam("file") final FormDataContentDisposition fileDetail, + @FormDataParam("ignoreConflicts") final boolean ignoreConflicts, + @FormDataParam("forceUpdate") final boolean forceUpdate) { + final EngineServiceFacade engineServiceFacade = new EngineServiceFacade(hostName, port); + + try { + engineServiceFacade.init(); + } catch (final ApexDeploymentException e) { + final String errorMessage = "Error connecting to Apex Engine Service at " + hostName + ":" + port; + LOGGER.warn(errorMessage + "<br>", e); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(errorMessage + "\n" + e.getMessage()) + .build(); + } + + try { + engineServiceFacade.deployModel(fileDetail.getFileName(), uploadedInputStream, ignoreConflicts, + forceUpdate); + } catch (final Exception e) { + LOGGER.warn("Error updating model on engine service " + engineServiceFacade.getKey().getID(), e); + final String errorMessage = + "Error updating model on engine service " + engineServiceFacade.getKey().getID(); + LOGGER.warn(errorMessage + "<br>", e); + return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(errorMessage + "\n" + e.getMessage()) + .build(); + } + + return Response.ok("Model " + fileDetail.getFileName() + " deployed on engine service " + + engineServiceFacade.getKey().getID()).build(); + } + +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ParameterCheck.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ParameterCheck.java new file mode 100644 index 000000000..87e76cdf7 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/ParameterCheck.java @@ -0,0 +1,211 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.apex.client.deployment.rest; + +import java.util.Map; + +import org.onap.policy.apex.model.basicmodel.concepts.AxArtifactKey; +import org.slf4j.ext.XLogger; +import org.slf4j.ext.XLoggerFactory; + +/** + * The Class ParameterCheck is used to check parameters passed to the servlet. + * + * @author Liam Fallon (liam.fallon@ericsson.com) + */ +public final class ParameterCheck { + private static final int MAX_PORT = 65535; + + /** + * private constructor to prevent subclassing of this utility class. + */ + private ParameterCheck() {} + + /** + * The Enum StartStop is used to hold . + * + * @author Liam Fallon (liam.fallon@ericsson.com) + */ + public enum StartStop { + /** Start of an Apex engine has been ordered. */ + START, + /** Stop of an Apex engine has been ordered. */ + STOP + }; + + private static final XLogger LOGGER = XLoggerFactory.getXLogger(ParameterCheck.class); + + private static final String HOSTNAME_PAR = "hostname"; + private static final String PORT_PAR = "port"; + private static final String AXARTIFACTKEY_PAR = "AxArtifactKey"; + + /** + * Gets the host name. + * + * @param parameterMap the parameter map + * @return the host name + */ + public static String getHostName(final Map<String, String[]> parameterMap) { + if (!parameterMap.containsKey(HOSTNAME_PAR)) { + LOGGER.warn("parameter \"" + HOSTNAME_PAR + "\" not found"); + return null; + } + + final String[] hostNameValue = parameterMap.get(HOSTNAME_PAR); + + if (hostNameValue.length == 0 || hostNameValue[0].trim().length() == 0) { + LOGGER.warn("value of parameter \"" + HOSTNAME_PAR + "\" not found"); + return null; + } + + return hostNameValue[0]; + } + + /** + * Gets the port. + * + * @param parameterMap the parameter map + * @return the port + */ + public static int getPort(final Map<String, String[]> parameterMap) { + if (!parameterMap.containsKey(PORT_PAR)) { + LOGGER.warn("parameter \"" + PORT_PAR + "\" not found"); + return -1; + } + + final String[] portValue = parameterMap.get(PORT_PAR); + + if (portValue.length == 0 || portValue[0].trim().length() == 0) { + LOGGER.warn("value of parameter \"" + PORT_PAR + "\" not found"); + return -1; + } + + int port = -1; + try { + port = Integer.parseInt(portValue[0]); + } catch (final Exception e) { + LOGGER.warn("value \"" + portValue[0] + "\"of parameter \"" + PORT_PAR + "\" not a valid integer", e); + return -1; + } + + if (port <= 0 || port > MAX_PORT) { + LOGGER.warn("value \"" + portValue[0] + "\"of parameter \"" + PORT_PAR + + "\" not a valid port between 0 and 65535"); + return -1; + } + + return port; + } + + /** + * Gets the engine key. + * + * @param parameterMap the parameter map + * @return the engine key + */ + public static AxArtifactKey getEngineKey(final Map<String, String[]> parameterMap) { + String artifactKeyParameter = null; + for (final String parameter : parameterMap.keySet()) { + // Check for an AxArtifactKey parameter + if (parameter.startsWith(AXARTIFACTKEY_PAR)) { + artifactKeyParameter = parameter; + break; + } + } + if (artifactKeyParameter == null) { + LOGGER.warn("parameter \"" + AXARTIFACTKEY_PAR + "\" not found"); + return null; + } + + final String[] axArtifactKeyArray = artifactKeyParameter.split("#"); + + if (axArtifactKeyArray.length != 2) { + LOGGER.warn("value \"" + artifactKeyParameter + "\" of parameter \"" + AXARTIFACTKEY_PAR + "\" not valid"); + return null; + } + + return new AxArtifactKey(axArtifactKeyArray[1]); + } + + /** + * Gets the start stop. + * + * @param parameterMap the parameter map + * @param engineKey the engine key + * @return the start stop + */ + public static ParameterCheck.StartStop getStartStop(final Map<String, String[]> parameterMap, + final AxArtifactKey engineKey) { + final String startStopPar = AXARTIFACTKEY_PAR + '#' + engineKey.getID(); + if (!parameterMap.containsKey(startStopPar)) { + LOGGER.warn("parameter \"" + startStopPar + "\" not found"); + return null; + } + + final String[] startStopValue = parameterMap.get(startStopPar); + + if (startStopValue.length == 0 || startStopValue[0].trim().length() == 0) { + LOGGER.warn("value of parameter \"" + startStopPar + "\" not found"); + return null; + } + + ParameterCheck.StartStop startStop; + if (startStopValue[0].equalsIgnoreCase("start")) { + startStop = ParameterCheck.StartStop.START; + } else if (startStopValue[0].equalsIgnoreCase("stop")) { + startStop = ParameterCheck.StartStop.STOP; + } else { + LOGGER.warn("value \"" + startStopValue[0] + "\"of parameter \"" + startStopPar + + "\" not \"start\" or \"stop\""); + return null; + } + + return startStop; + } + + /** + * Find and return a long value with the given name. + * + * @param parameterMap The parameter map containing the value + * @param longName The name of the long parameter + * @return The long value + */ + public static long getLong(final Map<String, String[]> parameterMap, final String longName) { + if (!parameterMap.containsKey(longName)) { + LOGGER.warn("parameter \"" + longName + "\" not found"); + return -1; + } + + final String[] longValue = parameterMap.get(longName); + + if (longValue.length == 0 || longValue[0].trim().length() == 0) { + LOGGER.warn("value of parameter \"" + longName + "\" not found"); + return -1; + } + + try { + return Long.parseLong(longValue[0]); + } catch (final Exception e) { + LOGGER.warn("value \"" + longValue[0] + "\"of parameter \"" + longName + "\" not a valid long", e); + return -1; + } + } +} diff --git a/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/package-info.java b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/package-info.java new file mode 100644 index 000000000..997e411a6 --- /dev/null +++ b/client/client-deployment/src/main/java/org/onap/policy/apex/client/deployment/rest/package-info.java @@ -0,0 +1,27 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/** + * Implements the RESTful deployment for Apex. + * + * @author Liam Fallon (liam.fallon@ericsson.com) + */ + +package org.onap.policy.apex.client.deployment.rest; diff --git a/client/client-deployment/src/main/resources/webapp/WEB-INF/web.xml b/client/client-deployment/src/main/resources/webapp/WEB-INF/web.xml new file mode 100644 index 000000000..b79cf362a --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/WEB-INF/web.xml @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ============LICENSE_START======================================================= + Copyright (C) 2016-2018 Ericsson. All rights reserved. + ================================================================================ + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + SPDX-License-Identifier: Apache-2.0 + ============LICENSE_END========================================================= +--> + +<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" + xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" + xsi:schemaLocation="http://java.sun.com/xml/ns/javaee + http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" + id="WebApp_ID" version="3.0"> + + <servlet> + <servlet-name>apex-services.rest</servlet-name> + <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class> + <init-param> + <param-name>jersey.config.server.provider.packages</param-name> + <param-value>org.onap.policy.apex.client.deployment.rest</param-value> + </init-param> + <init-param> + <param-name>jersey.config.server.provider.classnames</param-name> + <param-value>org.glassfish.jersey.media.multipart.MultiPartFeature</param-value> + </init-param> + <load-on-startup>1</load-on-startup> + </servlet> + <servlet-mapping> + <servlet-name>apex-services.rest</servlet-name> + <url-pattern>/apexservices/*</url-pattern> + </servlet-mapping> + +</web-app>
\ No newline at end of file diff --git a/client/client-deployment/src/main/resources/webapp/index.html b/client/client-deployment/src/main/resources/webapp/index.html new file mode 100644 index 000000000..2ae25f901 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/index.html @@ -0,0 +1,87 @@ +<!-- + ============LICENSE_START======================================================= + Copyright (C) 2016-2018 Ericsson. All rights reserved. + ================================================================================ + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + SPDX-License-Identifier: Apache-2.0 + ============LICENSE_END========================================================= +--> + +<html> +<head> +<meta charset="UTF-8"> + +<title>Apex Deployment</title> + +<!-- interface style --> +<link rel="stylesheet" type="text/css" href="css/interfaceAssets.css"> +<!-- ApexChartLib style --> +<link rel="stylesheet" type="text/css" href="css/apexChartLib.css"> +<!-- Apex services client style --> +<link rel="stylesheet" type="text/css" href="css/styles.css"> + +<script type="text/javascript" src="js/ApexUtils.js"></script> + +</head> +<body> + + <!-- interface styled System Bar --> + <div class="ebSystemBar"> + <div class="ebSystemBar-topMenuName">Apex</div> + <div class="ebSystemBar-config"></div> + </div> + + <div class="layoutWrapper"> + + <div class="ebBreadcrumbs"> + <div class="ebBreadcrumbs-item"> + <a href="javascript:getHomepageURL();" class="ebBreadcrumbs-link">Apex</a> + </div> + <div class="ebBreadcrumbs-item"> + <a href="" class="ebBreadcrumbs-link">Deployment</a> + </div> + </div> + + <div class="appHeading"> + <h1 class="title">Apex Deployment</h1> + </div> + + <div class="search ebQuickActionBar"></div> + + <!-- Main content div --> + <div id="content" class="content"> + + <!-- Engine Service --> + <h2>Engine Service</h2> + <div class="engineService"></div> + + <!-- Apex Model Loading --> + <h2>Apex Model Loading</h2> + <div class="modelLoading"></div> + + </div> + </div> + + <!-- jQuery --> + <script src="jquery/jquery-1.12.4.js"></script> + + <!-- Apex services client JS files --> + <script type="text/javascript" src="js/ApexAjax.js"></script> + <script type="text/javascript" src="js/ApexTable.js"></script> + <script type="text/javascript" src="js/ApexEngineService.js"></script> + <script type="text/javascript" src="js/ApexModelLoading.js"></script> + <script type="text/javascript" src="js/ApexServicesMain.js"></script> + +</body> +</html> diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexAjax.js b/client/client-deployment/src/main/resources/webapp/js/ApexAjax.js new file mode 100644 index 000000000..beb2cb11d --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexAjax.js @@ -0,0 +1,84 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/* + * Send a GET request + */ +function ajax_get(requestURL, callback, hostName, port, params, errorCallback) { + var data = { + hostName : hostName, + port : port + }; + for ( var p in params) { + data[p] = params[p]; + } + return $.ajax({ + type : 'GET', + url : requestURL, + dataType : "json", + data : data, + success : function(data, textStatus, jqXHR) { + if (callback) { + callback(data); + } + }, + error : function(jqXHR, textStatus, errorThrown) { + if (jqXHR.status == 500 || jqXHR.status == 404) { + if (jqXHR.responseText.indexOf("cound not handshake with server") !== -1 || jqXHR.status == 404) { + clearEngineURL(); + getEngineURL(jqXHR.responseText); + } else { + apexErrorDialog_activate(document.body, jqXHR.responseText); + } + } + if (errorCallback) { + errorCallback(jqXHR, textStatus, errorThrown); + } + } + }); +} + +/* + * Send a POST request and add a file to its payload + */ +function ajax_upload(requestURL, callback, hostName, port, fileUrl, ignoreConflicts, forceUpdate) { + var formData = new FormData(); + formData.append("hostName", hostName); + formData.append("port", port); + formData.append("file", fileUrl); + formData.append("ignoreConflicts", ignoreConflicts); + formData.append("forceUpdate", forceUpdate); + return $.ajax({ + url : requestURL, + type : "POST", + contentType : false, + dataType : "text", + processData : false, + data : formData, + success : function(data, textStatus, jqXHR) { + callback(data); + }, + error : function(jqXHR, textStatus, errorThrown) { + if (jqXHR.status == 500) { + apexErrorDialog_activate(document.body, jqXHR.responseText); + } + } + }); +} diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexEngineService.js b/client/client-deployment/src/main/resources/webapp/js/ApexEngineService.js new file mode 100644 index 000000000..f47c98f07 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexEngineService.js @@ -0,0 +1,101 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/* + * Create the Engine Service Table + */ +function createEngineServiceTable() { + var tableId = config.engineService.tableId; + var headers = config.engineService.headers; + var table = createEngineTable($("." + config.engineService.parent), tableId, headers.map(function(a) { + return a.title; + })); + var tableRow = document.createElement("tr"); + var tableData = ""; + for ( var h in headers) { + tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; + } + tableRow.innerHTML = tableData; + var actionTD = $(tableRow).find("#" + tableId + "_periodic_events"); + actionTD + .html('<input type="text" name="period" id="period" style="display:inline-block"><label class="ebSwitcher"><input type="checkbox" class="ebSwitcher-checkbox" /><div class="ebSwitcher-body"><div class="ebSwitcher-onLabel">Stopped</div><div class="ebSwitcher-switch"></div><div class="ebSwitcher-offLabel">Started</div></div></label>'); + var period = actionTD.find("#period"); + var switcher = actionTD.find(".ebSwitcher"); + switcher.css('display', 'inline-block'); + switcher.css('margin-left', '5px'); + switcher.css('vertical-align', 'middle'); + var checkbox = $(actionTD).find('input:checkbox:first'); + checkbox.change(function(event) { + var startstop; + if (checkbox.prop('checked')) { + startstop = "Stop"; + } else { + startstop = "Start"; + } + this.servicesCall.abort(); + ajax_get(restRootURL + "periodiceventstartstop", startStopCallback, this.engineURL.hostname, + this.engineURL.port, { + engineId : this.engineId, + startstop : startstop, + period : period.val() + }, resetPeriodicEvents); + }.bind(this)); + $(table).children("#engineTableBody").append(tableRow); +} + +/* + * Check for any changes in the Engine Service Table data and update only where + * necessary + */ +function setEngineServiceData(engineId, modelId, server, port, periodicEvents) { + this.engineId = engineId; + var tableId = config.engineService.tableId; + var headers = config.engineService.headers.map(function(a) { + return a.id; + }); + var data = [ engineId, server + ":" + port, modelId ]; + + var engineServiceTable = $("#engineServicesTable"); + + for ( var h in headers) { + var td = engineServiceTable.find("#" + tableId + "_" + headers[h]); + if (td.html() !== data[h]) { + engineServiceTable.find("#" + tableId + "_" + headers[h]).html(data[h]); + } + } + + var actionTD = engineServiceTable.find("#" + tableId + "_periodic_events"); + var checkbox = $(actionTD).find('input:checkbox:first'); + if (checkbox.is(":checked") === periodicEvents) { + checkbox.prop("checked", !checkbox.prop("checked")); + } +} + +/* + * Resets the switcher for Periodic Events in the Engine Service Table + */ +function resetPeriodicEvents() { + var engineServiceTable = $("#engineServicesTable"); + var periodicEventsTD = $(engineServiceTable).find("#engineServicesTable_periodic_events"); + var checkbox = $(periodicEventsTD).find('input:checkbox:first'); + if (checkbox.is(":checked")) { + checkbox.prop("checked", false); + } +} diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexModelLoading.js b/client/client-deployment/src/main/resources/webapp/js/ApexModelLoading.js new file mode 100644 index 000000000..8bd051f0f --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexModelLoading.js @@ -0,0 +1,63 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/* + * Create the div for uploading Apex models + */ +function createModelLoadingDiv() { + var fileLoader = document.createElement("input"); + fileLoader.setAttribute("type", "file"); + fileLoader.setAttribute("name", "apexModelFile"); + fileLoader.setAttribute("label", "Load Apex Model XML file"); + $('.modelLoading').append(fileLoader); + + var ignoreConflictsCheckbox = document.createElement("input"); + ignoreConflictsCheckbox.setAttribute("type", "checkbox"); + ignoreConflictsCheckbox.setAttribute("name", "ignoreContextConflicts"); + $('.modelLoading').append(ignoreConflictsCheckbox); + + ignoreConflictsLabel = document.createElement("label"); + ignoreConflictsLabel.setAttribute("class", "ignoreConflictsLabel"); + ignoreConflictsLabel.innerHTML = "Ignore Context Conflicts"; + $('.modelLoading').append(ignoreConflictsLabel); + + var forceUpdateCheckbox = document.createElement("input"); + forceUpdateCheckbox.setAttribute("type", "checkbox"); + forceUpdateCheckbox.setAttribute("name", "forceUpdate"); + $('.modelLoading').append(forceUpdateCheckbox); + + forceUpdateLabel = document.createElement("label"); + forceUpdateLabel.setAttribute("class", "ignoreConflictsLabel"); + forceUpdateLabel.innerHTML = "Force Update"; + $('.modelLoading').append(forceUpdateLabel); + + var submitButton = document.createElement("button"); + submitButton.setAttribute("class", "ebBtn"); + submitButton.innerHTML = "Load Apex Model XML file"; + $(submitButton).click( + function() { + var file = fileLoader.files[0]; + var ignoreConflicts = $(ignoreConflictsCheckbox).is(":checked"); + var forceUpdate = $(forceUpdateCheckbox).is(":checked"); + ajax_upload(restRootURL + "modelupload/", uploadCallback, this.engineURL.hostname, this.engineURL.port, + file, ignoreConflicts, forceUpdate); + }.bind(this)); + $('.modelLoading').append(submitButton); +}
\ No newline at end of file diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexServicesMain.js b/client/client-deployment/src/main/resources/webapp/js/ApexServicesMain.js new file mode 100644 index 000000000..a54815ab3 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexServicesMain.js @@ -0,0 +1,147 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +var restRootURL; + +var config = { + refresh : 5000, + engineService : { + parent : "engineService", + tableId : "engineServicesTable", + headers : [ { + title : "Engine Service ID", + id : "engine_id" + }, { + title : "server:port", + id : "server_port" + }, { + title : "Model ID", + id : "model_id" + } ] + } +} + +/* + * Callback for showing model info + */ +function servicesCallback(data) { + // If engine url in cookie has not been cleared + if (localStorage.getItem("apex-monitor-services")) { + setEngineServiceData(data.engine_id, data.model_id, data.server, data.port, data.periodic_events); + + // Make content visible after data has been returned for the first time + if (!$(".content").is(':visible')) { + $(".content").fadeIn(); + } + + // Repeat the same request + setTimeout(function() { + this.servicesCall = ajax_get(restRootURL, servicesCallback, this.engineURL.hostname, this.engineURL.port); + }, config.refresh); + } +} + +/* + * Callback for uploading a model + */ +function uploadCallback(response) { + // Open a dialog showing the response + apexSuccessDialog_activate(document.body, response); +} + +/* + * Clears and resets all content on the page + */ +function setUpPage() { + // Clear each div + $('#content > div').each(function() { + $(this).empty(); + }); + + // Set up content div's + createEngineServiceTable(); + createModelLoadingDiv(); +} + +/* + * Retrieves the engine URL from the cookie. If it has not been set yet, then a + * dialog is shown asking for it + */ +function getEngineURL(message) { + // The engine URL is stored in a cookie using the key + // "apex-monitor-services" + var engineURL = localStorage.getItem("apex-monitor-services"); + + // This url is used to store the last known engine URL so that the user + // doesn't have to retype it every time + var oldEngineURL = localStorage.getItem("apex-monitor-services_old"); + + // If an engine URL is stored in the cookie + if (engineURL) { + // Parse the engine URL + this.engineURL = JSON.parse(engineURL); + + // Send a request with that engine URL + this.servicesCall = ajax_get(restRootURL, servicesCallback, this.engineURL.hostname, this.engineURL.port); + } else { + // Prompt for engine URL + apexDialogForm_activate(document.body, message); + } +} + +/* + * Clears the cookie and reset the page + */ +function clearEngineURL() { + // Remove engine URL from cookie + localStorage.removeItem("apex-monitor-services"); + + // Reset the page + setUpPage(); +} + +/* + * Called after the DOM is ready + */ +$(document).ready( + function() { + restRootURL = location.protocol + + "//" + + window.location.hostname + + (location.port ? ':' + location.port : '') + + (location.pathname.endsWith("/deployment/") ? location.pathname.substring(0, location.pathname + .indexOf("deployment/")) : location.pathname) + "apexservices/deployment/"; + + // Set up the structure of the page + setUpPage(); + + // Check cookies for engine URL + getEngineURL(); + + // Add click event to config icon for clearing engine URL + $(".ebSystemBar-config").click(function() { + // Clear the engine URL + clearEngineURL(); + + // Request the engine URL + getEngineURL(); + }); + + });
\ No newline at end of file diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexTable.js b/client/client-deployment/src/main/resources/webapp/js/ApexTable.js new file mode 100644 index 000000000..20e3d08bd --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexTable.js @@ -0,0 +1,59 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/* + * Create a table with given headers + */ +function createEngineTable(parent, id, tableHeaders) { + var table = createTable(id); + + var tableHead = document.createElement("thead"); + table.appendChild(tableHead); + tableHead.setAttribute("id", "engineTableHeader"); + + var tableHeaderRow = document.createElement("tr"); + tableHead.appendChild(tableHeaderRow); + tableHeaderRow.setAttribute("id", "engineTableHeaderRow"); + + for ( var t in tableHeaders) { + var tableHeader = document.createElement("th"); + tableHeaderRow.appendChild(tableHeader); + tableHeader.setAttribute("id", "engineTableHeader"); + tableHeader.appendChild(document.createTextNode(tableHeaders[t])); + } + + var tableBody = document.createElement("tbody"); + tableBody.setAttribute("id", "engineTableBody"); + table.appendChild(tableBody); + + parent.append(table); + + return table; +} + +/* + * Create a table and apply UISDK styles to it + */ +function createTable(id) { + var table = document.createElement("table"); + table.setAttribute("id", id); + table.setAttribute("class", "apexTable ebTable elTablelib-Table-table ebTable_striped"); + return table; +}
\ No newline at end of file diff --git a/client/client-deployment/src/main/resources/webapp/js/ApexUtils.js b/client/client-deployment/src/main/resources/webapp/js/ApexUtils.js new file mode 100644 index 000000000..0f5e689fd --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/js/ApexUtils.js @@ -0,0 +1,212 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2016-2018 Ericsson. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +/* + * Crate a dialog with input, attach it to a given parent and show an optional message + */ +function apexDialogForm_activate(formParent, message) { + apexUtils_removeElement("apexDialogDiv"); + + var contentelement = document.createElement("apexDialogDiv"); + var formDiv = document.createElement("div"); + var backgroundDiv = document.createElement("div"); + backgroundDiv.setAttribute("id", "apexDialogDivBackground"); + backgroundDiv.setAttribute("class", "apexDialogDivBackground"); + + backgroundDiv.appendChild(formDiv); + contentelement.appendChild(backgroundDiv); + formParent.appendChild(contentelement); + + formDiv.setAttribute("id", "apexDialogDiv"); + formDiv.setAttribute("class", "apexDialogDiv"); + + var headingSpan = document.createElement("span"); + formDiv.appendChild(headingSpan); + + headingSpan.setAttribute("class", "headingSpan"); + headingSpan.innerHTML = "Apex Engine Configuration"; + + var form = document.createElement("apexDialog"); + formDiv.appendChild(form); + + form.setAttribute("id", "apexDialog"); + form.setAttribute("class", "form-style-1"); + form.setAttribute("method", "post"); + + if (message) { + var messageLI = document.createElement("li"); + messageLI.setAttribute("class", "dialogMessage"); + messageLI.innerHTML = message; + form.appendChild(messageLI); + } + + var urlLI = document.createElement("li"); + form.appendChild(urlLI); + + var urlLabel = document.createElement("label"); + urlLI.appendChild(urlLabel); + + urlLabel.setAttribute("for", "apexDialogUrlInput"); + urlLabel.innerHTML = "Apex Engine rest URL:"; + + var urlLabelSpan = document.createElement("span"); + urlLabel.appendChild(urlLabelSpan); + + urlLabelSpan.setAttribute("class", "required"); + urlLabelSpan.innerHTML = "*"; + + var engineUrl = localStorage.getItem("apex-monitor-services_old"); + + var urlInput = document.createElement("input"); + urlInput.setAttribute("id", "services_url_input"); + urlInput.setAttribute("placeholder", "localhost:12345"); + urlInput.value = (engineUrl && engineUrl !== "null") ? JSON.parse(engineUrl).hostname + ":" + + JSON.parse(engineUrl).port : ""; + urlLI.appendChild(urlInput); + + var inputLI = document.createElement("li"); + form.appendChild(inputLI); + + var submitInput = document.createElement("input"); + submitInput.setAttribute("id", "submit"); + submitInput.setAttribute("class", "button ebBtn"); + submitInput.setAttribute("type", "submit"); + submitInput.setAttribute("value", "Submit"); + submitInput.onclick = apexDialogForm_submitPressed; + inputLI.appendChild(submitInput); + + // Enter key press triggers submit + $(urlInput).keyup(function(event) { + if (event.keyCode == 13) { + $(submitInput).click(); + } + }); + + urlInput.focus(); +} + +/* + * Create a dialog for displaying text + */ +function apexTextDialog_activate(formParent, message, title) { + apexUtils_removeElement("apexDialogDiv"); + + var contentelement = document.createElement("div"); + contentelement.setAttribute("id", "apexDialogDiv") + var formDiv = document.createElement("div"); + var backgroundDiv = document.createElement("div"); + backgroundDiv.setAttribute("id", "apexDialogDivBackground"); + backgroundDiv.setAttribute("class", "apexDialogDivBackground"); + + backgroundDiv.appendChild(formDiv); + contentelement.appendChild(backgroundDiv); + formParent.appendChild(contentelement); + + formDiv.setAttribute("id", "apexErrorDialogDiv"); + formDiv.setAttribute("class", "apexDialogDiv apexErrorDialogDiv"); + + var headingSpan = document.createElement("span"); + formDiv.appendChild(headingSpan); + + headingSpan.setAttribute("class", "headingSpan"); + headingSpan.innerHTML = title; + + var form = document.createElement("div"); + formDiv.appendChild(form); + + form.setAttribute("id", "apexDialog"); + form.setAttribute("class", "form-style-1"); + form.setAttribute("method", "post"); + + if (message) { + var messageLI = document.createElement("li"); + messageLI.setAttribute("class", "dialogMessage"); + messageLI.innerHTML = message; + form.appendChild(messageLI); + } + + var inputLI = document.createElement("li"); + form.appendChild(inputLI); + + var cancelInput = document.createElement("input"); + cancelInput.setAttribute("class", "button ebBtn"); + cancelInput.setAttribute("type", "submit"); + cancelInput.setAttribute("value", "Close"); + cancelInput.onclick = newModelForm_cancelPressed; + form.appendChild(cancelInput); +} + +/* + * Create a Success dialog + */ +function apexSuccessDialog_activate(formParent, message) { + apexTextDialog_activate(formParent, message, "Success"); +} + +/* + * Create an Error dialog + */ +function apexErrorDialog_activate(formParent, message) { + apexTextDialog_activate(formParent, message, "Error"); +} + +/* + * Dialog cancel callback + */ +function newModelForm_cancelPressed() { + apexUtils_removeElement("apexDialogDivBackground"); +} + +/* + * Dialog submit callback + */ +function apexDialogForm_submitPressed() { + var url = $('#services_url_input').val(); + if (url && url.length > 0) { + var engineConfig = { + hostname : url.split(":")[0], + port : url.split(":")[1] + }; + localStorage.setItem("apex-monitor-services_old", JSON.stringify(engineConfig)); + localStorage.setItem("apex-monitor-services", JSON.stringify(engineConfig)); + apexUtils_removeElement("apexDialogDivBackground"); + getEngineURL(); + } +} + +/* + * Remove an element from the page + */ +function apexUtils_removeElement(elementname) { + var element = document.getElementById(elementname); + if (element != null) { + element.parentNode.removeChild(element); + } +} + +function getHomepageURL() { + var homepageURL = location.protocol + + "//" + + window.location.hostname + + (location.port ? ':' + location.port : '') + + (location.pathname.endsWith("/deployment/") ? location.pathname.substring(0, location.pathname + .indexOf("deployment/")) : location.pathname); + location.href = homepageURL; +}
\ No newline at end of file diff --git a/client/client-deployment/src/main/resources/webapp/resources/16px/rowCollapsed_black_16px.svg b/client/client-deployment/src/main/resources/webapp/resources/16px/rowCollapsed_black_16px.svg new file mode 100644 index 000000000..6878c863c --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/resources/16px/rowCollapsed_black_16px.svg @@ -0,0 +1,19 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In --> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [ + <!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/"> +]> +<svg version="1.1" + xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/" + x="0px" y="0px" width="16px" height="16px" viewBox="13 2437.971 16 16" enable-background="new 13 2437.971 16 16" + xml:space="preserve"> +<defs> +</defs> +<rect display="none" fill="#66A19F" width="87" height="3280.97"/> +<rect x="17" y="2441.97" fill="#FFFFFF" width="7" height="7"/> +<path d="M24.5,2440.97c-0.275,0-7.725,0-8,0s-0.5,0.225-0.5,0.5s0,7.725,0,8s0.225,0.499,0.5,0.499c0.22,0,7.78,0,8,0 + c0.275,0,0.5-0.223,0.5-0.499s0-7.725,0-8S24.775,2440.97,24.5,2440.97z M24,2448.97h-7v-7.001h7V2448.97z"/> +<line fill="none" stroke="#000000" stroke-miterlimit="10" x1="18" y1="2445.47" x2="23" y2="2445.47"/> +<line fill="none" stroke="#000000" stroke-miterlimit="10" x1="20.5" y1="2447.97" x2="20.5" y2="2442.971"/> +<rect x="13" y="2437.97" display="none" opacity="0.2" fill="#E94E47" width="16" height="16"/> +</svg> diff --git a/client/client-deployment/src/main/resources/webapp/resources/16px/rowExpanded_black_16px.svg b/client/client-deployment/src/main/resources/webapp/resources/16px/rowExpanded_black_16px.svg new file mode 100644 index 000000000..5e3e46a66 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/resources/16px/rowExpanded_black_16px.svg @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In --> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [ + <!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/"> +]> +<svg version="1.1" + xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/" + x="0px" y="0px" width="16px" height="16px" viewBox="13 2405.971 16 16" enable-background="new 13 2405.971 16 16" + xml:space="preserve"> +<defs> +</defs> +<rect display="none" fill="#66A19F" width="87" height="3280.97"/> +<rect x="17" y="2409.97" fill="#FFFFFF" width="7" height="7"/> +<path d="M24.5,2408.971c-0.275,0-7.725,0-8,0s-0.5,0.225-0.5,0.5s0,7.725,0,8s0.225,0.499,0.5,0.499c0.22,0,7.78,0,8,0 + c0.275,0,0.5-0.223,0.5-0.499s0-7.725,0-8S24.775,2408.971,24.5,2408.971z M24,2416.971h-7v-7.001h7V2416.971z"/> +<line fill="none" stroke="#000000" stroke-miterlimit="10" x1="18" y1="2413.471" x2="23" y2="2413.471"/> +<rect x="13" y="2405.97" display="none" opacity="0.2" fill="#E94E47" width="16" height="16"/> +</svg> diff --git a/client/client-deployment/src/main/resources/webapp/resources/16px/settings_black_16px.svg b/client/client-deployment/src/main/resources/webapp/resources/16px/settings_black_16px.svg new file mode 100644 index 000000000..c347888e9 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/resources/16px/settings_black_16px.svg @@ -0,0 +1,20 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In --> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [ + <!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/"> +]> +<svg version="1.1" + xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/" + x="0px" y="0px" width="16px" height="16px" viewBox="13 101.971 16 16" enable-background="new 13 101.971 16 16" + xml:space="preserve"> +<defs> +</defs> +<rect display="none" fill="#66A19F" width="87" height="3280.97"/> +<path d="M28,110.97v-2h-2.101c-0.13-0.638-0.383-1.229-0.73-1.754l1.488-1.488l-1.414-1.414l-1.488,1.488 + c-0.524-0.347-1.117-0.601-1.755-0.731v-2.101h-2v2.101c-0.638,0.129-1.23,0.383-1.754,0.731l-1.488-1.488l-1.414,1.414l1.488,1.488 + c-0.347,0.524-0.601,1.116-0.731,1.754H14v2h2.101c0.13,0.638,0.384,1.23,0.731,1.755l-1.488,1.488l1.414,1.414l1.488-1.488 + c0.524,0.347,1.116,0.601,1.754,0.73v2.101h2v-2.101c0.638-0.129,1.23-0.383,1.754-0.731l1.489,1.489l1.414-1.414l-1.489-1.489 + c0.347-0.524,0.601-1.116,0.731-1.754H28z M21,112.47c-1.381,0-2.5-1.119-2.5-2.5s1.119-2.5,2.5-2.5s2.5,1.119,2.5,2.5 + S22.381,112.47,21,112.47z"/> +<rect x="13" y="101.97" display="none" opacity="0.2" fill="#E94E47" width="16" height="16"/> +</svg> diff --git a/client/client-deployment/src/main/resources/webapp/resources/systemBar/help_black.svg b/client/client-deployment/src/main/resources/webapp/resources/systemBar/help_black.svg new file mode 100644 index 000000000..14fdf5d35 --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/resources/systemBar/help_black.svg @@ -0,0 +1,19 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + width="16px" height="16px" viewBox="0 0 16 16" enable-background="new 0 0 16 16" xml:space="preserve"> +<path fill="#1D1D1B" d="M8,0C3.582,0,0,3.582,0,8s3.582,8,8,8s8-3.582,8-8S12.418,0,8,0z M8.608,12.149 + c-0.205,0.183-0.442,0.273-0.711,0.273c-0.277,0-0.521-0.09-0.728-0.27c-0.207-0.181-0.311-0.433-0.311-0.756 + c0-0.287,0.101-0.528,0.3-0.724c0.201-0.196,0.447-0.295,0.738-0.295c0.287,0,0.529,0.099,0.725,0.295 + c0.196,0.195,0.295,0.437,0.295,0.724C8.917,11.717,8.813,11.967,8.608,12.149z M10.46,6.227c-0.123,0.229-0.27,0.427-0.439,0.594 + C9.85,6.986,9.545,7.267,9.104,7.661c-0.122,0.111-0.22,0.208-0.293,0.292C8.738,8.038,8.684,8.114,8.647,8.185 + c-0.036,0.069-0.063,0.14-0.083,0.209c-0.02,0.07-0.049,0.193-0.089,0.368C8.408,9.135,8.194,9.32,7.837,9.32 + c-0.187,0-0.343-0.061-0.47-0.183C7.239,9.016,7.176,8.835,7.176,8.595c0-0.301,0.047-0.561,0.14-0.782 + c0.093-0.22,0.217-0.413,0.371-0.58C7.84,7.067,8.048,6.869,8.31,6.64c0.229-0.201,0.395-0.352,0.497-0.454 + c0.102-0.103,0.188-0.216,0.257-0.341c0.07-0.125,0.105-0.261,0.105-0.408c0-0.287-0.107-0.528-0.32-0.725S8.361,4.417,8.024,4.417 + c-0.394,0-0.684,0.099-0.87,0.298C6.968,4.913,6.811,5.206,6.682,5.593C6.56,5.998,6.329,6.2,5.989,6.2 + c-0.201,0-0.37-0.071-0.508-0.212C5.344,5.846,5.274,5.693,5.274,5.528c0-0.34,0.109-0.685,0.328-1.034 + C5.82,4.146,6.14,3.856,6.559,3.627s0.907-0.344,1.466-0.344c0.52,0,0.978,0.096,1.375,0.287c0.397,0.192,0.705,0.452,0.922,0.782 + c0.216,0.33,0.324,0.688,0.324,1.074C10.646,5.73,10.584,5.998,10.46,6.227z"/> +</svg> diff --git a/client/client-deployment/src/main/resources/webapp/resources/systemBar/logout_black.svg b/client/client-deployment/src/main/resources/webapp/resources/systemBar/logout_black.svg new file mode 100644 index 000000000..af297acde --- /dev/null +++ b/client/client-deployment/src/main/resources/webapp/resources/systemBar/logout_black.svg @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> +<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" + width="16px" height="16px" viewBox="0 0 16 16" enable-background="new 0 0 16 16" xml:space="preserve"> +<g> + <g> + <path fill="#1D1D1B" d="M10.77,12.455c0,0-0.684,0.192-0.684-0.684c0-0.199,0-0.861,0-1.711H5.98 + c-0.377,0-0.684-0.308-0.684-0.684V6.639c0-0.377,0.307-0.684,0.684-0.684h4.106c0-0.818,0-1.475,0-1.732 + c0-0.919,0.684-0.662,0.684-0.662l5.133,4.447L10.77,12.455z"/> + </g> + <path fill="#1D1D1B" d="M9.85,14H3.099c-0.551,0-1-0.447-1-1V3c0-0.552,0.449-1,1-1H9.85V0H3.099c-1.656,0-3,1.344-3,3v10 + c0,1.656,1.344,3,3,3H9.85V14z"/> +</g> +</svg> diff --git a/client/client-monitoring/pom.xml b/client/client-monitoring/pom.xml index d94a0ea68..abac35db2 100644 --- a/client/client-monitoring/pom.xml +++ b/client/client-monitoring/pom.xml @@ -37,6 +37,14 @@ <version>${project.version}</version> </dependency> <dependency> + <groupId>org.onap.policy.apex-pdp.client</groupId> + <artifactId>client-common</artifactId> + <version>${project.version}</version> + <classifier>resources</classifier> + <type>zip</type> + <scope>provided</scope> + </dependency> + <dependency> <groupId>org.glassfish.jersey.containers</groupId> <artifactId>jersey-container-grizzly2-http</artifactId> <version>${version.jersey}</version> @@ -64,6 +72,25 @@ <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-dependency-plugin</artifactId> + <executions> + <execution> + <id>unpack-client-monitoring-shared-resources</id> + <goals> + <goal>unpack-dependencies</goal> + </goals> + <phase>generate-resources</phase> + <configuration> + <outputDirectory>${project.build.directory}/${project.artifactId}-${project.version}</outputDirectory> + <includeArtifacIds>client-common</includeArtifacIds> + <includeGroupIds>${project.groupId}</includeGroupIds> + <excludeTransitive>true</excludeTransitive> + </configuration> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <executions> <execution> diff --git a/client/client-monitoring/src/main/resources/webapp/css/interfaceAssets.css b/client/client-monitoring/src/main/resources/webapp/css/interfaceAssets.css deleted file mode 100644 index acb8fe23b..000000000 --- a/client/client-monitoring/src/main/resources/webapp/css/interfaceAssets.css +++ /dev/null @@ -1,3454 +0,0 @@ -/* - * ============LICENSE_START======================================================= - * Copyright (C) 2016-2018 Ericsson. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * SPDX-License-Identifier: Apache-2.0 - * ============LICENSE_END========================================================= - */ -@charset "utf-8"; - -html { - position: relative; - font-family: Arial, Helvetica, sans-serif; - font-size: 10px !important; - line-height: 10px !important; - margin: 0; - padding: 0; - width: 100%; - height: 100%; -} - -body { - font-size: 1.6rem; - line-height: 1.2rem; - color: #333333; - background-color: #ffffff; - margin: 0; - padding: 0; -} - -*:focus, .ebInput:focus, .ebIcon:focus, .ebCheckbox:focus+.ebCheckbox-inputStatus:after, - .ebRadioBtn:focus+.ebRadioBtn-inputStatus:after, textarea:focus, button:focus, - i:focus { - /** - * FF outline do not looks same as Chrome so adding box shadow - * FF outline is not working as expected - **/ - /* - * one way of outline - outline: #4d90fe auto 5px; - box-shadow: 0 0 0 1px #4d90fe; - -webkit-box-shadow: none; - */ - outline: none; // - box-shadow: 0 0 2px 1px #FFFFFF; -} - -h1, h2, h3, h4, h5, h6 { - color: #4d4d4d; - font-weight: bold; -} - -h1 { - line-height: 3.2rem; - font-size: 3.2rem; - font-weight: normal; - padding: 0.6rem 0; - margin: 0 0 0.6rem 0; -} - -h2 { - border-bottom: #000000 solid 1px; - line-height: 2.0rem; - font-size: 2.0rem; - font-weight: normal; - padding: 1.2rem 0 0.7rem 0; - margin: 0 0 0.4rem 0; -} - -h3 { - border-bottom: #7f7f7f solid 1px; - line-height: 1.6rem; - font-size: 1.6rem; - padding: 1.2rem 0 0.7rem 0; - margin: 0 0 0.4rem 0; - font-weight: normal; - color: #333333; -} - -h4 { - border-bottom: #b2b2b2 solid 1px; - line-height: 1.2rem; - font-size: 1.2rem; - padding: 0.6rem 0; - margin: 0 0 0.6rem 0; - font-weight: bold; - color: #333333; -} - -.ebLayout-SectionSubheading h3 { - float: left; - margin: 0; - border-bottom: none; -} - -/* System Bar */ -.ebSystemBar { - position: relative; - width: 100%; - height: 40px; - border-top: 4px solid #0066b3; - background-image: linear-gradient(180deg, #ffffff 0%, #f4f4f4 100%); - box-shadow: 0 1px 2px #D2D2D2; -} - -.ebSystemBar::before { - position: absolute; - top: -4px; - left: 0; - width: 100%; - height: 4px; - content: ""; - font-size: 0; - background: #0066b3; - background: -o-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 - 75%, #db0050 100%); - background: -moz-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, - #151f77 75%, #db0050 100%); - background: -webkit-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, - #151f77 75%, #db0050 100%); - background: -ms-linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 - 75%, #db0050 100%); - background: -webkit-gradient(linear, left top, right top, color-stop(0.1, #a2c517), - color-stop(0.3, #009046), color-stop(0.5, #0082b6), - color-stop(0.75, #151f77), color-stop(1, #db0050)); - background: linear-gradient(left, #a2c517 10%, #009046 30%, #0082b6 50%, #151f77 75% - , #db0050 100%); -} - -.ebSystemBar-logo { - position: absolute; - top: 0; - bottom: 0; - left: 0; - height: 40px; - width: 20px; - padding: 0 10px; - background: url('../resources/systemBar/econ01.svg') no-repeat center - center transparent; - background-size: 20px; -} - -.ebSystemBar-topMenuName { - display: inline-block; - padding: 0 5px 0 40px; - margin: 0; - line-height: 40px; - font-size: 16.8px; - color: #58585A; -} - -.ebSystemBar-topMenu { - position: absolute; - top: 0; - bottom: 0; - left: 50px; - list-style: none; - height: 40px; - margin: 0; - padding: 0; -} - -.ebSystemBar-topMenu li { - display: inline-block; -} - -.ebSystemBar-topMenu a { - padding: 0 5px 0 15px; - margin: 0; - font-size: 1.6em; - line-height: 40px; - color: #58585a; - cursor: pointer; - text-decoration: none; -} - -.ebSystemBar-topMenu a:hover { - color: #0066B3; -} - -.ebSystemBar-rightButton { - float: right; - display: inline-block; - line-height: 40px; - vertical-align: middle; -} - -.ebSystemBar-rightButton a { - display: block; - padding: 0 18px 0 18px; - font-size: 1.3rem; - color: #0066B3; - background-color: transparent; - background-repeat: no-repeat; - background-position: 18px center; - border-left: solid 1px #D2D2D2; -} - -.ebSystemBar-rightButton a:hover { - text-decoration: underline; -} - -.ebSystemBar-rightButton:hover { - background-image: linear-gradient(180deg, #f2f2f2 0%, #e8e8e8 100%); -} - -@media screen and (max-width: 640px) { - .ebSystemBar-topBar-rightButton a { - width: 0; - padding-left: 34px; - text-indent: -9999px; - } -} - -/* Inline Message */ -.ebInlineMessage { - padding: 5px 15px 0px 7px; - font-size: 0; - position: fixed; - bottom: 0; - left: 2; - width: calc(100% - 30px); - height: 66px; - border: 3px solid #adadad; - background-color: #FFFFFF; -} - -.ebInlineMessage-iconHolder, .ebInlineMessage-contentHolder { - display: inline-block; - vertical-align: top; -} - -.ebInlineMessage-iconHolder { - width: 20px; - margin: 0 12px 0 0; -} - -.ebInlineMessage-contentHolder { - width: calc(100% - 32px); - font-size: 1.2rem; -} - -.ebInlineMessage-header { - margin-top: 3px; - font-size: 14px; - line-height: 14px; -} - -.ebInlineMessage-separator { - height: 1px; - margin: 12px 0; - background-color: #adadad; - opacity: 0.3; -} - -.ebInlineMessage-description { - color: #666666; - white-space: pre; -} - -/* Table */ -.ebTable { - margin: 0; - padding: 0; - table-layout: fixed; - border-left: 1px solid #cccccc; // - ewatkmi: added for visible border; - border-right: 1px solid #cccccc; // - ewatkmi: added for visible border; - border-bottom: 1px solid #cccccc; // - ewatkmi: added for visible border; - border-collapse: collapse; - border-spacing: 0; - color: #1a1a1a; -} - -.ebTable_fullW { - width: 100%; -} - -.ebTable-th_resizable, .ebTable-th_sortable { - position: relative; -} - -.ebTable-th_resizable .ebTable-headerResize { - position: absolute; - top: -20px; - bottom: -20px; - right: -12px; - width: 10px; - cursor: col-resize; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; -} - -.ebTable-th_sortable { - cursor: pointer !important; -} - -.ebTable-th_sortable .ebTable-header { - display: flex; - flex-wrap: nowrap; - flex-direction: row; - align-items: center; -} - -.ebTable-th_sortable .ebTable-headerText { - flex-shrink: 1; - flex-grow: 0; - margin-right: 8px; - box-sizing: border-box; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; -} - -.ebTable-th_sortable .ebTable-headerSort { - flex-grow: 0; - flex-shrink: 0; - flex-basis: 10px; - margin-left: 4px; -} - -.ebTable-th_sortable .ebTable-headerSortOrder { - flex-grow: 1; - color: #999999; - font-weight: normal; -} - -.ebTable-header { - position: relative; - display: block; - width: 100%; - -moz-box-sizing: border-box; - box-sizing: border-box; -} - -.ebTable-headerText { - padding: 4px 0; - display: inline-block; - vertical-align: middle; - width: 100%; - overflow: hidden; - white-space: nowrap; - text-overflow: ellipsis; -} - -.ebTable thead tr { - height: 3.2rem; - font-size: 1.2rem; - font-weight: bold; - text-align: left; -} - -.ebTable thead tr th { - padding-left: 1.2rem; - padding-right: 1.2rem; - text-align: left; - cursor: default; - border-top: #cccccc solid 1px; - border-bottom: #cccccc solid 1px; - border-right: #e6e6e6 solid 1px; - overflow: hidden; - text-overflow: ellipsis; - white-space: nowrap; -} - -.ebTable thead tr th:last-child { - border-right: none; -} - -.ebTable thead tr:hover { - background: none; -} - -.ebTable thead tr:active { - background: none; -} - -.ebTable tbody tr { - height: 3.2rem; - font-size: 1.2rem; - border-bottom: #e6e6e6 solid 1px; -} - -.ebTable tbody tr td { - margin: 0; - padding: 0 1.2rem; - overflow: hidden; - text-overflow: ellipsis; - white-space: nowrap; - cursor: default; - border-right: #e6e6e6 solid 1px; -} - -.ebTable tbody tr td:last-child { - border-right: none; -} - -.ebTable_striped tbody tr { - border-bottom: none; -} - -.ebTable_striped tbody tr td { - border-right: none; -} - -.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #f2f2f2; -} - -.ebTable_striped tbody tr:nth-of-type(odd) { // - ewatkmi: added for nested tables; - background-color: #ffffff; -} - -.ebTable_compact tbody tr { - height: 2.6rem; -} - -.ebTable_expandableStriped { - border-collapse: separate; -} - -.ebTable_expandableStriped tbody tr { - border-bottom: none; -} - -.ebTable_expandableStriped tbody tr td { - border-right: none; -} - -.ebTable_expandableStriped tbody tr:nth-of-type(4n-1), - .ebTable_expandableStriped tbody tr:nth-of-type(4n) { - background-color: #f2f2f2; -} - -.ebTable_pinstripe tr td { - border-bottom: #e6e6e6 solid 1px; -} - -.ebTable_color_paleBlue.ebTable thead tr th { - background-color: #99ddee; - border-top: none; - border-bottom: none; -} - -.ebTable_color_paleBlue.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #e6f6fb; -} - -.ebTable_color_purple.ebTable thead tr th { - background-color: #ca9bc1; - border-top: none; - border-bottom: none; -} - -.ebTable_color_purple.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #f2e6ef; -} - -.ebTable_color_darkGreen.ebTable thead tr th { - background-color: #99c0bf; - border-top: none; - border-bottom: none; -} - -.ebTable_color_darkGreen.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #e6efef; -} - -.ebTable_color_green.ebTable thead tr th { - background-color: #d0e3a2; - border-top: none; - border-bottom: none; -} - -.ebTable_color_green.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #f3f8e8; -} - -.ebTable_color_yellow.ebTable thead tr th { - background-color: #fde499; - border-top: none; - border-bottom: none; -} - -.ebTable_color_yellow.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #fff8e6; -} - -.ebTable_color_orange.ebTable thead tr th { - background-color: #f9d099; - border-top: none; - border-bottom: none; -} - -.ebTable_color_orange.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #fef3e6; -} - -.ebTable_color_red.ebTable thead tr th { - background-color: #f4a6a3; - border-top: none; - border-bottom: none; -} - -.ebTable_color_red.ebTable_striped tbody tr:nth-of-type(even) { - background-color: #fce9e8; -} - -.ebTable_borderTop_none thead tr th { - border-top: none; -} - -.ebTable_verticalBorders_none thead tr th, .ebTable_verticalBorders_none tr td - { - border-right: none !important; - border-left: none !important; -} - -.ebTable_wrapHeaders th { - white-space: normal !important; - text-overflow: inherit !important; -} - -.ebTable_wrapHeaders th .ebTable-headerText { - white-space: normal !important; - text-overflow: inherit !important; -} - -.ebTable-expandableRow { - height: inherit !important; - display: none; -} - -.ebTable-expandableRow_expanded { - display: table-row; -} - -.ebTable-expandableRow>td { - padding: 0 !important; -} - -.ebTable-expandableRow>td>div { - overflow: hidden; - height: 0; - transition: height 0.3s ease-in-out; -} -/** - * Hover/Active/Selected Effects - * - * Modifiers: - * .ebTable_hoverActive_none (disables native hover and active selectors, primarily for pin columns plugin) - */ -.ebTable { - /** Hover effect **/ - -} - -.ebTable.ebTable:not (.ebTable_hoverActive_none ) tbody tr:not (.ebTable-expandableRow - ):not (.headerRow ):hover>*, .ebTable tbody tr:not (.ebTable-expandableRow - ):not (.headerRow ).ebTableRow_hover>* { - background-image: linear-gradient(0deg, rgba(0, 102, 179, 0.1), - rgba(0, 102, 179, 0.1)); -} - -.ebTable.ebTable_highlightedEffect_solid tbody tr:not (.ebTable-expandableRow - ).ebTableRow_highlighted>* { - background-color: #ffffff !important; -} - -/* Context Menu */ -.ebContextMenu { - position: relative; - width: 16px; - height: 16px; -} - -.ebContextMenu:focus { - outline: none; -} - -.ebContextMenu-ExpandBtn, .ebContextMenu-expandBtn { - width: 16px; - height: 16px; - position: relative; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; -} - -.ebContextMenu-ExpandBtn:focus, .ebContextMenu-expandBtn:focus { - outline: none; -} - -.ebContextMenu-Dropdown, .ebContextMenu-body { - position: absolute; - z-index: 1500; - min-width: 60px; - width: auto; - height: auto; - white-space: nowrap; - overflow: hidden; - text-overflow: ellipsis; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; - box-shadow: 5px 5px 5px #87888A; -} - -.ebContextMenu-Dropdown_corner_default, - .ebContextMenu-body_corner_default { - position: absolute; - top: 20px; - left: 0px; -} - -.ebContextMenu-Dropdown_corner_topRight, - .ebContextMenu-body_corner_topRight { - position: absolute; - top: 20px; - right: 0px; -} - -.ebContextMenu-Dropdown_corner_bottomLeft, - .ebContextMenu-body_corner_bottomLeft { - position: absolute; - bottom: 20px; - left: 0px; -} - -.ebContextMenu-Dropdown_corner_bottomRight, - .ebContextMenu-body_corner_bottomRight { - position: absolute; - bottom: 20px; - right: 0px; -} - -.ebContextMenu-Dropdown_visible_false, .ebContextMenu-body_visible_false - { - visibility: hidden; -} - -.ebContextMenu-Dropdown_visible_true, .ebContextMenu-body_visible_true { - display: block; -} - -/* Component List */ -.ebComponentList { - position: relative; - z-index: 1500; - padding: 4px 0; - margin: 0; - color: #333333; - list-style: none; - background-color: #ffffff; - border: #bfbfbf solid 1px; - box-shadow: 0 0 5px 0 rgba(0, 0, 0, 0.2); - border-radius: 3px; - -moz-box-sizing: border-box; - box-sizing: border-box; -} - -.ebComponentList-group, .ebComponentList-item { - padding: 0 0.8rem; - line-height: 2.4rem; - font-size: 1.2rem; - background-color: #ffffff; -} - -.ebComponentList-iconHolder { - display: inline-block; - vertical-align: middle; - width: 16px; - padding-right: 8px; -} - -.ebComponentList-item { - cursor: pointer; -} - -.ebComponentList-item-name { - display: inline-block; - font-size: 12px; - text-overflow: ellipsis; - overflow: hidden; - width: calc(100% - 24px); - vertical-align: middle; -} - -.ebComponentList-item_icon { - font-size: 0; -} - -.ebComponentList-link, .ebComponentList-item, .ebComponentList-item>*, - .ebComponentList-group-header { - white-space: nowrap; - text-overflow: ellipsis; - overflow: hidden; -} - -.ebComponentList-group { - display: block; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header, - .ebComponentList-group_expandable_expanded>.ebComponentList-group-header - { - font-size: 0; - cursor: pointer; - white-space: nowrap; - height: 24px; - vertical-align: middle; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header .ebComponentList-iconHolder+.ebComponentList-group-name, - .ebComponentList-group_expandable_expanded>.ebComponentList-group-header .ebComponentList-iconHolder+.ebComponentList-group-name - { - width: calc(100% - 40px); -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-inner, - .ebComponentList-group_expandable_expanded>.ebComponentList-inner { - padding: 0 0 0 24px; - margin: 0 -0.8rem; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header - { - border: none; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-item - { - overflow: hidden; - padding: 0; - margin: 0; - height: 0; - opacity: 0; - transition: height 0.2s linear, padding 0.075s 0.075s linear, margin - 0.075s 0.075s linear, opacity 0.075s linear; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group_expandable_collapsed .ebComponentList-group-header, - .ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group_expandable_expanded .ebComponentList-group-header - { - overflow: hidden; - padding: 0; - margin: 0; - height: 0; - opacity: 0; - transition: height 0.2s linear, padding 0.075s 0.075s linear, margin - 0.075s 0.075s linear, opacity 0.075s linear; -} - -.ebComponentList-group_expandable_collapsed>.ebComponentList-inner .ebComponentList-group>.ebComponentList-inner - { - padding: 0; - margin: 0; - transition: padding 0.1s 0.1s linear, margin 0.1s 0.1s linear; -} - -.ebComponentList-group_expandable_expanded>.ebComponentList-group-header - { - border-bottom: 1px solid #999; -} - -.ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-item - { - overflow: hidden; - height: 24px; - transition: height 0.2s linear, padding 0.075s linear, margin 0.075s - linear, opacity 0.15s 0.15s linear; -} - -.ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-group_expandable_expanded>.ebComponentList-group-header, - .ebComponentList-group_expandable_expanded>.ebComponentList-inner>.ebComponentList-group_expandable_collapsed>.ebComponentList-group-header - { - overflow: hidden; - height: 24px; - text-overflow: ellipsis; - transition: height 0.2s linear, padding 0.075s linear, margin 0.075s - linear, opacity 0.15s 0.15s linear; -} - -.ebComponentList-group:not (.ebComponentList-group_expandable_collapsed - ):not (.ebComponentList-group_expandable_expanded ) >.ebComponentList-group-header - { - cursor: default !important; - pointer-events: none !important; - -ms-touch-action: none !important; - touch-action: none !important; - -khtml-user-select: none !important; - -moz-user-select: none !important; - -o-user-select: none !important; - -webkit-user-select: none !important; - user-select: none; -} - -.ebComponentList-group-header { - font-size: 1.2rem; - font-weight: bold; - line-height: 2.4rem; - border-bottom: 1px solid #999; - background-color: #ffffff; -} - -.ebComponentList-group-header_icon { - font-size: 0; -} - -.ebComponentList-group-header_icon>.ebComponentList-group-name { - width: calc(100% - 24px); -} - -.ebComponentList-group-name { - display: inline-block; - width: calc(100% - 16px); - font-size: 1.2rem; - line-height: 2.4rem; - font-weight: bold; - text-overflow: ellipsis; - overflow: hidden; - white-space: nowrap; - vertical-align: middle; -} - -.ebComponentList-inner { - margin: 0 -0.8rem; - padding: 4px 0 0 0; -} - -.ebComponentList-link { - display: block; -} - -.ebComponentList-link:hover { - text-decoration: none; -} - -.ebComponentList-separator { - height: 1px; - margin: 0.4rem; - background-color: #E6E6E6; -} - -.ebComponentList_focus_forced .ebComponentList-item:hover { - background-color: transparent; -} - -.ebComponentList_focus_forced .ebComponentList-item_focused:hover { - background-color: #e6f0f7; -} - -.ebComponentList:not (.ebComponentList_focus_forced ) .ebComponentList-item:hover - { - background-color: #e6f0f7; -} - -.ebComponentList_focus_forced .ebComponentList-item:active, - .ebComponentList:not (.ebComponentList_focus_forced ) .ebComponentList-item:active - { - background-color: #cce0f0; -} - -.ebComponentList-item { - /* Fixes MultiSelectBox ellipsis bug in Firefox */ - margin: 0px !important; - font-size: 1em !important; -} - -.ebComponentList-item_focused { - background-color: #e6f0f7; -} - -.ebComponentList-item_disabled { - color: #b0b0af; - cursor: not-allowed !important; -} - -.ebComponentList-item_disabled:hover, .ebComponentList-item_disabled:active - { - background-color: inherit !important; -} - -.ebComponentList-item_selected { - position: relative; - cursor: default; -} - -.ebComponentList-item_selected>.ebComponentList-link { - cursor: default; - color: #333333; - cursor: default !important; - pointer-events: none !important; - -ms-touch-action: none !important; - touch-action: none !important; - -khtml-user-select: none !important; - -moz-user-select: none !important; - -o-user-select: none !important; - -webkit-user-select: none !important; - user-select: none; -} - -.ebComponentList-item_selected:before { - position: absolute; - content: ""; - left: 0; - top: 0; - bottom: 0; - width: 100%; - opacity: .2; - background-color: #0967b2; -} - -.ebComponentList-item>.ebComponentList-checkboxHolder>.ebCheckbox { - margin-left: 1px; -} - -.ebComponentList-item>.ebComponentList-checkboxHolder>.ebCheckbox-label - { - padding-left: 3px; - overflow: hidden; - font-size: 12px; - line-height: 2.4rem; - text-overflow: ellipsis; - width: calc(100% - 24px); -} - -.ebComponentList-info { - color: #333333; - font-style: italic; - text-align: center; -} - -.ebComponentList-info:hover { - background-color: #ffffff; -} - -.ebComponentList-info:active { - background-color: #ffffff; -} - -.ebComponentList-info, .ebComponentList-loader { - display: none; - margin: 0.6rem; - cursor: default; -} - -.ebComponentList_info .ebComponentList-group, .ebComponentList_info .ebComponentList-separator, - .ebComponentList_info .ebComponentList-item { - display: none; -} - -.ebComponentList_info .ebComponentList-info { - display: block; -} - -.ebComponentList_loading { - min-height: 34px; -} - -.ebComponentList_loading .ebComponentList-loader { - display: block; -} - -.ebComponentList_loading .ebComponentList-item_selected:before { - display: none; -} - -.ebComponentList_loading>.ebComponentList-group, - .ebComponentList_loading>.ebComponentList-item, - .ebComponentList_loading>.ebComponentList-items>.ebComponentList-group, - .ebComponentList_loading>.ebComponentList-items>.ebComponentList-item { - opacity: 0.4; -} - -/* Scrollbar */ -.eb_scrollbar { - -webkit-overflow-scrolling: touch; - overflow: auto; -} - -.eb_scrollbar::-webkit-scrollbar { - width: 14px; - height: 14px; -} - -.eb_scrollbar::-webkit-scrollbar-track { - background-color: #f0f0f0; - background-clip: content-box; -} - -.eb_scrollbar::-webkit-scrollbar-thumb { - background-color: #cccccc; - border-radius: 3px; - transition: all 0.2s linear; - background-clip: content-box; -} - -.eb_scrollbar::-webkit-scrollbar-thumb:hover { - background-color: #999999; -} - -.eb_scrollbar::-webkit-scrollbar-button { - width: 14px; - height: 14px; - background-repeat: no-repeat; - background-color: #f0f0f0; - background-position: center; -} - -.eb_scrollbar::-webkit-scrollbar-button:hover { - background-color: #cccccc; -} - -.eb_scrollbar::-webkit-scrollbar-button:vertical:decrement { - background-position: center 4px; - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M0.293,3.293l3-3C3.488,0.098,3.744,0,4,0s0.512,0.098,0.707,0.293l3,3c0.391,0.391,0.391,1.023,0,1.414 s-1.023,0.391-1.414,0L4,2.414L1.707,4.707c-0.391,0.391-1.023,0.391-1.414,0S-0.098,3.684,0.293,3.293z'/></svg>"); - border-top-left-radius: 2px; - border-top-right-radius: 2px; -} - -.eb_scrollbar::-webkit-scrollbar-button:vertical:increment { - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M7.707,1.707l-3,3C4.512,4.902,4.255,5,4,5S3.488,4.902,3.292,4.707l-3-3c-0.391-0.391-0.391-1.023,0-1.414 s1.023-0.391,1.414,0L4,2.586l2.293-2.293c0.391-0.391,1.023-0.391,1.414,0S8.098,1.316,7.707,1.707z'/></svg>"); - border-bottom-left-radius: 2px; - border-bottom-right-radius: 2px; -} - -.eb_scrollbar::-webkit-scrollbar-button:horizontal:decrement { - background-position: 4px center; - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M4.707,6.293c0.391,0.391,0.391,1.023,0,1.414C4.512,7.902,4.256,8,4,8S3.488,7.902,3.293,7.707l-3-3 C0.105,4.52,0,4.266,0,4s0.105-0.52,0.293-0.707l3-3c0.391-0.391,1.023-0.391,1.414,0c0.391,0.39,0.391,1.023,0,1.414L2.414,4 L4.707,6.293z'/></svg>"); - border-bottom-left-radius: 2px; - border-top-left-radius: 2px; -} - -.eb_scrollbar::-webkit-scrollbar-button:horizontal:increment { - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M0.293,1.707c-0.391-0.391-0.391-1.023,0-1.414C0.488,0.098,0.744,0,1,0s0.512,0.098,0.707,0.293l3,3 C4.895,3.48,5,3.734,5,4s-0.105,0.52-0.293,0.707l-3,3c-0.391,0.391-1.023,0.391-1.414,0s-0.391-1.023,0-1.414L2.586,4L0.293,1.707z'/></svg>"); - border-bottom-right-radius: 2px; - border-top-right-radius: 2px; -} - -/* Input */ -.ebInput { - display: inline-block; - vertical-align: middle; - text-align: left; - font-size: 1.2rem; - width: 140px; - height: 2.4rem; - padding: 0.4rem 0.6rem; - border: 1px solid #b3b3b3; - -moz-box-sizing: border-box; - box-sizing: border-box; - border-radius: 3px; - box-shadow: inset 1px 1px 0 0 #cccccc; - -webkit-appearance: none; - -moz-appearance: none; - -ms-appearance: none; - appearance: none; -} - -.ebInput_wMargin { - margin: 6px; -} - -.ebInput_txtCenter { - text-align: center; -} - -.ebInput_miniW, .ebInput_width_mini { - width: 40px; -} - -.ebInput_smallW, .ebInput_width_small { - width: 80px; -} - -.ebInput_longW, .ebInput_width_long { - width: 180px; -} - -.ebInput_xLongW, .ebInput_width_xLong { - width: 220px; -} - -.ebInput_width_full { - min-width: 40px; - width: 100%; -} - -.ebInput_noRightSide { - border-width: 1px 0 1px 1px; - border-radius: 3px 0 0 3px; -} - -.ebInput_noLeftSide { - border-width: 1px 1px 1px 0; - border-radius: 0 3px 3px 0; - box-shadow: inset 0 1px 0 0 #cccccc; -} - -.ebInput:hover { - border-color: #666666; -} - -.ebInput[readonly] { - cursor: text; // - box-shadow: none; - border-color: #E3E3E3; - background-color: #f0f0f0; - color: #b2b2b2; -} - -.ebInput[readonly]:hover { // - border-color: #E3E3E3; -} - -.ebInput_disabled, .ebInput:disabled { - color: #B2B2B2; - border-color: #B2B2B2; - background-color: rgba(0, 0, 0, 0.05); - -webkit-text-fill-color: #b2b2b2; - opacity: 1; - -ms-touch-action: none !important; - touch-action: none !important; - box-shadow: inset 1px 1px 0 0 #cccccc; -} - -.ebInput_borderColor { - border-color: #b3b3b3; -} - -.ebInput_borderColor_red { - border-color: #e32119; -} - -.ebInput_status_none { - border-color: #b3b3b3; -} - -.ebInput_status_warning { - border-color: #f08a00; -} - -.ebInput_status_error { - border-color: #e32119; -} - -.ebInput.eb_wMargin+.ebInput-status { - margin: -0.2rem 0.8rem 0 0.6rem; -} - -.ebInput-status { - display: block; - margin: 0.4rem 0 0 0; - line-height: 1.2rem; - min-height: 1.8rem; - font-size: 1.2rem; - font-weight: normal; -} - -.ebInput-statusOk, .ebInput-statusError { - vertical-align: middle; -} - -.ebInput-statusOk:before, .ebInput-statusError:before { - display: inline-block; - vertical-align: middle; - margin: 0 0.6rem 0 0; - width: 1.2rem; - height: 1.2rem; - content: ''; - background-repeat: no-repeat; -} - -.ebInput-statusInfo { - vertical-align: middle; - color: #8d8d8d; -} - -.ebInput-statusOk { - color: #89ba17; - display: none; -} - -.ebInput-statusOk:before { - background-image: url('../resources/form/valid_icon.svg'); -} - -.ebInput-statusError { - color: #e32119; - display: none; -} - -.ebInput-statusError:before { - background-image: url('../resources/form/invalid_icon.svg'); -} - -.ebInput-status_none { - display: none; -} - -.ebInput-status_hide .ebInput-statusOk, .ebInput-status_hide .ebInput-statusError, - .ebInput-status_hide .ebInput-statusInfo { - display: none; -} - -.ebInput-status_info .ebInput-statusInfo { - display: inline-block; -} - -.ebInput-status_info .ebInput-statusOk, .ebInput-status_info .ebInput-statusError - { - display: none; -} - -.ebInput-status_ok .ebInput-statusOk { - display: inline-block; -} - -.ebInput-status_ok .ebInput-statusError, .ebInput-status_ok .ebInput-statusInfo - { - display: none; -} - -.ebInput-status_error .ebInput-statusError { - display: inline-block; -} - -.ebInput-status_error .ebInput-statusOk, .ebInput-status_error .ebInput-statusInfo - { - display: none; -} - -.ebInput:not (.ebInput_validation_focusLost ):valid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusOk { - display: inline-block; -} - -.ebInput:not (.ebInput_validation_focusLost ):invalid:not (.ebInput_borderColor - ):not (.ebInput_status_warning ):not (.ebInput_status_none ) { - border-color: #e32119; -} - -.ebInput:not (.ebInput_validation_focusLost ):invalid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusError { - display: inline-block; -} - -.ebInput:not (.ebInput_validation_focusLost ):invalid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusInfo { - display: none; -} - -.ebInput.ebInput_validation_focusLost:not (:focus ):valid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusOk { - display: inline-block; -} - -.ebInput.ebInput_validation_focusLost:not (:focus ):invalid:not (.ebInput_borderColor - ):not (.ebInput_status_warning ):not (.ebInput_status_none ) { - border-color: #e32119; -} - -.ebInput.ebInput_validation_focusLost:not (:focus ):invalid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusError { - display: inline-block; -} - -.ebInput.ebInput_validation_focusLost:not (:focus ):invalid+.ebInput-status:not - (.ebInput-status_hide ):not (.ebInput-status_info ):not (.ebInput-status_ok - ):not (.ebInput-status_error ) .ebInput-statusInfo { - display: none; -} - -/* Textarea */ -.ebTextArea { - -webkit-overflow-scrolling: touch; - overflow: auto; - display: inline-block; - vertical-align: middle; - text-align: left; - font-size: 1.2rem; - width: 140px; - padding: 0.4rem 0.6rem; - margin: 0; - border: 1px solid #b3b3b3; - font-family: arial; - -moz-box-sizing: border-box; - box-sizing: border-box; - border-radius: 3px; - box-shadow: inset 1px 1px 0 0 #cccccc; - -webkit-appearance: none; - -moz-appearance: none; - -ms-appearance: none; - appearance: none; -} - -.ebTextArea::-webkit-scrollbar { - width: 14px; - height: 14px; -} - -.ebTextArea::-webkit-scrollbar-track { - background-color: #f0f0f0; - background-clip: content-box; -} - -.ebTextArea::-webkit-scrollbar-thumb { - background-color: #cccccc; - border-radius: 3px; - transition: all 0.2s linear; - background-clip: content-box; -} - -.ebTextArea::-webkit-scrollbar-thumb:hover { - background-color: #999999; -} - -.ebTextArea::-webkit-scrollbar-button { - width: 14px; - height: 14px; - background-repeat: no-repeat; - background-color: #f0f0f0; - background-position: center; -} - -.ebTextArea::-webkit-scrollbar-button:hover { - background-color: #cccccc; -} - -.ebTextArea::-webkit-scrollbar-button:vertical:decrement { - background-position: center 4px; - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M0.293,3.293l3-3C3.488,0.098,3.744,0,4,0s0.512,0.098,0.707,0.293l3,3c0.391,0.391,0.391,1.023,0,1.414 s-1.023,0.391-1.414,0L4,2.414L1.707,4.707c-0.391,0.391-1.023,0.391-1.414,0S-0.098,3.684,0.293,3.293z'/></svg>"); - border-top-left-radius: 2px; - border-top-right-radius: 2px; -} - -.ebTextArea::-webkit-scrollbar-button:vertical:increment { - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='8px' height='5px' viewBox='0 0 8 5' enable-background='new 0 0 8 5' xml:space='preserve'><path fill='#333333' d='M7.707,1.707l-3,3C4.512,4.902,4.255,5,4,5S3.488,4.902,3.292,4.707l-3-3c-0.391-0.391-0.391-1.023,0-1.414 s1.023-0.391,1.414,0L4,2.586l2.293-2.293c0.391-0.391,1.023-0.391,1.414,0S8.098,1.316,7.707,1.707z'/></svg>"); - border-bottom-left-radius: 2px; - border-bottom-right-radius: 2px; -} - -.ebTextArea::-webkit-scrollbar-button:horizontal:decrement { - background-position: 4px center; - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M4.707,6.293c0.391,0.391,0.391,1.023,0,1.414C4.512,7.902,4.256,8,4,8S3.488,7.902,3.293,7.707l-3-3 C0.105,4.52,0,4.266,0,4s0.105-0.52,0.293-0.707l3-3c0.391-0.391,1.023-0.391,1.414,0c0.391,0.39,0.391,1.023,0,1.414L2.414,4 L4.707,6.293z'/></svg>"); - border-bottom-left-radius: 2px; - border-top-left-radius: 2px; -} - -.ebTextArea::-webkit-scrollbar-button:horizontal:increment { - background-image: - url("data:image/svg+xml;utf8,<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' width='5px' height='8px' viewBox='0 0 5 8' enable-background='new 0 0 5 8' xml:space='preserve'><defs></defs><path fill='#333333' d='M0.293,1.707c-0.391-0.391-0.391-1.023,0-1.414C0.488,0.098,0.744,0,1,0s0.512,0.098,0.707,0.293l3,3 C4.895,3.48,5,3.734,5,4s-0.105,0.52-0.293,0.707l-3,3c-0.391,0.391-1.023,0.391-1.414,0s-0.391-1.023,0-1.414L2.586,4L0.293,1.707z'/></svg>"); - border-bottom-right-radius: 2px; - border-top-right-radius: 2px; -} - -.ebTextArea_noMargin { - margin: 0; -} - -.ebTextArea_txtCenter { - text-align: center; -} - -.ebTextArea_miniW, .ebTextArea_width_mini { - width: 40px; -} - -.ebTextArea_smallW, .ebTextArea_width_small { - width: 80px; -} - -.ebTextArea_longW, .ebTextArea_width_long { - width: 180px; -} - -.ebTextArea_xLongW, .ebTextArea_width_xLong { - width: 220px; -} - -.ebTextArea_width_full { - min-width: 40px; - width: 100%; -} - -.ebTextArea_noRightSide { - border-width: 1px 0 1px 1px; - border-radius: 3px 0 0 3px; -} - -.ebTextArea_noLeftSide { - border-width: 1px 1px 1px 0; - border-radius: 0 3px 3px 0; -} - -.ebTextArea:hover { - border-color: #666666; -} - -.ebTextArea[readonly] { - cursor: text; - border-color: #E3E3E3; - background-color: #f0f0f0; - color: #b2b2b2; -} - -.ebTextArea[readonly]:hover { // - border-color: #E3E3E3; -} - -.ebTextArea_disabled, .ebTextArea:disabled { - color: #B2B2B2; - border-color: #B2B2B2; - background-color: rgba(0, 0, 0, 0.05); - -ms-touch-action: none; - touch-action: none; - -webkit-text-fill-color: #b2b2b2; - opacity: 1; - box-shadow: inset 1px 1px 0 0 #cccccc; -} - -.ebTextArea_status_none { - border-color: #b3b3b3; -} - -.ebTextArea_status_warning { - border-color: #f08a00; -} - -.ebTextArea_status_error { - border-color: #e32119; -} - -.ebTextArea:invalid:not (.ebTextArea_status_warning ):not (.ebTextArea_status_none - ) { - border-color: #e32119; -} - -/* Button */ -.ebBtn { - position: relative; - display: inline-block; - vertical-align: middle; - color: #333333; - background-color: #ffffff; - border: none; - min-width: 60px; - box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); - border-radius: 3px; - -moz-box-sizing: border-box; - box-sizing: border-box; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.1) 100%); - padding: 0 8px; - height: 2.4rem; - font-size: 1.2rem; - white-space: nowrap; - text-decoration: none; - text-align: center; - cursor: pointer; -} - -a.ebBtn:hover { - color: #333; -} - -a.ebBtn:focus, a.ebBtn:active, a.ebBtn_active { - text-decoration: none; -} - -.ebBtn:focus { - outline: none; - box-shadow: 0 0 2px 1px #4d90fe, 0 0 0 1px rgba(0, 0, 0, 0.2) inset; -} - -.ebBtn_color_blue, .ebBtn_color_darkBlue, .ebBtn_color_paleBlue, - .ebBtn_color_darkGreen, .ebBtn_color_green, .ebBtn_color_orange, - .ebBtn_color_red, .ebBtn_color_purple { - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.3) 100%); - color: #F0F0F0 !important; -} - -.ebBtn_color_blue:hover, .ebBtn_color_darkBlue:hover, - .ebBtn_color_paleBlue:hover, .ebBtn_color_darkGreen:hover, - .ebBtn_color_green:hover, .ebBtn_color_orange:hover, .ebBtn_color_red:hover, - .ebBtn_color_purple:hover { - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.1) 100%); -} - -.ebBtn_color_blue { - background-color: #0966b3; -} - -.ebBtn_color_darkBlue { - background-color: #0066b3; -} - -.ebBtn_color_paleBlue { - background-color: #00A9D4; -} - -.ebBtn_color_darkGreen { - background-color: #00625F; -} - -.ebBtn_color_green { - background-color: #89BA17; -} - -.ebBtn_color_orange { - background-color: #F08A00; -} - -.ebBtn_color_red { - background-color: #E32119; -} - -.ebBtn_color_purple { - background-color: #953882; -} - -.ebBtn_small { - font-size: 1.1rem; - padding: 0 6px; - height: 2rem; -} - -.ebBtn_large { - font-size: 1.4rem; - padding: 0 10px; - height: 3.8rem; -} - -.ebBtn:hover { - text-decoration: none; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.15) 100%); -} - -.ebBtn_active, .ebBtn:active, .ebBtn_active:hover { - text-decoration: none; - box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px - rgba(0, 0, 0, 0.2); - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, - rgba(0, 0, 0, 0.2) 100%); -} - -.ebBtn:disabled, .ebBtn_disabled, .ebBtn:disabled:hover, .ebBtn_disabled:hover, - .ebBtn:disabled:active, .ebBtn_disabled:active { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; - background: rgba(0, 0, 0, 0.1); - color: #8d8d8d !important; -} - -.ebBtn:disabled .ebIcon, .ebBtn_disabled .ebIcon { - opacity: 0.3; -} - -.ebBtn_subtle { - background-image: none; - background-color: transparent; - box-shadow: none; - min-width: auto; -} - -.ebBtn_subtle:hover { - background-image: none; - box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); -} - -.ebBtn_subtle:focus { - box-shadow: 0 0 2px 1px #4d90fe, 0 0 0 1px rgba(0, 0, 0, 0.2) inset; -} - -.ebBtn_subtle:active, .ebBtn_subtle.ebBtn_subtle_active { - text-decoration: none; - box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px - rgba(0, 0, 0, 0.2); - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, - rgba(0, 0, 0, 0.2) 100%); -} - -.ebBtn_subtle:disabled, .ebBtn_subtle.ebBtn_subtle_disabled, - .ebBtn_subtle:disabled:hover, .ebBtn_subtle.ebBtn_subtle_disabled:hover, - .ebBtn_subtle:disabled:active, .ebBtn_subtle.ebBtn_subtle_disabled:active - { - background-color: transparent; - box-shadow: none; -} - -.ebBtn:active:focus, .ebBtn_active:focus { - box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px - rgba(0, 0, 0, 0.2), 0 0 2px 1px #4d90fe; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, - rgba(0, 0, 0, 0.2) 100%); -} - -/* Combobox */ -.ebCombobox { - position: relative; - display: inline-block; - vertical-align: middle; - white-space: nowrap; - margin: 0; - padding: 0; - height: 2.4rem; -} - -.ebCombobox_width_full { - min-width: 70px; - width: 100%; -} - -.ebCombobox_width_full .ebInput { - width: calc(100% - 30px); -} - -.ebCombobox-list, .ebCombobox-body { - position: absolute; - margin-top: 6px; - display: none; - width: 100%; -} - -.ebCombobox-list_rightAlign, .ebCombobox-body_rightAlign { - right: 0; -} - -.ebCombobox-Helper, .ebCombobox-helper { - position: relative; - display: inline-block; - vertical-align: middle; - width: 30px; - /*height: 100%; ewwatkmi: replaced with 2.4rem below*/ - height: 2.4rem; - cursor: pointer; - border: 1px solid #999999; - background-color: #ffffff; - -moz-box-sizing: border-box; - box-sizing: border-box; - border-radius: 0 3px 3px 0; - -webkit-appearance: none; - -moz-appearance: none; - -ms-appearance: none; - appearance: none; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.1) 100%); -} - -.ebCombobox-Helper:hover, .ebCombobox-helper:hover { - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.15) 100%); -} - -.ebCombobox-Helper:active, .ebCombobox-helper:active { - box-shadow: inset 2px 2px 3px 0 rgba(0, 0, 0, 0.35); - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, - rgba(0, 0, 0, 0.2) 100%); -} - -.ebCombobox-Helper:disabled, .ebCombobox-helper:disabled { - border-color: #b2b2b2; -} - -.ebCombobox-Helper:disabled, .ebCombobox-helper:disabled, - .ebCombobox-Helper:disabled:hover, .ebCombobox-helper:disabled:hover, - .ebCombobox-Helper:disabled:active, .ebCombobox-helper:disabled:active - { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; - background: #e5e5e5; - color: #B2B2B2; - cursor: not-allowed; - box-shadow: none; -} - -.ebCombobox-Helper .ebCombobox-iconHolder, .ebCombobox-helper .ebCombobox-iconHolder - { - display: inline-block; - opacity: 0.7; - cursor: pointer; - line-height: 2.2rem; -} - -.ebCombobox-Helper .ebCombobox-iconHolder .ebIcon, .ebCombobox-helper .ebCombobox-iconHolder .ebIcon - { - position: absolute; - top: 0; - bottom: 0; - left: 0; - right: 0; - margin: auto; -} - -.ebCombobox:hover>.ebCombobox-Helper, .ebCombobox:hover>.ebCombobox-helper - { - border-color: #666666; -} - -.ebCombobox - -.ebInput -:focus - -~ -.ebCombobox-list -, /*.ebCombobox .ebInput:focus ~ .ebCombobox-body,*/ -.ebCombobox -:active -> -.ebCombobox-list -, /*.ebCombobox:active > .ebCombobox-body*/ -{ -display -: - -block -; - - -} -.ebCombobox>.ebCombobox-list, .ebCombobox>.ebCombobox-body { - display: none; -} - -.ebCombobox_noMargin { - margin: 0; -} - -.ebCombobox_disabled, .ebCombobox_disabled *:hover { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; -} - -.ebCombobox_disabled .ebCombobox-iconHolder, .ebCombobox_disabled .ebCombobox-iconHolder:hover, - .ebCombobox_disabled .ebCombobox-iconHolder:active { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; - opacity: 0.3; -} - -.ebCombobox_disabled:hover>.ebCombobox-Helper, .ebCombobox_disabled:hover>.ebCombobox-helper - { - border-color: #b2b2b2; -} - -.ebCombobox_disabled:active>.ebCombobox-list, .ebCombobox_disabled:active>.ebCombobox-body - { - display: none; -} - -.ebCombobox_disabled .ebInput:focus ~ .ebCombobox-list, - .ebCombobox_disabled .ebInput:focus ~ .ebCombobox-body { - display: none; -} - -.ebCombobox_status_warning .ebInput { - border-color: #f08a00; -} - -.ebCombobox_status_error .ebInput { - border-color: #e32119; -} - -/* Switcher */ -.ebSwitcher { - position: relative; - height: 24px; - width: 84px; - display: block; - overflow: hidden; - cursor: pointer; - border: 1px solid #ccc; - border-radius: 3px; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; -} - -.ebSwitcher-checkbox { - display: none; -} - -.ebSwitcher-body { - position: relative; - font-size: 0; - white-space: nowrap; - top: 0; - left: 0; - width: 100%; - height: 100%; - transition: left 0.2s linear; -} - -.ebSwitcher-onLabel, .ebSwitcher-switch, .ebSwitcher-offLabel { - display: inline-block; - vertical-align: top; - overflow: hidden; - height: 100%; -} - -.ebSwitcher-onLabel, .ebSwitcher-offLabel { - width: calc(100% - 24px); - line-height: 2.4rem; - color: white; - text-align: center; - font-size: 1.2rem; -} - -.ebSwitcher-onLabel { - background-color: red; -} - -.ebSwitcher-onLabel2 { - background-color: #89ba17; -} - -.ebSwitcher-offLabel { - background-color: #89ba17; -} - -.ebSwitcher-offLabel2 { - background-color: red; -} - -.ebSwitcher-switch { - height: 24px; - width: 24px; - transition: left 0.2s; -} - -.ebSwitcher-switch::after { - content: ""; - position: absolute; - margin: -1px; - width: 24px; - height: 24px; - display: inline-block; - background: #ffffff; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.1) 100%); - border-radius: 3px; - border: 1px solid rgba(0, 0, 0, 0.2); -} - -.ebSwitcher-checkbox:not (:checked ) +.ebSwitcher-body { - left: calc(-100% + 24px); -} - -.ebSwitcher:focus { - /* - outline: #4d90fe auto 5px; - box-shadow: 0 0 0 1px #4d90fe; - -webkit-box-shadow: none; - */ - outline: none; - box-shadow: 0 0 2px 1px #4d90fe; -} - -.ebSwitcher_status_warning { - border-color: #f08a00; -} - -.ebSwitcher_status_error { - border-color: #e32119; -} - -.ebSwitcher_disabled { - cursor: not-allowed; -} - -.ebSwitcher_disabled .ebSwitcher-onLabel, .ebSwitcher_disabled .ebSwitcher-offLabel, - .ebSwitcher_disabled .ebSwitcher-switch::after { - background-color: #e5e5e5; - background-image: none; - color: #8d8d8d; -} - -/* Dropdown */ -.ebDropdown { - position: relative; - display: inline-block; - height: 2.4rem; - padding: 0; - margin: 0; -} - -.ebDropdown-list, .ebDropdown-body { - position: absolute; - margin-top: 6px; - display: none; - min-width: 100%; -} - -.ebDropdown-list_rightAlign, .ebDropdown-body_rightAlign { - right: 0; -} - -.ebDropdown-Header, .ebDropdown-header { - position: relative; - display: inline-block; - vertical-align: middle; - height: 100%; - min-width: 60px; - margin: 0; - padding: 6px 8px; - line-height: 1.2rem; - font-size: 1.2rem; - text-align: left; - text-decoration: none; - white-space: nowrap; - color: #333333; - background-color: #ffffff; - border: none; - cursor: pointer; - box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); - border-radius: 3px; - -moz-box-sizing: border-box; - box-sizing: border-box; - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.1) 100%); -} - -.ebDropdown-Header:hover, .ebDropdown-header:hover { - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, - rgba(0, 0, 0, 0.15) 100%); -} - -.ebDropdown-Header:active, .ebDropdown-header:active { - box-shadow: inset 2px 2px 2.5px 0 rgba(0, 0, 0, 0.35), inset 0 0 0 1px - rgba(0, 0, 0, 0.2); - background-image: linear-gradient(180deg, rgba(0, 0, 0, 0.2) 0%, - rgba(0, 0, 0, 0.2) 100%); -} - -.ebDropdown-Header .ebDropdown-caption, .ebDropdown-header .ebDropdown-caption - { - display: inline-block; - padding: 0 4px 0 0; - vertical-align: middle; - min-width: 27px; -} - -.ebDropdown-Header .ebDropdown-iconHolder, .ebDropdown-header .ebDropdown-iconHolder - { - display: inline-block; - cursor: pointer; - opacity: 0.7; -} - -.ebDropdown .ebDropdown-Header:focus+.ebDropdown-list, .ebDropdown .ebDropdown-header:focus+.ebDropdown-body, - .ebDropdown .ebDropdown-Header:active+.ebDropdown-list, .ebDropdown .ebDropdown-header:active+.ebDropdown-body, - .ebDropdown:focus>.ebDropdown-list, .ebDropdown:focus>.ebDropdown-body, - .ebDropdown:active>.ebDropdown-list, .ebDropdown:active>.ebDropdown-body - { - display: block; -} - -.ebDropdown_disabled .ebDropdown-Header, .ebDropdown_disabled .ebDropdown-header - { - background: rgba(0, 0, 0, 0.1); - color: #B2B2B2; -} - -.ebDropdown_disabled .ebDropdown-Header, .ebDropdown_disabled .ebDropdown-header, - .ebDropdown_disabled .ebDropdown-Header:hover, .ebDropdown_disabled .ebDropdown-header:hover, - .ebDropdown_disabled .ebDropdown-Header:active, .ebDropdown_disabled .ebDropdown-header:active - { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; -} - -.ebDropdown_disabled .ebDropdown-Header:hover, .ebDropdown_disabled .ebDropdown-header:hover, - .ebDropdown_disabled .ebDropdown-Header:active, .ebDropdown_disabled .ebDropdown-header:active - { - background: rgba(0, 0, 0, 0.1); - color: #B2B2B2; - box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.2); -} - -.ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder, - .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder, - .ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder:hover, - .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder:hover, - .ebDropdown_disabled .ebDropdown-Header .ebDropdown-iconHolder:active, - .ebDropdown_disabled .ebDropdown-header .ebDropdown-iconHolder:active { - -ms-touch-action: none !important; - cursor: not-allowed !important; - touch-action: none !important; - opacity: 0.3; -} - -.ebDropdown_disabled .ebDropdown-Header:focus+.ebDropdown-list, - .ebDropdown_disabled .ebDropdown-header:focus+.ebDropdown-body, - .ebDropdown_disabled .ebDropdown-Header:active+.ebDropdown-list, - .ebDropdown_disabled .ebDropdown-header:active+.ebDropdown-body, - .ebDropdown_disabled:focus>.ebDropdown-list, .ebDropdown_disabled:focus>.ebDropdown-body, - .ebDropdown_disabled:active>.ebDropdown-list, .ebDropdown_disabled:active>.ebDropdown-body - { - display: none; -} - -/* Icons */ -.ebIcon { - display: inline-block; - vertical-align: middle; - border: none; - height: 16px; - width: 16px; - line-height: 1.6rem; - background-repeat: no-repeat; - background-position: center; - background-color: transparent; - background-size: 100%; - -khtml-user-select: none; - -moz-user-select: none; - -o-user-select: none; - -webkit-user-select: none; - user-select: none; - /*small icons */ - /*16px icons*/ -} - -.ebIcon_interactive { - opacity: 0.7; - cursor: pointer; -} - -.ebIcon_interactive:hover { - opacity: 1.0; -} - -.ebIcon_interactive:active { - opacity: 0.4; -} - -.ebIcon_button { - margin: 10px; -} - -.ebIcon_noVertAlign { - vertical-align: inherit; -} - -.ebIcon_disabled { - cursor: default; -} - -.ebIcon_disabled, .ebIcon_disabled:hover, .ebIcon_disabled:active { - opacity: 0.3; -} - -.ebIcon_small { - width: 1rem; - height: 1rem; - line-height: 1rem; -} - -.ebIcon_big { - width: 2rem; - height: 2rem; - line-height: 2rem; -} - -.ebIcon_large { - width: 2.8rem; - height: 2.8rem; - line-height: 2.8rem; -} - -.ebIcon_wMargin { - margin: 4px; -} - -.ebIcon_upArrow { - background-image: url('../resources/16px/ArrowUpSmall_black_16px.svg'); -} - -.ebIcon_upArrow_white { - background-image: url('../resources/16px/arrowUpSmall_white_16px.svg'); -} - -.ebIcon_downArrow { - background-image: url('../resources/16px/ArrowDownSmall_black_16px.svg'); -} - -.ebIcon_downArrow_white { - background-image: url('../resources/16px/ArrowDownSmall_white_16px.svg'); -} - -.ebIcon_leftArrow { - background-image: url('../resources/16px/ArrowLeftSmall_black_16px.svg'); -} - -.ebIcon_leftArrow_white { - background-image: url('../resources/16px/ArrowLeftSmall_white_16px.svg'); -} - -.ebIcon_rightArrow { - background-image: - url('../resources/16px/ArrowRightSmall_black_16px.svg'); -} - -.ebIcon_rightArrow_white { - background-image: - url('../resources/16px/ArrowRightSmall_white_16px.svg'); -} - -.ebIcon_prevArrow { - background-image: - url('../resources/16px/ArrowDoubleLeftSmall_black_16px.svg'); -} - -.ebIcon_nextArrow { - background-image: - url('../resources/16px/ArrowDoubleRightSmall_black_16px.svg'); -} - -.ebIcon_upArrow_10px { - background-image: url('../resources/10px/ArrowUpSmall_black_10px.svg'); -} - -.ebIcon_downArrow_10px { - background-image: url('../resources/10px/ArrowDownSmall_black_10px.svg'); -} - -.ebIcon_leftArrow_10px { - background-image: url('../resources/10px/ArrowLeftSmall_black_10px.svg'); -} - -.ebIcon_rightArrow_10px { - background-image: - url('../resources/10px/ArrowRightSmall_black_10px.svg'); -} - -.ebIcon_prevArrow_10px { - background-image: - url('../resources/10px/ArrowDoubleLeftSmall_black_10px.svg'); -} - -.ebIcon_nextArrow_10px { - background-image: - url('../resources/10px/ArrowDoubleRightSmall_black_10px.svg'); -} - -.ebIcon_errorSmall { - background-image: url('../resources/other/errorSmall_red_10px.svg'); -} - -.ebIcon_tickSmallBlack { - background-image: url('../resources/other/tick_black_10x8px.svg'); -} - -.ebIcon_tickSmallGreen { - background-image: url('../resources/other/tick_green_10x8px.svg'); -} - -.ebIcon_upArrowLarge { - background-image: url('../resources/16px/ArrowUp_black_16px.svg'); -} - -.ebIcon_upArrowLarge_white { - background-image: url('../resources/16px/ArrowUp_white_16px.svg'); -} - -.ebIcon_downArrowLarge { - background-image: url('../resources/16px/ArrowDown_black_16px.svg'); -} - -.ebIcon_downArrowLarge_white { - background-image: url('../resources/16px/ArrowDown_white_16px.svg'); -} - -.ebIcon_downArrowLarge_blue { - background-image: url('../resources/16px/ArrowDown_blue_16px.svg'); -} - -.ebIcon_leftArrowLarge { - background-image: url('../resources/16px/ArrowLeft_black_16px.svg'); -} - -.ebIcon_leftArrowLarge_white { - background-image: url('../resources/16px/ArrowLeft_white_16px.svg'); -} - -.ebIcon_rightArrowLarge { - background-image: url('../resources/16px/ArrowRight_black_16px.svg'); -} - -.ebIcon_rightArrowLarge_white { - background-image: url('../resources/16px/ArrowRight_white_16px.svg'); -} - -.ebIcon_circleArrowDown { - background-image: - url('../resources/16px/circleArrowDown_black_16px.svg'); -} - -.ebIcon_circleArrowDown_white { - background-image: - url('../resources/16px/circleArrowDown_white_16px.svg'); -} - -.ebIcon_circleArrowLeft { - background-image: - url('../resources/16px/circleArrowLeft_black_16px.svg'); -} - -.ebIcon_circleArrowLeft_white { - background-image: - url('../resources/16px/circleArrowLeft_white_16px.svg'); -} - -.ebIcon_circleArrowRight { - background-image: - url('../resources/16px/circleArrowRight_black_16px.svg'); -} - -.ebIcon_circleArrowRight_white { - background-image: - url('../resources/16px/circleArrowRight_white_16px.svg'); -} - -.ebIcon_circleArrowUp { - background-image: url('../resources/16px/circleArrowUp_black_16px.svg'); -} - -.ebIcon_circleArrowUp_white { - background-image: url('../resources/16px/circleArrowUp_white_16px.svg'); -} - -.ebIcon_circleCaretDown { - background-image: - url('../resources/16px/circleCaretDown_black_16px.svg'); -} - -.ebIcon_circleCaretDown_white { - background-image: - url('../resources/16px/circleCaretDown_white_16px.svg'); -} - -.ebIcon_circleCaretLeft { - background-image: - url('../resources/16px/circleCaretLeft_black_16px.svg'); -} - -.ebIcon_circleCaretLeft_white { - background-image: - url('../resources/16px/circleCaretLeft_white_16px.svg'); -} - -.ebIcon_circleCaretRight { - background-image: - url('../resources/16px/circleCaretRight_black_16px.svg'); -} - -.ebIcon_circleCaretRight_white { - background-image: - url('../resources/16px/circleCaretRight_white_16px.svg'); -} - -.ebIcon_circleCaretUp { - background-image: url('../resources/16px/circleCaretUp_black_16px.svg'); -} - -.ebIcon_circleCaretUp_white { - background-image: url('../resources/16px/circleCaretUp_white_16px.svg'); -} - -.ebIcon_eLogo { - background-image: url('../resources/systemBar/econ01.svg'); -} - -.ebIcon_comment { - background-image: url('../resources/16px/Comment_black_16px.svg'); -} - -.ebIcon_comment_white { - background-image: url('../resources/16px/comment_white.svg'); -} - -.ebIcon_copy { - background-image: url('../resources/16px/copy_black_16px.svg'); -} - -.ebIcon_copy_white { - background-image: url('../resources/16px/copy_white_16px.svg'); -} - -.ebIcon_cut { - background-image: url('../resources/16px/cut_black.svg'); -} - -.ebIcon_cut_white { - background-image: url('../resources/16px/cut_white.svg'); -} - -.ebIcon_delete { - background-image: url('../resources/16px/delete_black_16px.svg'); -} - -.ebIcon_delete_white { - background-image: url('../resources/16px/delete_white_16px.svg'); -} - -.ebIcon_duplicate { - background-image: url('../resources/16px/duplicate_black_16px.svg'); -} - -.ebIcon_duplicate_white { - background-image: url('../resources/16px/duplicate_white_16px.svg'); -} - -.ebIcon_edit { - background-image: url('../resources/16px/edit_black_16px.svg'); -} - -.ebIcon_editWhite { - background-image: url('../resources/16px/edit_white_16px.svg'); -} - -.ebIcon_newFile { - background-image: url('../resources/16px/newFile_black_16px.svg'); -} - -.ebIcon_newFile_white { - background-image: url('../resources/16px/newFile_white_16px.svg'); -} - -.ebIcon_save { - background-image: url('../resources/16px/save_black_16px.svg'); -} - -.ebIcon_save_white { - background-size: contain; - background-image: url('../resources/16px/save_white.svg'); -} - -.ebIcon_filter { - background-image: url('../resources/16px/filter_black_16px.svg'); -} - -.ebIcon_filterOn { - background-image: url('../resources/16px/filters_on.svg'); -} - -.ebIcon_filterOff { - background-image: url('../resources/16px/filters_off.svg'); -} - -.ebIcon_filter_white { - background-image: url('../resources/16px/filter_white_16px.svg'); -} - -.ebIcon_folder { - background-image: url('../resources/16px/folder_black_16px.svg'); -} - -.ebIcon_folder_white { - background-image: url('../resources/16px/folder_white_16px.svg'); -} - -.ebIcon_folderClosed { - background-image: url('../resources/16px/folderClosed_black.svg'); -} - -.ebIcon_folderClosed_white { - background-image: url('../resources/16px/folderClosed_white.svg'); -} - -.ebIcon_detach { - background-image: url('../resources/16px/detach_black_16px.svg'); -} - -.ebIcon_detach_white { - background-size: contain; - background-image: url('../resources/16px/detach_white.svg'); -} - -.ebIcon_import { - background-image: url('../resources/16px/import_black.svg'); -} - -.ebIcon_import_white { - background-image: url('../resources/16px/import_white.svg'); -} - -.ebIcon_export { - background-image: url('../resources/16px/export_black_16px.svg'); -} - -.ebIcon_export_white { - background-image: url('../resources/16px/export_white.svg'); -} - -.ebIcon_undo { - background-image: url('../resources/16px/undo_black_16px.svg'); -} - -.ebIcon_undo_white { - background-image: url('../resources/16px/undo_white_16px.svg'); -} - -.ebIcon_cancelled { - background-image: url('../resources/16px/Cancelled_Black_16px.svg'); -} - -.ebIcon_draft { - background-size: contain; - background-image: url('../resources/16px/draft.svg'); -} - -.ebIcon_importExport { - background-image: url('../resources/16px/import_export.svg'); -} - -.ebIcon_login { - background-image: url('../resources/16px/login.svg'); -} - -.ebIcon_move { - background-image: url('../resources/16px/move.svg'); -} - -.ebIcon_remove { - background-image: url('../resources/16px/remove.svg'); -} - -.ebIcon_valid { - background-image: url('../resources/16px/valid_icon.svg'); -} - -.ebIcon_invalid { - background-image: url('../resources/16px/invalid_icon.svg'); -} - -.ebIcon_error { - background-image: url('../resources/16px/error_red_16px.svg'); -} - -.ebIcon_warning { - background-image: url('../resources/16px/warning_yellow_16px.svg'); -} - -.ebIcon_warningOrange { - background-image: url('../resources/16px/warning_orange_16px.svg'); -} - -.ebIcon_warning_white { - background-image: url('../resources/16px/warning_white.svg'); -} - -.ebIcon_warningShield { - background-image: url('../resources/16px/warningShield_black_16px.svg'); -} - -.ebIcon_warningShield_white { - background-size: contain; - background-image: url('../resources/16px/warningShield_white.svg'); -} - -.ebIcon_mail { - background-image: url('../resources/16px/mail_black_16px.svg'); -} - -.ebIcon_mail_white { - background-image: url('../resources/16px/mail_white_16px.svg'); -} - -.ebIcon_mailRead { - background-image: url('../resources/16px/mailRead_black_16px.svg'); -} - -.ebIcon_mailRead_white { - background-image: url('../resources/16px/mailRead_white_16px.svg'); -} - -.ebIcon_link { - background-image: url('../resources/16px/Link_black_16px.svg');; -} - -.ebIcon_lock { - background-image: url('../resources/16px/lock_black_16px.svg'); -} - -.ebIcon_lock_white { - background-image: url('../resources/16px/lock_white_16px.svg'); -} - -.ebIcon_unlock { - background-image: url('../resources/16px/unlock_black_16px.svg'); -} - -.ebIcon_unlock_white { - background-image: url('../resources/16px/unlock_white_16px.svg'); -} - -.ebIcon_logout { - background-image: url('../resources/16px/logout_black_16px.svg'); -} - -.ebIcon_menu { - background-image: url('../resources/16px/menu_black_16px.svg'); -} - -.ebIcon_menu_white { - background-image: url('../resources/16px/menu_white_16px.svg'); -} - -.ebIcon_search { - background-image: url('../resources/16px/search_black_16px.svg'); -} - -.ebIcon_searchWhite { - background-image: url('../resources/16px/search_white_16px.svg'); -} - -.ebIcon_advancedSearch { - background-image: - url('../resources/16px/advanced_search_black_16px.svg'); -} - -.ebIcon_advancedSearchWhite { - background-image: - url('../resources/16px/advanced_search_white_16px.svg'); -} - -.ebIcon_share { - background-image: url('../resources/16px/share_black_16px.svg'); -} - -.ebIcon_share_white { - background-image: url('../resources/16px/share_white.svg'); -} - -.ebIcon_star { - background-image: url('../resources/16px/star_black_16px.svg'); -} - -.ebIcon_star_white { - background-image: url('../resources/16px/star_white_16px.svg'); -} - -.ebIcon_star_yellow { - background-image: url('../resources/16px/star_yellow_16px.svg'); -} - -.ebIcon_starOutline { - background-image: url('../resources/16px/star_outline_black_16px.svg'); -} - -.ebIcon_starOutline_white { - background-image: url('../resources/16px/star_outline_white_16px.svg'); -} - -.ebIcon_starOutline_yellow { - background-image: url('../resources/16px/star_outline_yellow_16px.svg'); -} - -.ebIcon_tick { - background-image: url('../resources/16px/tick_green_16px.svg'); -} - -.ebIcon_tick_black { - background-image: url('../resources/16px/tick_16px.svg'); -} - -.ebIcon_simpleGreenTick { - background-image: url('../resources/16px/simple_green_tick.svg'); -} - -.ebIcon_simpleTick_black { - background-image: url('../resources/16px/simple_tick.svg'); -} - -.ebIcon_download { - background-image: url('../resources/16px/download_black.svg'); -} - -.ebIcon_download_white { - background-image: url('../resources/16px/download_white.svg'); -} - -.ebIcon_downloadWhite { - background-image: url('../resources/16px/download_white_16px.svg'); -} - -.ebIcon_documentWhite { - background-image: url('../resources/16px/document_white_16px.svg'); -} - -.ebIcon_expand { - background-image: url('../resources/16px/expand_black_16px.svg'); -} - -.ebIcon_rowCollapsed { - background-image: url('../resources/16px/rowCollapsed_black_16px.svg'); -} - -.ebIcon_rowExpanded { - background-image: url('../resources/16px/rowExpanded_black_16px.svg'); -} - -.ebIcon_rowView { - background-image: url('../resources/16px/rowView_black_16px.svg'); -} - -.ebIcon_rowView_white { - background-image: url('../resources/16px/rowView_white.svg'); -} - -.ebIcon_externalApp { - background-image: url('../resources/16px/externalApp_black_16px.svg'); -} - -.ebIcon_externalApp_white { - background-image: url('../resources/16px/externalApp_white_16px.svg'); -} - -.ebIcon_fullscreen { - background-image: url('../resources/16px/fullscreen_black_16px.svg'); -} - -.ebIcon_fullscreenMinimize { - background-image: - url('../resources/16px/fullscreenMinimise_black_16px.svg'); -} - -.ebIcon_help { - background-image: url('../resources/16px/help_black_16px.svg'); -} - -.ebIcon_help_white { - background-image: url('../resources/16px/help_white.svg'); -} - -.ebIcon_info { - background-image: url('../resources/16px/info_black.svg'); -} - -.ebIcon_info_white { - background-image: url('../resources/16px/info_white.svg'); -} - -.ebIcon_dialogInfo { - background-image: url('../resources/16px/dialogInfo_blue.svg'); -} - -.ebIcon_dialogInfo_white { - background-image: url('../resources/16px/dialogInfo_white.svg'); -} - -.ebIcon_infoMsgIndicator { - background-image: url('../resources/16px/infoMsgIndicator_16px.svg'); -} - -.ebIcon_exitFullscreen { - background-image: - url('../resources/16px/minimiseFullscreen_black_16px.svg'); -} - -.ebIcon_refresh { - background-image: url('../resources/16px/refresh_black_16px.svg'); -} - -.ebIcon_refresh_white { - background-image: url('../resources/16px/refresh_white_16px.svg'); -} - -.ebIcon_settings { - background-image: url('../resources/16px/settings_black_16px.svg'); -} - -.ebIcon_settings_white { - background-image: url('../resources/16px/settings_white_16px.svg'); -} - -.ebIcon_user { - background-image: url('../resources/16px/user_black_16px.svg'); -} - -.ebIcon_user_white { - background-image: url('../resources/16px/user_white_16px.svg'); -} - -.ebIcon_close { - background-image: url('../resources/16px/X_black_16px.svg'); -} - -.ebIcon_close_white { - background-image: url('../resources/16px/close_white_16px.svg'); -} - -.ebIcon_close_blue { - background-image: url('../resources/16px/X_blue_16px.svg'); -} - -.ebIcon_close_paleBlue { - background-image: url('../resources/16px/X_paleBlue_16px.svg'); -} - -.ebIcon_close_green { - background-image: url('../resources/16px/X_green_16px.svg'); -} - -.ebIcon_close_orange { - background-image: url('../resources/16px/X_orange_16px.svg'); -} - -.ebIcon_close_red { - background-image: url('../resources/16px/X_red_16px.svg'); -} - -.ebIcon_close_yellow { - background-image: url('../resources/16px/X_yellow_16px.svg'); -} - -.ebIcon_minus { - background-image: url('../resources/16px/minus_black_16px.svg'); -} - -.ebIcon_plus { - background-image: url('../resources/16px/plus_black_16px.svg'); -} - -.ebIcon_add { - background-image: url('../resources/16px/add_black_16px.svg'); -} - -.ebIcon_add_white { - background-image: url('../resources/16px/add_white_16px.svg'); -} - -.ebIcon_multiSelect { - background-image: url('../resources/16px/multiSelect_black_16px.svg'); -} - -.ebIcon_multiSelect_white { - background-size: contain; - background-image: url('../resources/16px/multiSelect_white.svg'); -} - -.ebIcon_multiSort { - background-image: url('../resources/16px/multi-sort.svg'); -} - -.ebIcon_multiSort_white { - background-image: url('../resources/16px/multi-sort_white.svg'); -} - -.ebIcon_sort { - background-image: url('../resources/16px/sort.svg'); -} - -.ebIcon_sort_white { - background-image: url('../resources/16px/sort_white.svg'); -} - -.ebIcon_stop { - background-image: url('../resources/16px/stop_black_16px.svg'); -} - -.ebIcon_pause { - background-image: url('../resources/16px/pause_black_16px.svg'); -} - -.ebIcon_suspend { - background-image: url('../resources/16px/suspend_black_16px.svg'); -} - -.ebIcon_resume { - background-image: url('../resources/16px/resume_black_16px.svg'); -} - -.ebIcon_play { - background-image: url('../resources/16px/play_black_16px.svg'); -} - -.ebIcon_fastForward { - background-image: url('../resources/16px/fastForward_black_16px.svg'); -} - -.ebIcon_fastRewind { - background-image: url('../resources/16px/fastRewind_black_16px.svg'); -} - -.ebIcon_print { - background-image: url('../resources/16px/print_black_16px.svg'); -} - -.ebIcon_print_white { - background-image: url('../resources/16px/print_white_16px.svg'); -} - -.ebIcon_calendar { - background-image: url('../resources/16px/calendar_black_16px.svg'); -} - -.ebIcon_calendar_white { - background-image: url('../resources/16px/calendar_white_16px.svg'); -} - -.ebIcon_addToFolder { - background-image: url('../resources/16px/addToFolder_black.svg'); -} - -.ebIcon_addToFolder_white { - background-image: url('../resources/16px/addToFolder_white.svg'); -} - -.ebIcon_alarmCleared { - background-image: url('../resources/16px/alarmCleared_16px.svg'); -} - -.ebIcon_alarmCleared_white { - background-image: url('../resources/16px/alarmCleared_white_16px.svg'); -} - -.ebIcon_alarmCritical { - background-image: url('../resources/16px/alarmCritical_16px.svg'); -} - -.ebIcon_alarmCritical_white { - background-image: url('../resources/16px/alarmCritical_white_16px.svg'); -} - -.ebIcon_alarmHeartbeat { - background-image: url('../resources/16px/alarmHeartbeat_16px.svg'); -} - -.ebIcon_alarmIndeterminate { - background-image: url('../resources/16px/alarmIndeterminate_16px.svg'); -} - -.ebIcon_alarmIndeterminate_white { - background-image: - url('../resources/16px/alarmIndeterminate_white_16px.svg'); -} - -.ebIcon_alarmMajor { - background-image: url('../resources/16px/alarmMajor_16px.svg'); -} - -.ebIcon_alarmMajor_white { - background-image: url('../resources/16px/alarmMajor_white_16px.svg'); -} - -.ebIcon_alarmMinor { - background-image: url('../resources/16px/alarmMinor_16px.svg'); -} - -.ebIcon_alarmMinor_white { - background-image: url('../resources/16px/alarmMinor_white_16px.svg'); -} - -.ebIcon_alarmWarning { - background-image: url('../resources/16px/alarmWarning_16px.svg'); -} - -.ebIcon_alarmWarning_white { - background-image: url('../resources/16px/alarmWarning_white_16px.svg'); -} - -.ebIcon_alarmOtherGrouping { - background-image: url('../resources/16px/alarmOtherGrouping_16px.svg'); -} - -.ebIcon_alarmUnacknowledged { - background-image: url('../resources/16px/alarmUnacknowledged.svg'); -} - -.ebIcon_alarmUnacknowledged_white { - background-image: url('../resources/16px/alarmUnacknowledged_white.svg'); -} - -.ebIcon_alarmUnspecified { - background-image: url('../resources/16px/alarmUnspecified_16px.svg'); -} - -.ebIcon_acknowledgeAlarm { - background-image: url('../resources/16px/acknowledgeAlarm.svg'); -} - -.ebIcon_acknowledgeAlarm_white { - background-image: url('../resources/16px/acknowledgeAlarm_white.svg'); -} - -.ebIcon_clearAlarm { - background-image: url('../resources/16px/clearAlarm.svg'); -} - -.ebIcon_clearAlarm_white { - background-image: url('../resources/16px/clearAlarm_white.svg'); -} - -.ebIcon_bsc { - background-image: url('../resources/16px/BSC_black_16px.svg'); -} - -.ebIcon_bscYellow { - background-image: url('../resources/16px/BSC_Yellow_16px.svg'); -} - -.ebIcon_bscFunction { - background-image: url('../resources/16px/BSCFunction_black_16px.svg'); -} - -.ebIcon_bscFunctionYellow { - background-image: url('../resources/16px/BSCFunction_Yellow_16px.svg'); -} - -.ebIcon_cabinet { - background-image: url('../resources/16px/cabinet_black_16px.svg'); -} - -.ebIcon_cellGray { - background-image: url('../resources/16px/cell_gray_16px.svg'); -} - -.ebIcon_cellGreen { - background-image: url('../resources/16px/cell_green_16px.svg'); -} - -.ebIcon_cellRed { - background-image: url('../resources/16px/cell_red_16px.svg'); -} - -.ebIcon_cellAdjacent { - background-image: url('../resources/16px/cellAdjacent_16px.svg'); -} - -.ebIcon_cellExternal { - background-image: url('../resources/16px/cellExternal_16px.svg'); -} - -.ebIcon_charging { - background-image: url('../resources/16px/charging_black.svg'); -} - -.ebIcon_charging_white { - background-size: contain; - background-image: url('../resources/16px/charging_white.svg'); -} - -.ebIcon_connected { - background-image: url('../resources/16px/connected_black_16px.svg'); -} - -.ebIcon_disconnected { - background-image: url('../resources/16px/disconnected_black_16px.svg'); -} - -.ebIcon_connectionError { - background-image: - url('../resources/16px/connectionError_black_16px.svg'); -} - -.ebIcon_core { - background-image: url('../resources/16px/core_black_16px.svg'); -} - -.ebIcon_coreSubscriber { - background-image: url('../resources/16px/coreSubscriber_black_16px.svg'); -} - -.ebIcon_database { - background-image: url('../resources/16px/database_black_16px.svg'); -} - -.ebIcon_ftpServer { - background-image: url('../resources/16px/ftpServer_black_16px.svg'); -} - -.ebIcon_ftpServerFunction { - background-image: - url('../resources/16px/ftpServerFunction_black_16px.svg'); -} - -.ebIcon_gatewayFunction { - background-image: - url('../resources/16px/gatewayFunction_black_16px.svg'); -} - -.ebIcon_grabHandle { - background-image: url('../resources/16px/grabHandle_black_16px.svg'); -} - -.ebIcon_grabHandle_white { - background-size: contain; - background-image: url('../resources/16px/grabHandle_white.svg'); -} - -.ebIcon_managedFunction { - background-image: - url('../resources/16px/managedFunction_black_16px.svg'); -} - -.ebIcon_managedGroup { - background-image: url('../resources/16px/managedGroup_black_16px.svg'); -} - -.ebIcon_managementNode { - background-image: url('../resources/16px/managementNode_black_16px.svg'); -} - -.ebIcon_network { - background-image: url('../resources/16px/network_black_16px.svg'); -} - -.ebIcon_networkElement { - background-image: url('../resources/16px/networkElement_black_16px.svg'); -} - -.ebIcon_networkElement_white { - background-image: url('../resources/16px/networkElement_white_16px.svg'); -} - -.ebIcon_rbs { - background-image: url('../resources/16px/RBS_black_16px.svg'); -} - -.ebIcon_rbs_white { - background-image: url('../resources/16px/RBS_white_16px.svg'); -} - -.ebIcon_routeSwitch { - background-image: url('../resources/16px/routeSwitch.svg'); -} - -.ebIcon_rxi { - background-image: url('../resources/16px/rxi_black_16px.svg'); -} - -.ebIcon_switchFunction { - background-image: url('../resources/16px/switchFunction_black_16px.svg'); -} - -.ebIcon_technicianPresent { - background-image: url('../resources/16px/technicianPresent_16px.svg'); -} - -.ebIcon_terminal { - background-image: url('../resources/16px/terminal_black_16px.svg'); -} - -.ebIcon_topology { - background-image: url('../resources/16px/topology_black_16px.svg'); -} - -.ebIcon_access { - background-image: url('../resources/16px/access_black_16px.svg'); -} - -.ebIcon_access_white { - background-image: url('../resources/16px/access_white_16px.svg'); -} - -.ebIcon_accessSettings { - background-image: url('../resources/16px/accessSettings_black_16px.svg'); -} - -.ebIcon_accessSettings_white { - background-image: url('../resources/16px/accessSettings_white_16px.svg'); -} - -.ebIcon_alignCenter { - background-image: url('../resources/16px/alignCenter_black_16px.svg'); -} - -.ebIcon_alignCenter_white { - background-image: url('../resources/16px/alignCenter_white.svg'); -} - -.ebIcon_alignLeft { - background-image: url('../resources/16px/alignLeft_black_16px.svg'); -} - -.ebIcon_alignLeft_white { - background-image: url('../resources/16px/alignLeft_white.svg'); -} - -.ebIcon_alignRight { - background-image: url('../resources/16px/alignRight_black_16px.svg'); -} - -.ebIcon_alignRight_white { - background-image: url('../resources/16px/alignRight_white.svg'); -} - -.ebIcon_cli { - background-image: - url('../resources/16px/CommandLineInterface_black_16px.svg'); -} - -.ebIcon_cli_white { - background-image: - url('../resources/16px/CommandLineInterface_white_16px.svg'); -} - -.ebIcon_controllingNode { - background-image: url('../resources/16px/controllingNode.svg'); -} - -.ebIcon_grid3x3 { - background-image: url('../resources/16px/grid3X3_black_16px.svg'); -} - -.ebIcon_grid3x3_white { - background-image: url('../resources/16px/grid3x3_white.svg'); -} - -.ebIcon_grid4x4 { - background-image: url('../resources/16px/grid4X4_black_16px.svg'); -} - -.ebIcon_grid4x4_white { - background-image: url('../resources/16px/grid4x4_white.svg'); -} - -.ebIcon_gridView { - background-image: url('../resources/16px/gridView_black_16px.svg'); -} - -.ebIcon_gridView_white { - background-image: url('../resources/16px/gridView_white.svg'); -} - -.ebIcon_jumpTo { - background-image: url('../resources/16px/jumpTo_black_16px.svg'); -} - -.ebIcon_microwave { - background-image: url('../resources/16px/microwave.svg'); -} - -.ebIcon_mo { - background-image: url('../resources/16px/mo.svg'); -} - -.ebIcon_security { - background-image: url('../resources/16px/security_black_16px.svg'); -} - -.ebIcon_security_white { - background-image: url('../resources/16px/security_white_16px.svg'); -} - -.ebIcon_site { - background-image: url('../resources/16px/site_black_16px.svg'); -} - -.ebIcon_siteManager { - background-image: url('../resources/16px/siteManager_black_16px.svg'); -} - -.ebIcon_subnetwork { - background-image: url('../resources/16px/subnetwork.svg'); -} - -.ebIcon_gateway, .ebIcon_switch { - background-image: url('../resources/16px/switch.svg'); -} - -.ebIcon_tip { - background-image: url('../resources/16px/tip_black_16px.svg'); -} - -.ebIcon_tip_white { - background-image: url('../resources/16px/tip_white_16px.svg'); -} - -.ebIcon_attach { - background-image: url('../resources/16px/attach_black_16px.svg'); -} - -.ebIcon_attach_white { - background-size: contain; - background-image: url('../resources/16px/attach_white.svg'); -} - -.ebIcon_clock { - background-image: url('../resources/16px/clock_black_16px.svg'); -} - -.ebIcon_clock_white { - background-image: url('../resources/16px/clock_white_16px.svg'); -} - -.ebIcon_windowMaximize { - background-image: url('../resources/16px/WindowMaximize_black_16px.svg'); -} - -.ebIcon_windowMinimize { - background-image: url('../resources/16px/WindowMinimize_black_16px.svg'); -} - -.ebIcon_deprecated { - background-image: url('../resources/16px/deprecated_16px.svg'); -} - -.ebIcon_obsolete { - background-image: url('../resources/16px/obsolete_16px.svg'); -} - -.ebIcon_newStatus_blue { - background-image: url('../resources/16px/newStatus_blue_16px.svg'); -} - -.ebIcon_newStatus_green { - background-image: url('../resources/16px/newStatus_green_16px.svg'); -} - -.ebIcon_upload { - background-image: url('../resources/16px/upload_black_16px.svg'); -} - -.ebIcon_activate { - background-image: url('../resources/16px/activate_black_16px.svg'); -} - -.ebIcon_activate_white { - background-size: contain; - background-image: url('../resources/16px/activate_white.svg'); -} - -.ebIcon_deactivate { - background-image: url('../resources/16px/deactivate_black_16px.svg'); -} - -.ebIcon_deactivate_white { - background-size: contain; - background-image: url('../resources/16px/deactivate_white.svg'); -} - -.ebIcon_switchBetween { - background-image: url('../resources/16px/switchBetween_black_16px.svg'); -} - -.ebIcon_switchBetween_white { - background-image: url('../resources/16px/switchBetween_white_16px.svg'); -} - -.ebIcon_eye { - background-image: url('../resources/16px/eye_black_16px.svg'); -} - -.ebIcon_eye_white { - background-image: url('../resources/16px/eye_white_16px.svg'); -} - -.ebIcon_eyeLine { - background-image: url('../resources/16px/eyeLine_black_16px.svg'); -} - -.ebIcon_eyeLine_white { - background-image: url('../resources/16px/eyeLine_white.svg'); -} - -.ebIcon_activityTray { - background-image: url('../resources/16px/activity_16px_black.svg'); -} - -.ebIcon_note { - background-image: url('../resources/16px/note_black_16px.svg'); - background-size: contain; -} - -.ebIcon_note_white { - background-image: url('../resources/16px/note_white_16px.svg'); -} - -.ebIcon_tableView { - background-image: url('../resources/16px/tableView_black_16px.svg'); -} - -.ebIcon_tableView_white { - background-image: url('../resources/16px/tableView_white_16px.svg'); -} - -.ebIcon_synced { - background-image: url('../resources/16px/Syncd_16px.svg'); -} - -.ebIcon_syncError { - background-image: url('../resources/16px/SyncError_16px.svg'); -} - -.ebIcon_syncing { - background-image: url('../resources/16px/Syncing_Static_16px.svg'); -} - -.ebIcon_syncing_animated { - background-image: url('../resources/16px/Syncing_Animated_16px.svg'); -} - -/* Breadcrumb */ -.ebBreadcrumbs { - position: relative; - display: block; - font-size: 0; - margin-top: 12px; - margin-bottom: 4px; -} - -.ebBreadcrumbs-link { - font-size: 1.2rem; - vertical-align: middle; - display: inline-block -} - -.ebBreadcrumbs-list { - position: absolute; - left: 0; - margin-top: 6px; - display: none; - min-width: calc(100% - 16px); - max-width: 250px; - z-index: 1500 -} - -.ebBreadcrumbs-arrow { - margin-left: .6rem; - vertical-align: middle; - outline: none; - display: inline-block; - line-height: 12px -} - -.ebBreadcrumbs-arrow:focus>* { - opacity: 1 -} - -.ebBreadcrumbs-arrow_hidden { - display: none -} - -.ebBreadcrumbs-arrow:focus+.ebBreadcrumbs-list { - display: block -} - -.ebBreadcrumbs-item { - position: relative; - font-size: 0; - white-space: nowrap; - display: inline-block; - margin-bottom: .8rem -} - -.ebBreadcrumbs-item:after { - vertical-align: middle; - display: inline-block; - width: 20px; - content: "/"; - font-size: 1.6rem; - text-align: center; - color: #999; - cursor: default !important; - pointer-events: none !important; - -ms-touch-action: none !important; - touch-action: none !important; - -khtml-user-select: none !important; - -moz-user-select: none !important; - -o-user-select: none !important; - -webkit-user-select: none !important; - user-select: none -} - -.ebBreadcrumbs-item:last-child { - margin-right: 0 -} - -.ebBreadcrumbs-item:last-child>.ebBreadcrumbs-link { - -ms-touch-action: none !important; - touch-action: none !important; - -khtml-user-select: none !important; - -moz-user-select: none !important; - -o-user-select: none !important; - -webkit-user-select: none !important; - user-select: none -} - -.ebBreadcrumbs-item:last-child:after { - content: ""; - padding: 0; - font-size: 0; - width: 0; -} - -.ebBreadcrumbs a { - font-size: 1.2rem; - color: #0066b3; - text-decoration: none; -} - -.ebBreadcrumbs a:hover { - text-decoration: underline; - outline: none; -} - -.ebBreadcrumbs a:active { - text-decoration: underline -} - -.ebBreadcrumbs a:focus { - outline: none; - text-decoration: underline; - box-shadow: none; -}
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/css/styles.css b/client/client-monitoring/src/main/resources/webapp/css/styles.css deleted file mode 100644 index fcb78fb43..000000000 --- a/client/client-monitoring/src/main/resources/webapp/css/styles.css +++ /dev/null @@ -1,441 +0,0 @@ -/* - * ============LICENSE_START======================================================= - * Copyright (C) 2016-2018 Ericsson. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * SPDX-License-Identifier: Apache-2.0 - * ============LICENSE_END========================================================= - */ -.ebSystemBar-config { - position: absolute; - top: 0; - bottom: 0; - right: 0; - height: 40px; - width: 20px; - padding: 0 10px; - background: url('../resources/16px/settings_black_16px.svg') no-repeat - center center transparent; - background-size: 20px; - cursor: pointer; -} - -.content { - display: none; - padding: 10px; -} - -.context { - margin-left: 5px; -} - -.wrapper { - border: 1px dashed #ddd; - box-shadow: 0 0 0 3px #fff, 0 0 0 5px #ddd, 0 0 0 10px #fff, 0 0 2px - 10px #eee; - padding: 10px; - margin: 10px; - min-width: 1287px; -} - -.wrapper_borderless { - margin-left: 5px; - min-width: 1287px; -} - -.engineService { - margin-left: 5px; - padding-bottom: 10px; -} - -.apexDialogDiv { - background-color: white; - position: fixed; - top: 50%; - left: 50%; - transform: translate(-50%, -50%); - min-width: 310px; - min-height: 140px; - resize: both; - overflow: auto; - padding: 10px 10px 10px 10px; - border: 1px solid #c0c0c0; - border-radius: 3px; - box-shadow: 3px 7px 5px #555555; -} - -.apexDialogDiv { - background-color: white; - position: fixed; - top: 50%; - left: 50%; - transform: translate(-50%, -50%); - min-width: 310px; - min-height: 140px; - resize: both; - overflow: auto; - padding: 10px 10px 10px 10px; - border: 1px solid #c0c0c0; - border-radius: 3px; - box-shadow: 3px 7px 5px #555555; -} - -.apexErrorDialogDiv { - max-width: 80%; - max-height: 80%; - overflow: hidden; -} - -/* Dialog */ -.apexDialogDiv .headingSpan { - width: 100%; - height: 30px; - display: inline-block; - text-align: center; - font-weight: bold; - font-size: 20px; - padding: 5px 0px 0px 0px; - border-bottom: #c0c0c0 solid 1px; -} - -.apexDialogDivBackground { - position: fixed; - height: 100%; - width: 100%; - background-color: rgba(0, 0, 0, 0.5); - top: 0px; - left: 0px; -} - -.dialogMessage { - white-space: pre-wrap; - font: 14px "Lucida Sans Unicode", "Lucida Grande", sans-serif; - overflow-y: auto; - max-height: 480px; - overflow-x: hidden; - word-wrap: break-word; -} - -/* Form */ -.resultFormDiv .form-style-1 .field-textarea { - height: 480px; - font-size: 15px; -} - -.form-style-1 { - margin: 10px auto; - font: 16px "Lucida Sans Unicode", "Lucida Grande", sans-serif; -} - -.form-style-1 li { - padding: 0; - display: block; - list-style: none; - margin: 10px 0 0 0; -} - -.form-style-1 label { - margin: 0 0 3px 0; - padding: 0px; - display: block; - font-weight: bold; -} - -.form-style-1 input[type=text], .form-style-1 input[type=date], - .form-style-1 input[type=datetime], .form-style-1 input[type=number], - .form-style-1 input[type=search], .form-style-1 input[type=time], - .form-style-1 input[type=url], .form-style-1 input[type=email], - textarea, select { - box-sizing: border-box; - -webkit-box-sizing: border-box; - -moz-box-sizing: border-box; - border: 1px solid #BEBEBE; - padding: 0px 7px; - margin: 0px; - -webkit-transition: all 0.30s ease-in-out; - -moz-transition: all 0.30s ease-in-out; - -ms-transition: all 0.30s ease-in-out; - -o-transition: all 0.30s ease-in-out; - outline: none; -} - -.form-style-1 input[type=text]:focus, .form-style-1 input[type=date]:focus, - .form-style-1 input[type=datetime]:focus, .form-style-1 input[type=number]:focus, - .form-style-1 input[type=search]:focus, .form-style-1 input[type=time]:focus, - .form-style-1 input[type=url]:focus, .form-style-1 input[type=email]:focus, - .form-style-1 textarea:focus, .form-style-1 select:focus { - -moz-box-shadow: 0 0 8px #88D5E9; - -webkit-box-shadow: 0 0 8px #88D5E9; - box-shadow: 0 0 8px #88D5E9; - border: 1px solid #88D5E9; -} - -.form-style-1 input:focus::-webkit-input-placeholder { - color: transparent; -} - -.form-style-1 input:focus:-moz-placeholder { - color: transparent; -} - -.form-style-1 .field { - font-size: 15px; -} - -.form-style-1 .field-divided { - width: 49%; - font-size: 15px; -} - -.form-style-1 .field-long { - width: 100%; - font-size: 15px; -} - -.form-style-1 .field-medium { - width: 50%; - font-size: 15px; -} - -.form-style-1 .field-select { - width: 100%; - font-size: 15px; -} - -.form-style-1 .field-textarea { - height: 100px; - font-size: 15px; -} - -.form-style-1 .field-javaType { - width: 100%; - font-size: 15px; -} - -.form-style-1 .field-schemaFlavour { - width: 100%; - font-size: 15px; -} - -.form-style-1 .field-taskSelLogic { - width: 100%; - font-size: 15px; - height: 300px; -} - -.form-style-1 .field-taskLogic { - width: 100%; - font-size: 15px; - height: 300px; -} - -.form-style-1 .field-finalizerLogic { - width: 100%; - font-size: 15px; - height: 300px; -} - -.form-style-1 .field-schemaDefinition { - width: 100%; - font-size: 15px; - height: 100px; -} - -.form-style-1 .required { - color: red; -} - -.form-style-1 .button { - font-size: 15px; -} - -.form-style-1 .delete_ex { - height: 30px; - width: 30px; - opacity: 1; - font-size: 30px; - line-height: 30px; - transition: all 0.8s; - border: 1px solid transparent; - text-align: center; -} - -.form-style-1 .delete_ex:hover { - border-radius: 50%; - background: tomato; - border: 1px solid black; -} - -.form-style-1 .delete_ex_disabled { - width: 0px; - opacity: 0; -} - -/* Icons */ -.expandIcon { - float: right; -} - -.ignoreConflictsLabel { - font-size: 1.4rem; - padding-right: 15px; -} - -#engineServicesTable_periodic_events { - align-items: center; - display: flex; - height: 30px; -} - -.modelLoading { - margin-left: 5px; - display: none; -} - -.layoutWrapper { - margin: 0 40px; -} - -.appHeading { - color: rgb(51, 51, 51); - display: block; - font-family: Arial, Helvetica, sans-serif; - font-size: 12px; - height: 32px; - line-height: 12px; - position: relative; -} - -.ebQuickActionBar { - margin-top: 1.2rem; - font-size: 0; - height: 32px; - padding: 0.4rem 0; - background-color: #e8e8e8; - position: relative; - width: 100%; - overflow: hidden; - line-height: 0; - box-sizing: border-box; - -webkit-transition: background-color 0.1s ease-in; - transition: background-color 0.1s ease-in; - -webkit-border-radius: 3px; - -moz-border-radius: 3px; - -ms-border-radius: 3px; - border-radius: 3px; -} - -.ebQuickActionBar_context { - background-color: #f3f3f3; - border-bottom: 2px solid #65cbe5; - box-sizing: border-box; - height: 32px; -} - -.ebQuickActionBar>* { - margin-left: 0.4rem; - margin-right: 0.4rem; - vertical-align: middle; -} - -.ebQuickActionBar-iconHolder { - display: inline-block; - vertical-align: middle; - height: 1.6rem; -} - -.ebQuickActionBar-separator { - display: inline-block; - vertical-align: middle; - border-left: 1px solid #CCCCCC; - margin: 0 8px; - height: 2.4rem; -} - -.ebQuickActionBar-Commands, .ebQuickActionBar-commands { - display: inline-block; - margin: 0; - font-size: 0; - line-height: 2.4rem; -} - -.ebQuickActionBar-Commands-iconHolder, - .ebQuickActionBar-commands-iconHolder { - display: inline-block; - vertical-align: middle; - height: 1.6rem; -} - -.ebQuickActionBar-Commands-separator, - .ebQuickActionBar-commands-separator { - display: inline-block; - vertical-align: middle; - border-left: 1px solid #CCCCCC; - margin: 0 8px; - height: 2.4rem; -} - -.ebQuickActionBar-Commands>*, .ebQuickActionBar-commands>* { - margin-left: 0.4rem; - margin-right: 0.4rem; - vertical-align: middle; -} - -.ebQuickActionBar-Commands-block, .ebQuickActionBar-commands-block, - .ebQuickActionBar-CommandsBlock, .ebQuickActionBar-commandsBlock { - margin: 0 0.8rem; - display: inline-block; -} - -.ebQuickActionBar-Commands-block>*, .ebQuickActionBar-commands-block>*, - .ebQuickActionBar-CommandsBlock>*, .ebQuickActionBar-commandsBlock>* { - margin-left: 0.4rem; - margin-right: 0.4rem; - vertical-align: middle; -} - -.ebQuickActionBar-Commands-block :last-child, - .ebQuickActionBar-commands-block :last-child, - .ebQuickActionBar-CommandsBlock :last-child, - .ebQuickActionBar-commandsBlock :last-child { - margin-right: 0; -} - -.title { - padding: 0px; -} - -.dataTd { - max-width: 1000px; - word-wrap: break-word; - white-space: normal !important; -} - -.dataTd_wordwrap { - max-width: 1000px; - word-wrap: break-word; - white-space: pre-wrap !important; -} - -.engineContextTitle { - padding: 1.2rem 0 .7rem 0; - font-weight: normal; -} - -.engineContextWrapper { - display: inline-block; - float: left; - padding-right: 10px; - padding-bottom: 10px; -}
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/index.html b/client/client-monitoring/src/main/resources/webapp/index.html index bd5ce0f70..8015f436b 100644 --- a/client/client-monitoring/src/main/resources/webapp/index.html +++ b/client/client-monitoring/src/main/resources/webapp/index.html @@ -22,7 +22,7 @@ <head> <meta charset="UTF-8"> -<title>Apex Deployment and Monitoring</title> +<title>Apex Monitoring</title> <!-- interface style --> <link rel="stylesheet" type="text/css" href="css/interfaceAssets.css"> @@ -34,7 +34,6 @@ <script type="text/javascript" src="js/ApexUtils.js"></script> </head> - <body> <!-- interface styled System Bar --> @@ -81,7 +80,7 @@ </div> <!-- jQuery --> - <script src="js/jquery/jquery-1.12.4.js"></script> + <script src="jquery/jquery-1.12.4.js"></script> <!-- D3 --> <script type="text/javascript" src="js/d3/d3.min.js"></script> diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexAjax.js b/client/client-monitoring/src/main/resources/webapp/js/ApexAjax.js index e62489fa2..beb2cb11d 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexAjax.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexAjax.js @@ -22,68 +22,63 @@ * Send a GET request */ function ajax_get(requestURL, callback, hostName, port, params, errorCallback) { - var data = { - hostName : hostName, - port : port - }; - for ( var p in params) { - data[p] = params[p]; - } - return $ - .ajax({ - type : 'GET', - url : requestURL, - dataType : "json", - data : data, - success : function(data, textStatus, jqXHR) { - if (callback) { - callback(data); - } - }, - error : function(jqXHR, textStatus, errorThrown) { - if (jqXHR.status == 500 || jqXHR.status == 404) { - if (jqXHR.responseText - .indexOf("cound not handshake with server") !== -1 - || jqXHR.status == 404) { - clearEngineURL(); - getEngineURL(jqXHR.responseText); - } else { - apexErrorDialog_activate(document.body, - jqXHR.responseText); - } - } - if (errorCallback) { - errorCallback(jqXHR, textStatus, errorThrown); - } - } - }); + var data = { + hostName : hostName, + port : port + }; + for ( var p in params) { + data[p] = params[p]; + } + return $.ajax({ + type : 'GET', + url : requestURL, + dataType : "json", + data : data, + success : function(data, textStatus, jqXHR) { + if (callback) { + callback(data); + } + }, + error : function(jqXHR, textStatus, errorThrown) { + if (jqXHR.status == 500 || jqXHR.status == 404) { + if (jqXHR.responseText.indexOf("cound not handshake with server") !== -1 || jqXHR.status == 404) { + clearEngineURL(); + getEngineURL(jqXHR.responseText); + } else { + apexErrorDialog_activate(document.body, jqXHR.responseText); + } + } + if (errorCallback) { + errorCallback(jqXHR, textStatus, errorThrown); + } + } + }); } /* * Send a POST request and add a file to its payload */ -function ajax_upload(requestURL, callback, hostName, port, fileUrl, - ignoreConflicts, forceUpdate) { - var formData = new FormData(); - formData.append("hostName", hostName); - formData.append("port", port); - formData.append("file", fileUrl); - formData.append("ignoreConflicts", ignoreConflicts); - formData.append("forceUpdate", forceUpdate); - return $.ajax({ - url : requestURL, - type : "POST", - contentType : false, - dataType : "text", - processData : false, - data : formData, - success : function(data, textStatus, jqXHR) { - callback(data); - }, - error : function(jqXHR, textStatus, errorThrown) { - if (jqXHR.status == 500) { - apexErrorDialog_activate(document.body, jqXHR.responseText); - } - } - }); +function ajax_upload(requestURL, callback, hostName, port, fileUrl, ignoreConflicts, forceUpdate) { + var formData = new FormData(); + formData.append("hostName", hostName); + formData.append("port", port); + formData.append("file", fileUrl); + formData.append("ignoreConflicts", ignoreConflicts); + formData.append("forceUpdate", forceUpdate); + return $.ajax({ + url : requestURL, + type : "POST", + contentType : false, + dataType : "text", + processData : false, + data : formData, + success : function(data, textStatus, jqXHR) { + callback(data); + }, + error : function(jqXHR, textStatus, errorThrown) { + if (jqXHR.status == 500) { + apexErrorDialog_activate(document.body, jqXHR.responseText); + } + } + }); } diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexChart.js b/client/client-monitoring/src/main/resources/webapp/js/ApexChart.js index 438a3e5d9..7a288f5c1 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexChart.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexChart.js @@ -22,112 +22,112 @@ * Create a chart and append it to a container */ function createChart(data, container, title, unit, lineStroke, nodeColour) { - // Set the dimensions of the canvas - var margin = { - top : 30, - right : 20, - bottom : 30, - left : 50 - }, width = 600 - margin.left - margin.right, height = 270 - margin.top - - margin.bottom; - - // Set the ranges - var x = d3.time.scale().range([ 0, width ]); - var y = d3.scale.linear().range([ height, 0 ]); - - // Define the axes - var xAxis = d3.svg.axis().scale(x).orient("bottom").ticks(5).innerTickSize( - -height).outerTickSize(0).tickPadding(10); - - var yAxis = d3.svg.axis().scale(y).orient("left").ticks(10).innerTickSize( - -width).outerTickSize(0).tickPadding(10); - - // Define the line - var valueline = d3.svg.line().x(function(d) { - return x(d.timestamp); - }).y(function(d) { - return y(d.value); - }); - - // Add the svg canvas to the container - var svg = d3.select(container).append("svg").attr("preserveAspectRatio", - "xMinYMin meet").attr("viewBox", "0 0 600 400").classed( - "svg-content-responsive", true).append("g").attr("transform", - "translate(" + margin.left + "," + margin.top + ")"); - - // Set the unit for the value - svg.attr("unit", unit); - - // Format the data for the chart - data.forEach(function(d) { - d.timestamp = d.timestamp; - d.value = +d.value; - }); - - // Scale the range of the data - x.domain(d3.extent(data, function(d) { - return d.timestamp; - })); - y.domain([ 0, d3.max(data, function(d) { - return Math.ceil((d.value + 1) / 10) * 10; - }) ]); - - // Set the colour of the line - if (!lineStroke) { - lineStroke = "#5fbadd" - } - - // Set the colour of the circles - if (!nodeColour) { - nodeColour = "#00A9D4" - } - - // Add the valueline path - svg.append("path").attr("class", "line").data(data).attr("unit", unit) - .attr("stroke", lineStroke).attr("d", valueline(data)); - - // Add the scatterplot - svg.selectAll("circle").data(data).enter().append("circle").attr("r", 3.5) - .attr("class", "circle").attr("fill", nodeColour).attr("cx", - function(d) { - return x(d.timestamp); - }).attr("cy", function(d) { - return y(d.value); - }) - - // Apply the tooltip to each node - .on( - "mouseover", - function(d) { - d3.select("body").select(".tooltip").transition() - .duration(50).style("opacity", 1); - d3.select("body").select(".tooltip").html( - formatDate(new Date(d.timestamp)) + "<br/>" - + d.value + (unit ? " " + unit : "")) - .style("left", (d3.event.pageX) + "px").style( - "top", (d3.event.pageY - 28) + "px"); - }).on( - "mouseout", - function(d) { - d3.select("body").select(".tooltip").transition() - .duration(500).style("opacity", 0); - }); - - // Add the X Axis - svg.append("g").attr("class", "x axis").attr("transform", - "translate(0," + height + ")").call(xAxis); - - // Add the Y Axis - svg.append("g").attr("class", "y axis").call(yAxis); - - // Add the title - svg.append("text").attr("x", (width / 2)).attr("y", 0 - (margin.top / 2)) - .attr("text-anchor", "middle").style("font-size", "16px").style( - "text-decoration", "underline").text(title); - - // Add the background - svg.selectAll(".tick:not(:first-of-type) line").attr("stroke", "#777") - .attr("stroke-dasharray", "2,2"); + // Set the dimensions of the canvas + var margin = { + top : 30, + right : 20, + bottom : 30, + left : 50 + }, width = 600 - margin.left - margin.right, height = 270 - margin.top + - margin.bottom; + + // Set the ranges + var x = d3.time.scale().range([ 0, width ]); + var y = d3.scale.linear().range([ height, 0 ]); + + // Define the axes + var xAxis = d3.svg.axis().scale(x).orient("bottom").ticks(5).innerTickSize( + -height).outerTickSize(0).tickPadding(10); + + var yAxis = d3.svg.axis().scale(y).orient("left").ticks(10).innerTickSize( + -width).outerTickSize(0).tickPadding(10); + + // Define the line + var valueline = d3.svg.line().x(function(d) { + return x(d.timestamp); + }).y(function(d) { + return y(d.value); + }); + + // Add the svg canvas to the container + var svg = d3.select(container).append("svg").attr("preserveAspectRatio", + "xMinYMin meet").attr("viewBox", "0 0 600 400").classed( + "svg-content-responsive", true).append("g").attr("transform", + "translate(" + margin.left + "," + margin.top + ")"); + + // Set the unit for the value + svg.attr("unit", unit); + + // Format the data for the chart + data.forEach(function(d) { + d.timestamp = d.timestamp; + d.value = +d.value; + }); + + // Scale the range of the data + x.domain(d3.extent(data, function(d) { + return d.timestamp; + })); + y.domain([ 0, d3.max(data, function(d) { + return Math.ceil((d.value + 1) / 10) * 10; + }) ]); + + // Set the colour of the line + if (!lineStroke) { + lineStroke = "#5fbadd" + } + + // Set the colour of the circles + if (!nodeColour) { + nodeColour = "#00A9D4" + } + + // Add the valueline path + svg.append("path").attr("class", "line").data(data).attr("unit", unit) + .attr("stroke", lineStroke).attr("d", valueline(data)); + + // Add the scatterplot + svg.selectAll("circle").data(data).enter().append("circle").attr("r", 3.5) + .attr("class", "circle").attr("fill", nodeColour).attr("cx", + function(d) { + return x(d.timestamp); + }).attr("cy", function(d) { + return y(d.value); + }) + + // Apply the tooltip to each node + .on( + "mouseover", + function(d) { + d3.select("body").select(".tooltip").transition() + .duration(50).style("opacity", 1); + d3.select("body").select(".tooltip").html( + formatDate(new Date(d.timestamp)) + "<br/>" + + d.value + (unit ? " " + unit : "")) + .style("left", (d3.event.pageX) + "px").style( + "top", (d3.event.pageY - 28) + "px"); + }).on( + "mouseout", + function(d) { + d3.select("body").select(".tooltip").transition() + .duration(500).style("opacity", 0); + }); + + // Add the X Axis + svg.append("g").attr("class", "x axis").attr("transform", + "translate(0," + height + ")").call(xAxis); + + // Add the Y Axis + svg.append("g").attr("class", "y axis").call(yAxis); + + // Add the title + svg.append("text").attr("x", (width / 2)).attr("y", 0 - (margin.top / 2)) + .attr("text-anchor", "middle").style("font-size", "16px").style( + "text-decoration", "underline").text(title); + + // Add the background + svg.selectAll(".tick:not(:first-of-type) line").attr("stroke", "#777") + .attr("stroke-dasharray", "2,2"); } /* @@ -135,108 +135,108 @@ function createChart(data, container, title, unit, lineStroke, nodeColour) { * are not empty on load */ function generateRandomData() { - var data = []; - for (var i = 0; i < 30; i++) { - data.push({ - timestamp : new Date().getTime() - (i * 5000), - value : Math.floor(Math.random() * 100) + 1 - }); - } - return data; + var data = []; + for (var i = 0; i < 30; i++) { + data.push({ + timestamp : new Date().getTime() - (i * 5000), + value : Math.floor(Math.random() * 100) + 1 + }); + } + return data; } /* * Update a chart belonging to a specific container */ function updateChart(container, data, nodeColour) { - var margin = { - top : 30, - right : 20, - bottom : 30, - left : 50 - }, width = 600 - margin.left - margin.right, height = 270 - margin.top - - margin.bottom; - var parseDate = d3.time.format("%d-%b-%y").parse; - - // Format the data for the chart - data.forEach(function(d) { - d.timestamp = d.timestamp; - d.value = +d.value; - }); - - // Select the chart - var svg = d3.select(container); - - // Set the ranges - var x = d3.time.scale().range([ 0, width ]); - var y = d3.scale.linear().range([ height, 0 ]); - - // Define the axes - var xAxis = d3.svg.axis().scale(x).orient("bottom").ticks(5).innerTickSize( - -height).outerTickSize(0).tickPadding(10); - - var yAxis = d3.svg.axis().scale(y).orient("left").ticks(10).innerTickSize( - -width).outerTickSize(0).tickPadding(10); - - // Scale the range of the data - x.domain(d3.extent(data, function(d) { - return d.timestamp; - })); - y.domain([ 0, d3.max(data, function(d) { - return Math.ceil((d.value + 1) / 10) * 10; - }) ]); - - // Update the valueline path - var valueline = d3.svg.line().x(function(d) { - return x(d.timestamp); - }).y(function(d) { - return y(d.value); - }); - - var unit = svg.select(".line").attr("unit"); - - // Remove all nodes - svg.selectAll("circle").remove(); - - // Set the node colour if one is passed in - if (!nodeColour) { - nodeColour = "#00A9D4" - } - - // Make the changes - svg.select(".line").data(data) // change the line - .transition().duration(750).attr("d", valueline(data)); - svg.select(".x.axis") // change the x axis - .transition().duration(750).call(xAxis.ticks(5)); - svg.select(".y.axis") // change the y axis - .transition().duration(750).call(yAxis); - - // Redraw the nodes based on the new data - svg.select("svg").select("g").selectAll("circle").data(data).enter() - .append("circle").attr("r", 3.5).attr("class", "circle").attr( - "fill", nodeColour).attr("cx", function(d) { - return x(d.timestamp); - }).attr("cy", function(d) { - return y(d.value); - }) - - // Apply the tooltip to each node - .on( - "mouseover", - function(d) { - d3.select("body").select(".tooltip").transition() - .duration(50).style("opacity", 1); - d3.select("body").select(".tooltip").html( - formatDate(new Date(d.timestamp)) + "<br/>" - + d.value + (unit ? " " + unit : "")) - .style("left", (d3.event.pageX) + "px").style( - "top", (d3.event.pageY - 28) + "px"); - }).on( - "mouseout", - function(d) { - d3.select("body").select(".tooltip").transition() - .duration(500).style("opacity", 0); - }); + var margin = { + top : 30, + right : 20, + bottom : 30, + left : 50 + }, width = 600 - margin.left - margin.right, height = 270 - margin.top + - margin.bottom; + var parseDate = d3.time.format("%d-%b-%y").parse; + + // Format the data for the chart + data.forEach(function(d) { + d.timestamp = d.timestamp; + d.value = +d.value; + }); + + // Select the chart + var svg = d3.select(container); + + // Set the ranges + var x = d3.time.scale().range([ 0, width ]); + var y = d3.scale.linear().range([ height, 0 ]); + + // Define the axes + var xAxis = d3.svg.axis().scale(x).orient("bottom").ticks(5).innerTickSize( + -height).outerTickSize(0).tickPadding(10); + + var yAxis = d3.svg.axis().scale(y).orient("left").ticks(10).innerTickSize( + -width).outerTickSize(0).tickPadding(10); + + // Scale the range of the data + x.domain(d3.extent(data, function(d) { + return d.timestamp; + })); + y.domain([ 0, d3.max(data, function(d) { + return Math.ceil((d.value + 1) / 10) * 10; + }) ]); + + // Update the valueline path + var valueline = d3.svg.line().x(function(d) { + return x(d.timestamp); + }).y(function(d) { + return y(d.value); + }); + + var unit = svg.select(".line").attr("unit"); + + // Remove all nodes + svg.selectAll("circle").remove(); + + // Set the node colour if one is passed in + if (!nodeColour) { + nodeColour = "#00A9D4" + } + + // Make the changes + svg.select(".line").data(data) // change the line + .transition().duration(750).attr("d", valueline(data)); + svg.select(".x.axis") // change the x axis + .transition().duration(750).call(xAxis.ticks(5)); + svg.select(".y.axis") // change the y axis + .transition().duration(750).call(yAxis); + + // Redraw the nodes based on the new data + svg.select("svg").select("g").selectAll("circle").data(data).enter() + .append("circle").attr("r", 3.5).attr("class", "circle").attr( + "fill", nodeColour).attr("cx", function(d) { + return x(d.timestamp); + }).attr("cy", function(d) { + return y(d.value); + }) + + // Apply the tooltip to each node + .on( + "mouseover", + function(d) { + d3.select("body").select(".tooltip").transition() + .duration(50).style("opacity", 1); + d3.select("body").select(".tooltip").html( + formatDate(new Date(d.timestamp)) + "<br/>" + + d.value + (unit ? " " + unit : "")) + .style("left", (d3.event.pageX) + "px").style( + "top", (d3.event.pageY - 28) + "px"); + }).on( + "mouseout", + function(d) { + d3.select("body").select(".tooltip").transition() + .duration(500).style("opacity", 0); + }); } @@ -244,13 +244,13 @@ function updateChart(container, data, nodeColour) { * Initialize a singleton div used as a floating tooltip for all charts */ function initTooltip() { - d3.select("body").append("div").attr("class", "tooltip").attr("id", - "tooltip").style("opacity", 0); + d3.select("body").append("div").attr("class", "tooltip").attr("id", + "tooltip").style("opacity", 0); } /* * Format a date object to string */ function formatDate(date) { - return date.toLocaleString().replace(',', ''); + return date.toLocaleString().replace(',', ''); }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexContext.js b/client/client-monitoring/src/main/resources/webapp/js/ApexContext.js index 437d8177d..8e249ac0b 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexContext.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexContext.js @@ -22,73 +22,72 @@ * Create a Context Table */ function createEngineContextTable(wrapper) { - var tableId = config.engineContext.tableId; - var headers = config.engineContext.headers.map(function(a) { - return a.title; - }); - return createEngineTable($(wrapper), tableId, headers); + var tableId = config.engineContext.tableId; + var headers = config.engineContext.headers.map(function(a) { + return a.title; + }); + return createEngineTable($(wrapper), tableId, headers); } /* * Update each Context Table with the latest data */ function setEngineContextData(engineContextData) { - var tableId = config.engineContext.tableId; - for ( var ecd in engineContextData) { - var id = tableId + "_" + engineContextData[ecd].id; - var existingTable = undefined; - for ( var ect in this.engineContextTables) { - if (id === this.engineContextTables[ect].getAttribute("id")) { - existingTable = this.engineContextTables[ect]; - } - } - var engineInfo = JSON.parse(engineContextData[ecd].engine_info); - var contextAlbums = engineInfo.ContextAlbums; - var data = []; + var tableId = config.engineContext.tableId; + for ( var ecd in engineContextData) { + var id = tableId + "_" + engineContextData[ecd].id; + var existingTable = undefined; + for ( var ect in this.engineContextTables) { + if (id === this.engineContextTables[ect].getAttribute("id")) { + existingTable = this.engineContextTables[ect]; + } + } + var engineInfo = JSON.parse(engineContextData[ecd].engine_info); + var contextAlbums = engineInfo.ContextAlbums; + var data = []; - for ( var ca in contextAlbums) { - var cAlbumn = contextAlbums[ca]; - data.push([ cAlbumn.AlbumKey.name, cAlbumn.AlbumKey.version, - JSON.stringify(cAlbumn.AlbumContent, undefined, 50) ]); - } + for ( var ca in contextAlbums) { + var cAlbumn = contextAlbums[ca]; + data.push([ cAlbumn.AlbumKey.name, cAlbumn.AlbumKey.version, + JSON.stringify(cAlbumn.AlbumContent, undefined, 50) ]); + } - var table = existingTable; - // If no table already exists for the context, add one - if (!table) { - var wrapper = document.createElement("div"); - wrapper.setAttribute("class", "engineContextWrapper"); - var title = document.createElement("div"); - title.setAttribute("class", "engineContextTitle"); - title.innerHTML = engineContextData[ecd].id; - $(wrapper).append(title); - $("." + config.engineContext.parent).append(wrapper); - table = createEngineContextTable(wrapper); - table.setAttribute("id", id); - table.style["margin-bottom"] = "10px"; - this.engineContextTables.push(table); - } + var table = existingTable; + // If no table already exists for the context, add one + if (!table) { + var wrapper = document.createElement("div"); + wrapper.setAttribute("class", "engineContextWrapper"); + var title = document.createElement("div"); + title.setAttribute("class", "engineContextTitle"); + title.innerHTML = engineContextData[ecd].id; + $(wrapper).append(title); + $("." + config.engineContext.parent).append(wrapper); + table = createEngineContextTable(wrapper); + table.setAttribute("id", id); + table.style["margin-bottom"] = "10px"; + this.engineContextTables.push(table); + } - var old_data = $(table).data(tableId); - if (!deepCompare(old_data, data)) { - $(table).find("tbody").remove(); - var tbody = document.createElement("tbody"); + var old_data = $(table).data(tableId); + if (!deepCompare(old_data, data)) { + $(table).find("tbody").remove(); + var tbody = document.createElement("tbody"); - for ( var d in data) { - var rowData = data[d]; - var row = document.createElement("tr"); - var rowContent = "<tr>"; - for ( var rd in rowData) { - var tdClass = (rd == 2 ? "dataTd_wordwrap" : "dataTd"); - rowContent += "<td class=" + tdClass + ">" + rowData[rd] - + "</td>"; - } - rowContent += "</tr>"; - row.innerHTML = rowContent; - $(tbody).append(row); - } - $(table).data(tableId, data); - $(table).append(tbody); - } + for ( var d in data) { + var rowData = data[d]; + var row = document.createElement("tr"); + var rowContent = "<tr>"; + for ( var rd in rowData) { + var tdClass = (rd == 2 ? "dataTd_wordwrap" : "dataTd"); + rowContent += "<td class=" + tdClass + ">" + rowData[rd] + "</td>"; + } + rowContent += "</tr>"; + row.innerHTML = rowContent; + $(tbody).append(row); + } + $(table).data(tableId, data); + $(table).append(tbody); + } - } + } }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineService.js b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineService.js index 0573dd886..f47c98f07 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineService.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineService.js @@ -22,43 +22,42 @@ * Create the Engine Service Table */ function createEngineServiceTable() { - var tableId = config.engineService.tableId; - var headers = config.engineService.headers; - var table = createEngineTable($("." + config.engineService.parent), - tableId, headers.map(function(a) { - return a.title; - })); - var tableRow = document.createElement("tr"); - var tableData = ""; - for ( var h in headers) { - tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; - } - tableRow.innerHTML = tableData; - var actionTD = $(tableRow).find("#" + tableId + "_periodic_events"); - actionTD - .html('<input type="text" name="period" id="period" style="display:inline-block"><label class="ebSwitcher"><input type="checkbox" class="ebSwitcher-checkbox" /><div class="ebSwitcher-body"><div class="ebSwitcher-onLabel">Stopped</div><div class="ebSwitcher-switch"></div><div class="ebSwitcher-offLabel">Started</div></div></label>'); - var period = actionTD.find("#period"); - var switcher = actionTD.find(".ebSwitcher"); - switcher.css('display', 'inline-block'); - switcher.css('margin-left', '5px'); - switcher.css('vertical-align', 'middle'); - var checkbox = $(actionTD).find('input:checkbox:first'); - checkbox.change(function(event) { - var startstop; - if (checkbox.prop('checked')) { - startstop = "Stop"; - } else { - startstop = "Start"; - } - this.servicesCall.abort(); - ajax_get(restRootURL + "periodiceventstartstop", startStopCallback, - this.engineURL.hostname, this.engineURL.port, { - engineId : this.engineId, - startstop : startstop, - period : period.val() - }, resetPeriodicEvents); - }.bind(this)); - $(table).children("#engineTableBody").append(tableRow); + var tableId = config.engineService.tableId; + var headers = config.engineService.headers; + var table = createEngineTable($("." + config.engineService.parent), tableId, headers.map(function(a) { + return a.title; + })); + var tableRow = document.createElement("tr"); + var tableData = ""; + for ( var h in headers) { + tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; + } + tableRow.innerHTML = tableData; + var actionTD = $(tableRow).find("#" + tableId + "_periodic_events"); + actionTD + .html('<input type="text" name="period" id="period" style="display:inline-block"><label class="ebSwitcher"><input type="checkbox" class="ebSwitcher-checkbox" /><div class="ebSwitcher-body"><div class="ebSwitcher-onLabel">Stopped</div><div class="ebSwitcher-switch"></div><div class="ebSwitcher-offLabel">Started</div></div></label>'); + var period = actionTD.find("#period"); + var switcher = actionTD.find(".ebSwitcher"); + switcher.css('display', 'inline-block'); + switcher.css('margin-left', '5px'); + switcher.css('vertical-align', 'middle'); + var checkbox = $(actionTD).find('input:checkbox:first'); + checkbox.change(function(event) { + var startstop; + if (checkbox.prop('checked')) { + startstop = "Stop"; + } else { + startstop = "Start"; + } + this.servicesCall.abort(); + ajax_get(restRootURL + "periodiceventstartstop", startStopCallback, this.engineURL.hostname, + this.engineURL.port, { + engineId : this.engineId, + startstop : startstop, + period : period.val() + }, resetPeriodicEvents); + }.bind(this)); + $(table).children("#engineTableBody").append(tableRow); } /* @@ -66,39 +65,37 @@ function createEngineServiceTable() { * necessary */ function setEngineServiceData(engineId, modelId, server, port, periodicEvents) { - this.engineId = engineId; - var tableId = config.engineService.tableId; - var headers = config.engineService.headers.map(function(a) { - return a.id; - }); - var data = [ engineId, server + ":" + port, modelId ]; + this.engineId = engineId; + var tableId = config.engineService.tableId; + var headers = config.engineService.headers.map(function(a) { + return a.id; + }); + var data = [ engineId, server + ":" + port, modelId ]; - var engineServiceTable = $("#engineServicesTable"); + var engineServiceTable = $("#engineServicesTable"); - for ( var h in headers) { - var td = engineServiceTable.find("#" + tableId + "_" + headers[h]); - if (td.html() !== data[h]) { - engineServiceTable.find("#" + tableId + "_" + headers[h]).html( - data[h]); - } - } + for ( var h in headers) { + var td = engineServiceTable.find("#" + tableId + "_" + headers[h]); + if (td.html() !== data[h]) { + engineServiceTable.find("#" + tableId + "_" + headers[h]).html(data[h]); + } + } - var actionTD = engineServiceTable.find("#" + tableId + "_periodic_events"); - var checkbox = $(actionTD).find('input:checkbox:first'); - if (checkbox.is(":checked") === periodicEvents) { - checkbox.prop("checked", !checkbox.prop("checked")); - } + var actionTD = engineServiceTable.find("#" + tableId + "_periodic_events"); + var checkbox = $(actionTD).find('input:checkbox:first'); + if (checkbox.is(":checked") === periodicEvents) { + checkbox.prop("checked", !checkbox.prop("checked")); + } } /* * Resets the switcher for Periodic Events in the Engine Service Table */ function resetPeriodicEvents() { - var engineServiceTable = $("#engineServicesTable"); - var periodicEventsTD = $(engineServiceTable).find( - "#engineServicesTable_periodic_events"); - var checkbox = $(periodicEventsTD).find('input:checkbox:first'); - if (checkbox.is(":checked")) { - checkbox.prop("checked", false); - } + var engineServiceTable = $("#engineServicesTable"); + var periodicEventsTD = $(engineServiceTable).find("#engineServicesTable_periodic_events"); + var checkbox = $(periodicEventsTD).find('input:checkbox:first'); + if (checkbox.is(":checked")) { + checkbox.prop("checked", false); + } } diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineStatus.js b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineStatus.js index 832a704f7..36a89dab0 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineStatus.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineStatus.js @@ -22,73 +22,64 @@ * Create an Engine Status Table and its charts */ function createEngineStatusTable(id, startStopStatus) { - var tableId = config.engineStatus.tableId; - var headers = config.engineStatus.headers; + var tableId = config.engineStatus.tableId; + var headers = config.engineStatus.headers; - // Create a wrapper div for both the table and the charts - var wrapper = document.createElement("div"); - wrapper.setAttribute("id", id + "_wrapper"); - wrapper.setAttribute("class", "wrapper"); - $("." + config.engineStatus.parent).append(wrapper); + // Create a wrapper div for both the table and the charts + var wrapper = document.createElement("div"); + wrapper.setAttribute("id", id + "_wrapper"); + wrapper.setAttribute("class", "wrapper"); + $("." + config.engineStatus.parent).append(wrapper); - // Create the table - var table = createEngineTable($(wrapper), id, headers.map(function(a) { - return a.title; - })); - var tableRow = document.createElement("tr"); - var tableData = ""; - for ( var h in headers) { - tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; - } - tableRow.innerHTML = tableData; - var actionTD = $(tableRow).find("#" + tableId + "_action"); - var checked = (startStopStatus === "STOPPED") ? "checked" : ""; - var chartWrapper = document.createElement("div"); - chartWrapper.setAttribute("id", "chartWrapper"); - actionTD - .html('<label class="ebSwitcher"><input type="checkbox" ' - + checked - + ' class="ebSwitcher-checkbox" /><div class="ebSwitcher-body"><div class="ebSwitcher-onLabel">Stopped</div><div class="ebSwitcher-switch"></div><div class="ebSwitcher-offLabel">Started</div></div></label>'); + // Create the table + var table = createEngineTable($(wrapper), id, headers.map(function(a) { + return a.title; + })); + var tableRow = document.createElement("tr"); + var tableData = ""; + for ( var h in headers) { + tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; + } + tableRow.innerHTML = tableData; + var actionTD = $(tableRow).find("#" + tableId + "_action"); + var checked = (startStopStatus === "STOPPED") ? "checked" : ""; + var chartWrapper = document.createElement("div"); + chartWrapper.setAttribute("id", "chartWrapper"); + actionTD + .html('<label class="ebSwitcher"><input type="checkbox" ' + + checked + + ' class="ebSwitcher-checkbox" /><div class="ebSwitcher-body"><div class="ebSwitcher-onLabel">Stopped</div><div class="ebSwitcher-switch"></div><div class="ebSwitcher-offLabel">Started</div></div></label>'); - var checkbox = $(actionTD).find('input:checkbox:first'); - checkbox.change(function(event) { - var startstop; - if (checkbox.prop('checked')) { - startstop = "Stop"; - } else { - startstop = "Start"; - } - this.servicesCall.abort(); - ajax_get(restRootURL + "startstop", startStopCallback, - this.engineURL.hostname, this.engineURL.port, { - engineId : id.split("_")[1], - startstop : startstop - }); - }.bind(this)); + var checkbox = $(actionTD).find('input:checkbox:first'); + checkbox.change(function(event) { + var startstop; + if (checkbox.prop('checked')) { + startstop = "Stop"; + } else { + startstop = "Start"; + } + this.servicesCall.abort(); + ajax_get(restRootURL + "startstop", startStopCallback, this.engineURL.hostname, this.engineURL.port, { + engineId : id.split("_")[1], + startstop : startstop + }); + }.bind(this)); - $(table).children("#engineTableBody").append(tableRow); + $(table).children("#engineTableBody").append(tableRow); - var expand = document.createElement("i"); - expand - .setAttribute("class", - "ebIcon ebIcon_rowExpanded ebIcon_large ebIcon_interactive expandIcon"); - $(expand) - .click( - function() { - if ($(chartWrapper).is(":visible")) { - expand - .setAttribute("class", - "ebIcon ebIcon_rowCollapsed ebIcon_large ebIcon_interactive expandIcon"); - } else { - expand - .setAttribute("class", - "ebIcon ebIcon_rowExpanded ebIcon_large ebIcon_interactive expandIcon"); - } - $(chartWrapper).slideToggle(); - }.bind(this)); - $(wrapper).append(expand); - $(wrapper).append(chartWrapper); - return table; + var expand = document.createElement("i"); + expand.setAttribute("class", "ebIcon ebIcon_rowExpanded ebIcon_large ebIcon_interactive expandIcon"); + $(expand).click(function() { + if ($(chartWrapper).is(":visible")) { + expand.setAttribute("class", "ebIcon ebIcon_rowCollapsed ebIcon_large ebIcon_interactive expandIcon"); + } else { + expand.setAttribute("class", "ebIcon ebIcon_rowExpanded ebIcon_large ebIcon_interactive expandIcon"); + } + $(chartWrapper).slideToggle(); + }.bind(this)); + $(wrapper).append(expand); + $(wrapper).append(chartWrapper); + return table; } /* @@ -96,89 +87,81 @@ function createEngineStatusTable(id, startStopStatus) { * update only where necessary */ function setEngineStatusData(engineStatusData) { - var tableId = config.engineStatus.tableId; - var headers = config.engineStatus.headers.map(function(a) { - return a.id; - }); - for ( var esd in engineStatusData) { - var id = tableId + "_" + engineStatusData[esd].id; - var existingTable = undefined; - for ( var est in this.engineStatusTables) { - if (id === this.engineStatusTables[est].getAttribute("id")) { - existingTable = this.engineStatusTables[est]; - } - } + var tableId = config.engineStatus.tableId; + var headers = config.engineStatus.headers.map(function(a) { + return a.id; + }); + for ( var esd in engineStatusData) { + var id = tableId + "_" + engineStatusData[esd].id; + var existingTable = undefined; + for ( var est in this.engineStatusTables) { + if (id === this.engineStatusTables[est].getAttribute("id")) { + existingTable = this.engineStatusTables[est]; + } + } - var data = [ engineStatusData[esd].timestamp, id.split("_")[1], - engineStatusData[esd].status, - engineStatusData[esd].last_message, - engineStatusData[esd].up_time, - engineStatusData[esd].policy_executions ]; + var data = [ engineStatusData[esd].timestamp, id.split("_")[1], engineStatusData[esd].status, + engineStatusData[esd].last_message, engineStatusData[esd].up_time, + engineStatusData[esd].policy_executions ]; - var table = existingTable; - // If no table already exists for the engine, add one - if (!table) { - table = createEngineStatusTable(id, engineStatusData[esd].status); - table.setAttribute("id", id); - table.style["margin-bottom"] = "10px"; - table.style.display = "inline-block"; - this.engineStatusTables.push(table); - } + var table = existingTable; + // If no table already exists for the engine, add one + if (!table) { + table = createEngineStatusTable(id, engineStatusData[esd].status); + table.setAttribute("id", id); + table.style["margin-bottom"] = "10px"; + table.style.display = "inline-block"; + this.engineStatusTables.push(table); + } - // Update data in table - for ( var h in headers) { - var td = $(table).find("#" + tableId + "_" + headers[h]); - if (td.html() !== data[h]) { - $(table).find("#" + tableId + "_" + headers[h]).html(data[h]); - } - } + // Update data in table + for ( var h in headers) { + var td = $(table).find("#" + tableId + "_" + headers[h]); + if (td.html() !== data[h]) { + $(table).find("#" + tableId + "_" + headers[h]).html(data[h]); + } + } - var checked = (engineStatusData[esd].status === "STOPPED"); - var actionTD = $(table).find("#engineStatusTable_action"); - var checkbox = $(actionTD).find('input:checkbox:first'); - if (checkbox.is(":checked") !== checked) { - checkbox.prop("checked", !checkbox.prop("checked")); - } + var checked = (engineStatusData[esd].status === "STOPPED"); + var actionTD = $(table).find("#engineStatusTable_action"); + var checkbox = $(actionTD).find('input:checkbox:first'); + if (checkbox.is(":checked") !== checked) { + checkbox.prop("checked", !checkbox.prop("checked")); + } - // Update charts - var wrapper = $(table).parent(); - var chartWrapper = $(wrapper).find("#chartWrapper") + // Update charts + var wrapper = $(table).parent(); + var chartWrapper = $(wrapper).find("#chartWrapper") - var chartConfig = this.config.engineChart.lastPolicyDurationChart; - var lastPolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; - if (lastPolicyDurationChart) { - updateChart(lastPolicyDurationChart, JSON - .parse(engineStatusData[esd].last_policy_duration), - chartConfig.nodeColour); - } else { - chartConfig = this.config.engineChart.lastPolicyDurationChart; - var lastPolicyDurationDiv = document.createElement("div"); - lastPolicyDurationDiv.setAttribute("id", chartConfig.parent); - lastPolicyDurationDiv.setAttribute("class", "apexChart"); - createChart(JSON.parse(engineStatusData[esd].last_policy_duration), - lastPolicyDurationDiv, chartConfig.title, chartConfig.unit, - chartConfig.lineStroke, chartConfig.nodeColour); - $(chartWrapper).append(lastPolicyDurationDiv); - } + var chartConfig = this.config.engineChart.lastPolicyDurationChart; + var lastPolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; + if (lastPolicyDurationChart) { + updateChart(lastPolicyDurationChart, JSON.parse(engineStatusData[esd].last_policy_duration), + chartConfig.nodeColour); + } else { + chartConfig = this.config.engineChart.lastPolicyDurationChart; + var lastPolicyDurationDiv = document.createElement("div"); + lastPolicyDurationDiv.setAttribute("id", chartConfig.parent); + lastPolicyDurationDiv.setAttribute("class", "apexChart"); + createChart(JSON.parse(engineStatusData[esd].last_policy_duration), lastPolicyDurationDiv, + chartConfig.title, chartConfig.unit, chartConfig.lineStroke, chartConfig.nodeColour); + $(chartWrapper).append(lastPolicyDurationDiv); + } - chartConfig = this.config.engineChart.averagePolicyDurationChart; - var averagePolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; - if (averagePolicyDurationChart) { - updateChart(averagePolicyDurationChart, JSON - .parse(engineStatusData[esd].average_policy_duration), - chartConfig.nodeColour); - } else { - chartConfig = this.config.engineChart.averagePolicyDurationChart; - var averagePolicyDurationDiv = document.createElement("div"); - averagePolicyDurationDiv.setAttribute("id", chartConfig.parent); - averagePolicyDurationDiv.setAttribute("class", "apexChart"); - createChart(JSON - .parse(engineStatusData[esd].average_policy_duration), - averagePolicyDurationDiv, chartConfig.title, - chartConfig.unit, chartConfig.lineStroke, - chartConfig.nodeColour); - $(chartWrapper).append(averagePolicyDurationDiv); - } + chartConfig = this.config.engineChart.averagePolicyDurationChart; + var averagePolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; + if (averagePolicyDurationChart) { + updateChart(averagePolicyDurationChart, JSON.parse(engineStatusData[esd].average_policy_duration), + chartConfig.nodeColour); + } else { + chartConfig = this.config.engineChart.averagePolicyDurationChart; + var averagePolicyDurationDiv = document.createElement("div"); + averagePolicyDurationDiv.setAttribute("id", chartConfig.parent); + averagePolicyDurationDiv.setAttribute("class", "apexChart"); + createChart(JSON.parse(engineStatusData[esd].average_policy_duration), averagePolicyDurationDiv, + chartConfig.title, chartConfig.unit, chartConfig.lineStroke, chartConfig.nodeColour); + $(chartWrapper).append(averagePolicyDurationDiv); + } - } + } }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineSummary.js b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineSummary.js index 8b4051467..8f1e7c9b6 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexEngineSummary.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexEngineSummary.js @@ -22,131 +22,125 @@ * Create the Engine Service Table */ function createEngineSummaryTable() { - var tableId = config.engineSummary.tableId; - var headers = config.engineSummary.headers; - - // Create a wrapper div for both the table and the charts - var wrapper = document.createElement("div"); - wrapper.setAttribute("id", "engineSummary_wrapper"); - wrapper.setAttribute("class", "wrapper_borderless"); - $("." + config.engineSummary.parent).append(wrapper); - - var table = createEngineTable($(wrapper), tableId, headers.map(function(a) { - return a.title; - })); - var tableRow = document.createElement("tr"); - var tableData = ""; - for ( var h in headers) { - tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; - } - tableRow.innerHTML = tableData; - - $(table).children("#engineTableBody").append(tableRow); + var tableId = config.engineSummary.tableId; + var headers = config.engineSummary.headers; + + // Create a wrapper div for both the table and the charts + var wrapper = document.createElement("div"); + wrapper.setAttribute("id", "engineSummary_wrapper"); + wrapper.setAttribute("class", "wrapper_borderless"); + $("." + config.engineSummary.parent).append(wrapper); + + var table = createEngineTable($(wrapper), tableId, headers.map(function(a) { + return a.title; + })); + var tableRow = document.createElement("tr"); + var tableData = ""; + for ( var h in headers) { + tableData += "<td id=" + tableId + "_" + headers[h].id + "></td>"; + } + tableRow.innerHTML = tableData; + + $(table).children("#engineTableBody").append(tableRow); } function setEngineSummaryData(data) { - this._setEngineSummaryData(getLatestTimestamp(data), - getUptimeOfOldestEngine(data), getSumOfPolicyExecutions(data), - getAvgPolicyDuration(data)); + this._setEngineSummaryData(getLatestTimestamp(data), getUptimeOfOldestEngine(data), getSumOfPolicyExecutions(data), + getAvgPolicyDuration(data)); } /* * Check for any changes in the Engine Summary Table data and update only where * necessary */ -function _setEngineSummaryData(timestamp, upTime, policyExecutions, - avgPolicyDuration) { - - var tableId = config.engineSummary.tableId; - var headers = config.engineSummary.headers.map(function(a) { - return a.id; - }); - var data = [ timestamp, upTime, policyExecutions ]; - - var engineSummaryTable = $("#engineSummaryTable"); - - for ( var h in headers) { - var td = engineSummaryTable.find("#" + tableId + "_" + headers[h]); - if (td.html() !== data[h]) { - engineSummaryTable.find("#" + tableId + "_" + headers[h]).html( - data[h]); - } - } - - // Update charts - var wrapper = engineSummaryTable.parent(); - var chartConfig = this.config.engineSummary.chart.avgPolicyDurationChart; - var avgPolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; - if (avgPolicyDurationChart) { - updateChart(avgPolicyDurationChart, avgPolicyDuration, - chartConfig.nodeColour); - } else { - var avgPolicyDurationDiv = document.createElement("div"); - avgPolicyDurationDiv.setAttribute("id", chartConfig.parent); - avgPolicyDurationDiv.setAttribute("class", "apexChart_inline"); - createChart(avgPolicyDuration, avgPolicyDurationDiv, chartConfig.title, - chartConfig.unit, chartConfig.lineStroke, - chartConfig.nodeColour); - $(wrapper).append(avgPolicyDurationDiv); - } +function _setEngineSummaryData(timestamp, upTime, policyExecutions, avgPolicyDuration) { + + var tableId = config.engineSummary.tableId; + var headers = config.engineSummary.headers.map(function(a) { + return a.id; + }); + var data = [ timestamp, upTime, policyExecutions ]; + + var engineSummaryTable = $("#engineSummaryTable"); + + for ( var h in headers) { + var td = engineSummaryTable.find("#" + tableId + "_" + headers[h]); + if (td.html() !== data[h]) { + engineSummaryTable.find("#" + tableId + "_" + headers[h]).html(data[h]); + } + } + + // Update charts + var wrapper = engineSummaryTable.parent(); + var chartConfig = this.config.engineSummary.chart.avgPolicyDurationChart; + var avgPolicyDurationChart = wrapper.find("#" + chartConfig.parent)[0]; + if (avgPolicyDurationChart) { + updateChart(avgPolicyDurationChart, avgPolicyDuration, chartConfig.nodeColour); + } else { + var avgPolicyDurationDiv = document.createElement("div"); + avgPolicyDurationDiv.setAttribute("id", chartConfig.parent); + avgPolicyDurationDiv.setAttribute("class", "apexChart_inline"); + createChart(avgPolicyDuration, avgPolicyDurationDiv, chartConfig.title, chartConfig.unit, + chartConfig.lineStroke, chartConfig.nodeColour); + $(wrapper).append(avgPolicyDurationDiv); + } } function getLatestTimestamp(data) { - var latestTimestamp = { - displayText : "-1", - value : -1 - }; - for ( var d in data) { - var currentDateInMillis = new Date(data[d].timestamp.replace(/-/g, '/') - .split('.')[0]).getTime(); - if (currentDateInMillis > latestTimestamp.value) { - latestTimestamp.displayText = data[d].timestamp; - latestTimestamp.value = currentDateInMillis; - } - } - return latestTimestamp.displayText; + var latestTimestamp = { + displayText : "-1", + value : -1 + }; + for ( var d in data) { + var currentDateInMillis = new Date(data[d].timestamp.replace(/-/g, '/').split('.')[0]).getTime(); + if (currentDateInMillis > latestTimestamp.value) { + latestTimestamp.displayText = data[d].timestamp; + latestTimestamp.value = currentDateInMillis; + } + } + return latestTimestamp.displayText; } function getUptimeOfOldestEngine(data) { - var oldestUpTime = -1; - for ( var d in data) { - if (data[d].up_time > oldestUpTime) { - oldestUpTime = data[d].up_time; - } - } - return oldestUpTime; + var oldestUpTime = -1; + for ( var d in data) { + if (data[d].up_time > oldestUpTime) { + oldestUpTime = data[d].up_time; + } + } + return oldestUpTime; } function getSumOfPolicyExecutions(data) { - var totalPolicyExecutions = 0; - for ( var d in data) { - totalPolicyExecutions += data[d].policy_executions; - } - return totalPolicyExecutions; + var totalPolicyExecutions = 0; + for ( var d in data) { + totalPolicyExecutions += data[d].policy_executions; + } + return totalPolicyExecutions; } function getAvgPolicyDuration(data) { - var chartData = []; - var avgPolicyDurations = []; - for ( var d in data) { - var avgPolicyDuration = JSON.parse(data[d].average_policy_duration); - avgPolicyDurations.push(avgPolicyDuration); - } - - if (avgPolicyDurations.length > 0) { - chartData = avgPolicyDurations[0]; - for (var i = 1; i < avgPolicyDurations.length; i++) { - var engineData = avgPolicyDurations[i]; - for ( var c in chartData) { - chartData[c].value += engineData[c].value; - } - } - } - - for ( var c2 in chartData) { - chartData[c2].value = Math.round(chartData[c2].value / data.length); - } - - return chartData; + var chartData = []; + var avgPolicyDurations = []; + for ( var d in data) { + var avgPolicyDuration = JSON.parse(data[d].average_policy_duration); + avgPolicyDurations.push(avgPolicyDuration); + } + + if (avgPolicyDurations.length > 0) { + chartData = avgPolicyDurations[0]; + for (var i = 1; i < avgPolicyDurations.length; i++) { + var engineData = avgPolicyDurations[i]; + for ( var c in chartData) { + chartData[c].value += engineData[c].value; + } + } + } + + for ( var c2 in chartData) { + chartData[c2].value = Math.round(chartData[c2].value / data.length); + } + + return chartData; }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexServicesMain.js b/client/client-monitoring/src/main/resources/webapp/js/ApexServicesMain.js index f22b3077c..eb7d4db90 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexServicesMain.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexServicesMain.js @@ -22,162 +22,159 @@ var restRootURL; // Configuration used for page layout and charts var config = { - refresh : 5000, - engineService : { - parent : "engineService", - tableId : "engineServicesTable", - headers : [ { - title : "Engine Service ID", - id : "engine_id" - }, { - title : "server:port", - id : "server_port" - }, { - title : "Model ID", - id : "model_id" - }, { - title : "Periodic Events", - id : "periodic_events" - } ] - }, - engineSummary : { - parent : "engineSummary", - tableId : "engineSummaryTable", - headers : [ { - title : "Timestamp", - id : "timestamp" - }, { - title : "Up Time of oldest engine (ms)", - id : "up_time" - }, { - title : "Sum of policy executions", - id : "policy_executions" - } ], - chart : { - avgPolicyDurationChart : { - parent : "avgPolicyDuration", - title : "Average Policy Duration (ms)", - unit : "ms", - lineStroke : "#5FBADD", - nodeColour : "#00A9D4" - }, - } - }, - engineStatus : { - parent : "engineStatus", - tableId : "engineStatusTable", - headers : [ { - title : "Timestamp", - id : "timestamp" - }, { - title : "Engine ID", - id : "engine_id" - }, { - title : "Engine Status", - id : "engine_status" - }, { - title : "Last Message", - id : "last_message" - }, { - title : "Up Time (ms)", - id : "up_time" - }, { - title : "Policy Executions", - id : "policy_executions" - }, { - title : "Action", - id : "action" - } ] - }, - engineContext : { - parent : "context", - tableId : "engineContextTable", - headers : [ { - title : "Name", - id : "name" - }, { - title : "Version", - id : "version" - }, { - title : "Info", - id : "schema" - } ] - }, - engineChart : { - lastPolicyDurationChart : { - parent : "lastPolicyDurationChart", - title : "Last Policy Duration (ms)", - unit : "ms", - lineStroke : "#F5A241", - nodeColour : "#F08A00" - }, - averagePolicyDurationChart : { - parent : "averagePolicyDurationChart", - title : "Average Policy Duration (ms)", - unit : "ms", - lineStroke : "#00625F", - nodeColour : "#007B78" - } - } + refresh : 5000, + engineService : { + parent : "engineService", + tableId : "engineServicesTable", + headers : [ { + title : "Engine Service ID", + id : "engine_id" + }, { + title : "server:port", + id : "server_port" + }, { + title : "Model ID", + id : "model_id" + }, { + title : "Periodic Events", + id : "periodic_events" + } ] + }, + engineSummary : { + parent : "engineSummary", + tableId : "engineSummaryTable", + headers : [ { + title : "Timestamp", + id : "timestamp" + }, { + title : "Up Time of oldest engine (ms)", + id : "up_time" + }, { + title : "Sum of policy executions", + id : "policy_executions" + } ], + chart : { + avgPolicyDurationChart : { + parent : "avgPolicyDuration", + title : "Average Policy Duration (ms)", + unit : "ms", + lineStroke : "#5FBADD", + nodeColour : "#00A9D4" + }, + } + }, + engineStatus : { + parent : "engineStatus", + tableId : "engineStatusTable", + headers : [ { + title : "Timestamp", + id : "timestamp" + }, { + title : "Engine ID", + id : "engine_id" + }, { + title : "Engine Status", + id : "engine_status" + }, { + title : "Last Message", + id : "last_message" + }, { + title : "Up Time (ms)", + id : "up_time" + }, { + title : "Policy Executions", + id : "policy_executions" + }, { + title : "Action", + id : "action" + } ] + }, + engineContext : { + parent : "context", + tableId : "engineContextTable", + headers : [ { + title : "Name", + id : "name" + }, { + title : "Version", + id : "version" + }, { + title : "Info", + id : "schema" + } ] + }, + engineChart : { + lastPolicyDurationChart : { + parent : "lastPolicyDurationChart", + title : "Last Policy Duration (ms)", + unit : "ms", + lineStroke : "#F5A241", + nodeColour : "#F08A00" + }, + averagePolicyDurationChart : { + parent : "averagePolicyDurationChart", + title : "Average Policy Duration (ms)", + unit : "ms", + lineStroke : "#00625F", + nodeColour : "#007B78" + } + } }; function servicesCallback(data) { - // If engine url in cookie has not been cleared - if (localStorage.getItem("apex-monitor-services")) { - setEngineServiceData(data.engine_id, data.model_id, data.server, - data.port, data.periodic_events); - setEngineSummaryData(data.status); - setEngineStatusData(data.status); - setEngineContextData(data.context); - - // Make content visible after data has been returned for the first time - if (!$(".content").is(':visible')) { - $(".content").fadeIn(); - } - - // Repeat the same request - setTimeout(function() { - this.servicesCall = ajax_get(restRootURL, servicesCallback, - this.engineURL.hostname, this.engineURL.port); - }, config.refresh); - } + // If engine url in cookie has not been cleared + if (localStorage.getItem("apex-monitor-services")) { + setEngineServiceData(data.engine_id, data.model_id, data.server, data.port, data.periodic_events); + setEngineSummaryData(data.status); + setEngineStatusData(data.status); + setEngineContextData(data.context); + + // Make content visible after data has been returned for the first time + if (!$(".content").is(':visible')) { + $(".content").fadeIn(); + } + + // Repeat the same request + setTimeout(function() { + this.servicesCall = ajax_get(restRootURL, servicesCallback, this.engineURL.hostname, this.engineURL.port); + }, config.refresh); + } } /* * Callback for starting/stopping an engine/events */ function startStopCallback() { - this.servicesCall = ajax_get(restRootURL, servicesCallback, - this.engineURL.hostname, this.engineURL.port); + this.servicesCall = ajax_get(restRootURL, servicesCallback, this.engineURL.hostname, this.engineURL.port); } /* * Callback for uploading a model */ function uploadCallback(response) { - // Open a dialog showing the response - apexSuccessDialog_activate(document.body, response); + // Open a dialog showing the response + apexSuccessDialog_activate(document.body, response); } /* * Clears and resets all content on the page */ function setUpPage() { - // Hide all content - $('#content').hide(); + // Hide all content + $('#content').hide(); - // Clear each div - $('#content > div').each(function() { - $(this).empty(); - }); + // Clear each div + $('#content > div').each(function() { + $(this).empty(); + }); - // Reset trackers for tables - this.engineStatusTables = []; - this.engineContextTables = []; + // Reset trackers for tables + this.engineStatusTables = []; + this.engineContextTables = []; - // Set up content div's - createEngineServiceTable(); - createEngineSummaryTable(); + // Set up content div's + createEngineServiceTable(); + createEngineSummaryTable(); } /* @@ -185,69 +182,64 @@ function setUpPage() { * dialog is shown asking for it */ function getEngineURL(message) { - // The engine URL is stored in a cookie using the key - // "apex-monitor-services" - var engineURL = localStorage.getItem("apex-monitor-services"); - - // This url is used to store the last known engine URL so that the user - // doesn't have to retype it every time - var oldEngineURL = localStorage.getItem("apex-monitor-services_old"); - - // If an engine URL is stored in the cookie - if (engineURL) { - // Parse the engine URL - this.engineURL = JSON.parse(engineURL); - - // Send a request with that engine URL - this.servicesCall = ajax_get(restRootURL, servicesCallback, - this.engineURL.hostname, this.engineURL.port); - } else { - // Prompt for engine URL - apexDialogForm_activate(document.body, message); - } + // The engine URL is stored in a cookie using the key + // "apex-monitor-services" + var engineURL = localStorage.getItem("apex-monitor-services"); + + // This url is used to store the last known engine URL so that the user + // doesn't have to retype it every time + var oldEngineURL = localStorage.getItem("apex-monitor-services_old"); + + // If an engine URL is stored in the cookie + if (engineURL) { + // Parse the engine URL + this.engineURL = JSON.parse(engineURL); + + // Send a request with that engine URL + this.servicesCall = ajax_get(restRootURL, servicesCallback, this.engineURL.hostname, this.engineURL.port); + } else { + // Prompt for engine URL + apexDialogForm_activate(document.body, message); + } } /* * Clears the cookie and reset the page */ function clearEngineURL() { - // Remove engine URL from cookie - localStorage.removeItem("apex-monitor-services"); + // Remove engine URL from cookie + localStorage.removeItem("apex-monitor-services"); - // Reset the page - setUpPage(); + // Reset the page + setUpPage(); } /* * Called after the DOM is ready */ -$(document) - .ready( - function() { - restRootURL = location.protocol - + "//" - + window.location.hostname - + (location.port ? ':' + location.port : '') - + (location.pathname.endsWith("/monitoring/") ? location.pathname - .substring(0, location.pathname - .indexOf("monitoring/")) - : location.pathname) - + "apexservices/monitoring/"; - // Initialize tooltip for the charts - initTooltip(); - - // Set up the structure of the page - setUpPage(); - - // Check cookies for engine URL - getEngineURL(); - - // Add click event to config icon for clearing engine URL - $(".ebSystemBar-config").click(function() { - // Clear the engine URL - clearEngineURL(); - - // Request the engine URL - getEngineURL(); - }); - });
\ No newline at end of file +$(document).ready( + function() { + restRootURL = location.protocol + + "//" + + window.location.hostname + + (location.port ? ':' + location.port : '') + + (location.pathname.endsWith("/monitoring/") ? location.pathname.substring(0, location.pathname + .indexOf("monitoring/")) : location.pathname) + "apexservices/monitoring/"; + // Initialize tooltip for the charts + initTooltip(); + + // Set up the structure of the page + setUpPage(); + + // Check cookies for engine URL + getEngineURL(); + + // Add click event to config icon for clearing engine URL + $(".ebSystemBar-config").click(function() { + // Clear the engine URL + clearEngineURL(); + + // Request the engine URL + getEngineURL(); + }); + });
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexTable.js b/client/client-monitoring/src/main/resources/webapp/js/ApexTable.js index 95e9ec1f8..20e3d08bd 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexTable.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexTable.js @@ -22,39 +22,38 @@ * Create a table with given headers */ function createEngineTable(parent, id, tableHeaders) { - var table = createTable(id); + var table = createTable(id); - var tableHead = document.createElement("thead"); - table.appendChild(tableHead); - tableHead.setAttribute("id", "engineTableHeader"); + var tableHead = document.createElement("thead"); + table.appendChild(tableHead); + tableHead.setAttribute("id", "engineTableHeader"); - var tableHeaderRow = document.createElement("tr"); - tableHead.appendChild(tableHeaderRow); - tableHeaderRow.setAttribute("id", "engineTableHeaderRow"); + var tableHeaderRow = document.createElement("tr"); + tableHead.appendChild(tableHeaderRow); + tableHeaderRow.setAttribute("id", "engineTableHeaderRow"); - for ( var t in tableHeaders) { - var tableHeader = document.createElement("th"); - tableHeaderRow.appendChild(tableHeader); - tableHeader.setAttribute("id", "engineTableHeader"); - tableHeader.appendChild(document.createTextNode(tableHeaders[t])); - } + for ( var t in tableHeaders) { + var tableHeader = document.createElement("th"); + tableHeaderRow.appendChild(tableHeader); + tableHeader.setAttribute("id", "engineTableHeader"); + tableHeader.appendChild(document.createTextNode(tableHeaders[t])); + } - var tableBody = document.createElement("tbody"); - tableBody.setAttribute("id", "engineTableBody"); - table.appendChild(tableBody); + var tableBody = document.createElement("tbody"); + tableBody.setAttribute("id", "engineTableBody"); + table.appendChild(tableBody); - parent.append(table); + parent.append(table); - return table; + return table; } /* * Create a table and apply UISDK styles to it */ function createTable(id) { - var table = document.createElement("table"); - table.setAttribute("id", id); - table.setAttribute("class", - "apexTable ebTable elTablelib-Table-table ebTable_striped"); - return table; + var table = document.createElement("table"); + table.setAttribute("id", id); + table.setAttribute("class", "apexTable ebTable elTablelib-Table-table ebTable_striped"); + return table; }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/ApexUtils.js b/client/client-monitoring/src/main/resources/webapp/js/ApexUtils.js index 732fbfd25..b48c8cbd1 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/ApexUtils.js +++ b/client/client-monitoring/src/main/resources/webapp/js/ApexUtils.js @@ -22,311 +22,304 @@ * Crate a dialog with input, attach it to a given parent and show an optional message */ function apexDialogForm_activate(formParent, message) { - apexUtils_removeElement("apexDialogDiv"); + apexUtils_removeElement("apexDialogDiv"); - var contentelement = document.createElement("apexDialogDiv"); - var formDiv = document.createElement("div"); - var backgroundDiv = document.createElement("div"); - backgroundDiv.setAttribute("id", "apexDialogDivBackground"); - backgroundDiv.setAttribute("class", "apexDialogDivBackground"); + var contentelement = document.createElement("apexDialogDiv"); + var formDiv = document.createElement("div"); + var backgroundDiv = document.createElement("div"); + backgroundDiv.setAttribute("id", "apexDialogDivBackground"); + backgroundDiv.setAttribute("class", "apexDialogDivBackground"); - backgroundDiv.appendChild(formDiv); - contentelement.appendChild(backgroundDiv); - formParent.appendChild(contentelement); + backgroundDiv.appendChild(formDiv); + contentelement.appendChild(backgroundDiv); + formParent.appendChild(contentelement); - formDiv.setAttribute("id", "apexDialogDiv"); - formDiv.setAttribute("class", "apexDialogDiv"); + formDiv.setAttribute("id", "apexDialogDiv"); + formDiv.setAttribute("class", "apexDialogDiv"); - var headingSpan = document.createElement("span"); - formDiv.appendChild(headingSpan); + var headingSpan = document.createElement("span"); + formDiv.appendChild(headingSpan); - headingSpan.setAttribute("class", "headingSpan"); - headingSpan.innerHTML = "Apex Engine Configuration"; + headingSpan.setAttribute("class", "headingSpan"); + headingSpan.innerHTML = "Apex Engine Configuration"; - var form = document.createElement("apexDialog"); - formDiv.appendChild(form); + var form = document.createElement("apexDialog"); + formDiv.appendChild(form); - form.setAttribute("id", "apexDialog"); - form.setAttribute("class", "form-style-1"); - form.setAttribute("method", "post"); + form.setAttribute("id", "apexDialog"); + form.setAttribute("class", "form-style-1"); + form.setAttribute("method", "post"); - if (message) { - var messageLI = document.createElement("li"); - messageLI.setAttribute("class", "dialogMessage"); - messageLI.innerHTML = message; - form.appendChild(messageLI); - } + if (message) { + var messageLI = document.createElement("li"); + messageLI.setAttribute("class", "dialogMessage"); + messageLI.innerHTML = message; + form.appendChild(messageLI); + } - var urlLI = document.createElement("li"); - form.appendChild(urlLI); + var urlLI = document.createElement("li"); + form.appendChild(urlLI); - var urlLabel = document.createElement("label"); - urlLI.appendChild(urlLabel); + var urlLabel = document.createElement("label"); + urlLI.appendChild(urlLabel); - urlLabel.setAttribute("for", "apexDialogUrlInput"); - urlLabel.innerHTML = "Apex Engine rest URL:"; + urlLabel.setAttribute("for", "apexDialogUrlInput"); + urlLabel.innerHTML = "Apex Engine rest URL:"; - var urlLabelSpan = document.createElement("span"); - urlLabel.appendChild(urlLabelSpan); + var urlLabelSpan = document.createElement("span"); + urlLabel.appendChild(urlLabelSpan); - urlLabelSpan.setAttribute("class", "required"); - urlLabelSpan.innerHTML = "*"; + urlLabelSpan.setAttribute("class", "required"); + urlLabelSpan.innerHTML = "*"; - var engineUrl = localStorage.getItem("apex-monitor-services_old"); + var engineUrl = localStorage.getItem("apex-monitor-services_old"); - var urlInput = document.createElement("input"); - urlInput.setAttribute("id", "services_url_input"); - urlInput.setAttribute("placeholder", "localhost:12345"); - urlInput.value = (engineUrl && engineUrl !== "null") ? JSON - .parse(engineUrl).hostname - + ":" + JSON.parse(engineUrl).port : ""; - urlLI.appendChild(urlInput); + var urlInput = document.createElement("input"); + urlInput.setAttribute("id", "services_url_input"); + urlInput.setAttribute("placeholder", "localhost:12345"); + urlInput.value = (engineUrl && engineUrl !== "null") ? JSON.parse(engineUrl).hostname + ":" + + JSON.parse(engineUrl).port : ""; + urlLI.appendChild(urlInput); - var inputLI = document.createElement("li"); - form.appendChild(inputLI); + var inputLI = document.createElement("li"); + form.appendChild(inputLI); - var submitInput = document.createElement("input"); - submitInput.setAttribute("id", "submit"); - submitInput.setAttribute("class", "button ebBtn"); - submitInput.setAttribute("type", "submit"); - submitInput.setAttribute("value", "Submit"); - submitInput.onclick = apexDialogForm_submitPressed; - inputLI.appendChild(submitInput); + var submitInput = document.createElement("input"); + submitInput.setAttribute("id", "submit"); + submitInput.setAttribute("class", "button ebBtn"); + submitInput.setAttribute("type", "submit"); + submitInput.setAttribute("value", "Submit"); + submitInput.onclick = apexDialogForm_submitPressed; + inputLI.appendChild(submitInput); - // Enter key press triggers submit - $(urlInput).keyup(function(event) { - if (event.keyCode == 13) { - $(submitInput).click(); - } - }); + // Enter key press triggers submit + $(urlInput).keyup(function(event) { + if (event.keyCode == 13) { + $(submitInput).click(); + } + }); - urlInput.focus(); + urlInput.focus(); } /* * Create a dialog for displaying text */ function apexTextDialog_activate(formParent, message, title) { - apexUtils_removeElement("apexDialogDiv"); - - var contentelement = document.createElement("div"); - contentelement.setAttribute("id", "apexDialogDiv") - var formDiv = document.createElement("div"); - var backgroundDiv = document.createElement("div"); - backgroundDiv.setAttribute("id", "apexDialogDivBackground"); - backgroundDiv.setAttribute("class", "apexDialogDivBackground"); - - backgroundDiv.appendChild(formDiv); - contentelement.appendChild(backgroundDiv); - formParent.appendChild(contentelement); - - formDiv.setAttribute("id", "apexErrorDialogDiv"); - formDiv.setAttribute("class", "apexDialogDiv apexErrorDialogDiv"); - - var headingSpan = document.createElement("span"); - formDiv.appendChild(headingSpan); - - headingSpan.setAttribute("class", "headingSpan"); - headingSpan.innerHTML = title; - - var form = document.createElement("div"); - formDiv.appendChild(form); - - form.setAttribute("id", "apexDialog"); - form.setAttribute("class", "form-style-1"); - form.setAttribute("method", "post"); - - if (message) { - var messageLI = document.createElement("li"); - messageLI.setAttribute("class", "dialogMessage"); - messageLI.innerHTML = message; - form.appendChild(messageLI); - } - - var inputLI = document.createElement("li"); - form.appendChild(inputLI); - - var cancelInput = document.createElement("input"); - cancelInput.setAttribute("class", "button ebBtn"); - cancelInput.setAttribute("type", "submit"); - cancelInput.setAttribute("value", "Close"); - cancelInput.onclick = newModelForm_cancelPressed; - form.appendChild(cancelInput); + apexUtils_removeElement("apexDialogDiv"); + + var contentelement = document.createElement("div"); + contentelement.setAttribute("id", "apexDialogDiv") + var formDiv = document.createElement("div"); + var backgroundDiv = document.createElement("div"); + backgroundDiv.setAttribute("id", "apexDialogDivBackground"); + backgroundDiv.setAttribute("class", "apexDialogDivBackground"); + + backgroundDiv.appendChild(formDiv); + contentelement.appendChild(backgroundDiv); + formParent.appendChild(contentelement); + + formDiv.setAttribute("id", "apexErrorDialogDiv"); + formDiv.setAttribute("class", "apexDialogDiv apexErrorDialogDiv"); + + var headingSpan = document.createElement("span"); + formDiv.appendChild(headingSpan); + + headingSpan.setAttribute("class", "headingSpan"); + headingSpan.innerHTML = title; + + var form = document.createElement("div"); + formDiv.appendChild(form); + + form.setAttribute("id", "apexDialog"); + form.setAttribute("class", "form-style-1"); + form.setAttribute("method", "post"); + + if (message) { + var messageLI = document.createElement("li"); + messageLI.setAttribute("class", "dialogMessage"); + messageLI.innerHTML = message; + form.appendChild(messageLI); + } + + var inputLI = document.createElement("li"); + form.appendChild(inputLI); + + var cancelInput = document.createElement("input"); + cancelInput.setAttribute("class", "button ebBtn"); + cancelInput.setAttribute("type", "submit"); + cancelInput.setAttribute("value", "Close"); + cancelInput.onclick = newModelForm_cancelPressed; + form.appendChild(cancelInput); } /* * Create a Success dialog */ function apexSuccessDialog_activate(formParent, message) { - apexTextDialog_activate(formParent, message, "Success"); + apexTextDialog_activate(formParent, message, "Success"); } /* * Create an Error dialog */ function apexErrorDialog_activate(formParent, message) { - apexTextDialog_activate(formParent, message, "Error"); + apexTextDialog_activate(formParent, message, "Error"); } /* * Dialog cancel callback */ function newModelForm_cancelPressed() { - apexUtils_removeElement("apexDialogDivBackground"); + apexUtils_removeElement("apexDialogDivBackground"); } /* * Dialog submit callback */ function apexDialogForm_submitPressed() { - var url = $('#services_url_input').val(); - if (url && url.length > 0) { - var engineConfig = { - hostname : url.split(":")[0], - port : url.split(":")[1] - }; - localStorage.setItem("apex-monitor-services_old", JSON - .stringify(engineConfig)); - localStorage.setItem("apex-monitor-services", JSON - .stringify(engineConfig)); - apexUtils_removeElement("apexDialogDivBackground"); - getEngineURL(); - } + var url = $('#services_url_input').val(); + if (url && url.length > 0) { + var engineConfig = { + hostname : url.split(":")[0], + port : url.split(":")[1] + }; + localStorage.setItem("apex-monitor-services_old", JSON.stringify(engineConfig)); + localStorage.setItem("apex-monitor-services", JSON.stringify(engineConfig)); + apexUtils_removeElement("apexDialogDivBackground"); + getEngineURL(); + } } /* * Remove an element from the page */ function apexUtils_removeElement(elementname) { - var element = document.getElementById(elementname); - if (element != null) { - element.parentNode.removeChild(element); - } + var element = document.getElementById(elementname); + if (element != null) { + element.parentNode.removeChild(element); + } } /* * Compare two objects */ function deepCompare() { - var i, l, leftChain, rightChain; - - function compare2Objects(x, y) { - var p; - - // remember that NaN === NaN returns false - // and isNaN(undefined) returns true - if (isNaN(x) && isNaN(y) && typeof x === 'number' - && typeof y === 'number') { - return true; - } - - // Compare primitives and functions. - // Check if both arguments link to the same object. - // Especially useful on the step where we compare prototypes - if (x === y) { - return true; - } - - // Works in case when functions are created in constructor. - // Comparing dates is a common scenario. Another built-ins? - // We can even handle functions passed across iframes - if ((typeof x === 'function' && typeof y === 'function') - || (x instanceof Date && y instanceof Date) - || (x instanceof RegExp && y instanceof RegExp) - || (x instanceof String && y instanceof String) - || (x instanceof Number && y instanceof Number)) { - return x.toString() === y.toString(); - } - - // At last checking prototypes as good as we can - if (!(x instanceof Object && y instanceof Object)) { - return false; - } - - if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) { - return false; - } - - if (x.constructor !== y.constructor) { - return false; - } - - if (x.prototype !== y.prototype) { - return false; - } - - // Check for infinitive linking loops - if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) { - return false; - } - - // Quick checking of one object being a subset of another. - // todo: cache the structure of arguments[0] for performance - for (p in y) { - if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) { - return false; - } else if (typeof y[p] !== typeof x[p]) { - return false; - } - } - - for (p in x) { - if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) { - return false; - } else if (typeof y[p] !== typeof x[p]) { - return false; - } - - switch (typeof (x[p])) { - case 'object': - case 'function': - - leftChain.push(x); - rightChain.push(y); - - if (!compare2Objects(x[p], y[p])) { - return false; - } - - leftChain.pop(); - rightChain.pop(); - break; - - default: - if (x[p] !== y[p]) { - return false; - } - break; - } - } - - return true; - } - - if (arguments.length < 1) { - return true; - } - - for (i = 1, l = arguments.length; i < l; i++) { - - leftChain = []; // Todo: this can be cached - rightChain = []; - - if (!compare2Objects(arguments[0], arguments[i])) { - return false; - } - } - - return true; + var i, l, leftChain, rightChain; + + function compare2Objects(x, y) { + var p; + + // remember that NaN === NaN returns false + // and isNaN(undefined) returns true + if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') { + return true; + } + + // Compare primitives and functions. + // Check if both arguments link to the same object. + // Especially useful on the step where we compare prototypes + if (x === y) { + return true; + } + + // Works in case when functions are created in constructor. + // Comparing dates is a common scenario. Another built-ins? + // We can even handle functions passed across iframes + if ((typeof x === 'function' && typeof y === 'function') || (x instanceof Date && y instanceof Date) + || (x instanceof RegExp && y instanceof RegExp) || (x instanceof String && y instanceof String) + || (x instanceof Number && y instanceof Number)) { + return x.toString() === y.toString(); + } + + // At last checking prototypes as good as we can + if (!(x instanceof Object && y instanceof Object)) { + return false; + } + + if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) { + return false; + } + + if (x.constructor !== y.constructor) { + return false; + } + + if (x.prototype !== y.prototype) { + return false; + } + + // Check for infinitive linking loops + if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) { + return false; + } + + // Quick checking of one object being a subset of another. + // todo: cache the structure of arguments[0] for performance + for (p in y) { + if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) { + return false; + } else if (typeof y[p] !== typeof x[p]) { + return false; + } + } + + for (p in x) { + if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) { + return false; + } else if (typeof y[p] !== typeof x[p]) { + return false; + } + + switch (typeof (x[p])) { + case 'object': + case 'function': + + leftChain.push(x); + rightChain.push(y); + + if (!compare2Objects(x[p], y[p])) { + return false; + } + + leftChain.pop(); + rightChain.pop(); + break; + + default: + if (x[p] !== y[p]) { + return false; + } + break; + } + } + + return true; + } + + if (arguments.length < 1) { + return true; + } + + for (i = 1, l = arguments.length; i < l; i++) { + + leftChain = []; // Todo: this can be cached + rightChain = []; + + if (!compare2Objects(arguments[0], arguments[i])) { + return false; + } + } + + return true; } function getHomepageURL() { - var homepageURL = location.protocol - + "//" - + window.location.hostname - + (location.port ? ':' + location.port : '') - + (location.pathname.endsWith("/monitoring/") ? location.pathname - .substring(0, location.pathname.indexOf("monitoring/")) - : location.pathname); - location.href = homepageURL; + var homepageURL = location.protocol + + "//" + + window.location.hostname + + (location.port ? ':' + location.port : '') + + (location.pathname.endsWith("/monitoring/") ? location.pathname.substring(0, location.pathname + .indexOf("monitoring/")) : location.pathname); + location.href = homepageURL; }
\ No newline at end of file diff --git a/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js b/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js index 717794363..5a731c91f 100644 --- a/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js +++ b/client/client-monitoring/src/main/resources/webapp/js/avsc/avsc.js @@ -671,9 +671,9 @@ module.exports = { Z_TREES: 6, /* - * Return codes for the compression/decompression functions. Negative values - * are errors, positive values are used for special but normal events. - */ + * Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ Z_OK: 0, Z_STREAM_END: 1, Z_NEED_DICT: 2, @@ -852,14 +852,14 @@ var BUSY_STATE = 113; var FINISH_STATE = 666; var BS_NEED_MORE = 1; /* - * block not completed, need more input or more - * output - */ + * block not completed, need more input or more + * output + */ var BS_BLOCK_DONE = 2; /* block flush performed */ var BS_FINISH_STARTED = 3; /* - * finish started, need only more output at next - * deflate - */ + * finish started, need only more output at next + * deflate + */ var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. @@ -987,18 +987,18 @@ function longest_match(s, cur_match) { var prev = s.prev; /* - * Stop when cur_match becomes <= limit. To simplify the code, we prevent - * matches with the string of window index 0. - */ + * Stop when cur_match becomes <= limit. To simplify the code, we prevent + * matches with the string of window index 0. + */ var strend = s.strstart + MAX_MATCH; var scan_end1 = _win[scan + best_len - 1]; var scan_end = _win[scan + best_len]; /* - * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ + * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); /* Do not waste too much time if we already have a good match: */ @@ -1006,9 +1006,9 @@ function longest_match(s, cur_match) { chain_length >>= 2; } /* - * Do not look for matches beyond the end of the input. This is necessary to - * make deflate deterministic. - */ + * Do not look for matches beyond the end of the input. This is necessary to + * make deflate deterministic. + */ if (nice_match > s.lookahead) { nice_match = s.lookahead; } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need @@ -1019,14 +1019,14 @@ function longest_match(s, cur_match) { match = cur_match; /* - * Skip to next match if the match length cannot increase or if the match - * length is less than 2. Note that the checks below for insufficient - * lookahead only occur occasionally for performance reasons. Therefore - * uninitialized memory will be accessed, and conditional jumps will be made - * that depend on those values. However the length of the match is limited - * to the lookahead, so the output of deflate is not affected by the - * uninitialized values. - */ + * Skip to next match if the match length cannot increase or if the match + * length is less than 2. Note that the checks below for insufficient + * lookahead only occur occasionally for performance reasons. Therefore + * uninitialized memory will be accessed, and conditional jumps will be made + * that depend on those values. However the length of the match is limited + * to the lookahead, so the output of deflate is not affected by the + * uninitialized values. + */ if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || @@ -1036,19 +1036,19 @@ function longest_match(s, cur_match) { } /* - * The check at best_len-1 can be removed because it will be made again - * later. (This heuristic is not always a win.) It is not necessary to - * compare scan[2] and match[2] since they are always equal when the other - * bytes match, given that the hash keys are equal and that HASH_BITS >= 8. - */ + * The check at best_len-1 can be removed because it will be made again + * later. (This heuristic is not always a win.) It is not necessary to + * compare scan[2] and match[2] since they are always equal when the other + * bytes match, given that the hash keys are equal and that HASH_BITS >= 8. + */ scan += 2; match++; // Assert(*scan == *match, "match[2]?"); /* - * We check for insufficient lookahead only every 8th comparison; the 256th - * check will be made at strstart+258. - */ + * We check for insufficient lookahead only every 8th comparison; the 256th + * check will be made at strstart+258. + */ do { /* jshint noempty:false */ } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && @@ -1115,9 +1115,9 @@ function fill_window(s) { /* - * If the window is almost full and there is insufficient lookahead, move - * the upper half to the lower one to make room in the upper half. - */ + * If the window is almost full and there is insufficient lookahead, move + * the upper half to the lower one to make room in the upper half. + */ if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { utils.arraySet(s.window, s.window, _w_size, _w_size, 0); @@ -1127,12 +1127,12 @@ function fill_window(s) { s.block_start -= _w_size; /* - * Slide the hash table (could be avoided with 32 bit values at the - * expense of memory usage). We slide even when level == 0 to keep the - * hash table consistent if we switch back to level > 0 later. (Using - * level 0 permanently is not an optimal usage of zlib, so we don't care - * about this pathological case.) - */ + * Slide the hash table (could be avoided with 32 bit values at the + * expense of memory usage). We slide even when level == 0 to keep the + * hash table consistent if we switch back to level > 0 later. (Using + * level 0 permanently is not an optimal usage of zlib, so we don't care + * about this pathological case.) + */ n = s.hash_size; p = n; @@ -1147,9 +1147,9 @@ function fill_window(s) { m = s.prev[--p]; s.prev[p] = (m >= _w_size ? m - _w_size : 0); /* - * If n is not on any hash chain, prev[n] is garbage but its value will - * never be used. - */ + * If n is not on any hash chain, prev[n] is garbage but its value will + * never be used. + */ } while (--n); more += _w_size; @@ -1159,15 +1159,15 @@ function fill_window(s) { } /* - * If there was no sliding: strstart <= WSIZE+MAX_DIST-1 && lookahead <= - * MIN_LOOKAHEAD - 1 && more == window_size - lookahead - strstart => more >= - * window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) => more >= - * window_size - 2*WSIZE + 2 In the BIG_MEM or MMAP case (not yet - * supported), window_size == input_size + MIN_LOOKAHEAD && strstart + - * s->lookahead <= input_size => more >= MIN_LOOKAHEAD. Otherwise, - * window_size == 2*WSIZE so more >= 2. If there was sliding, more >= WSIZE. - * So in all cases, more >= 2. - */ + * If there was no sliding: strstart <= WSIZE+MAX_DIST-1 && lookahead <= + * MIN_LOOKAHEAD - 1 && more == window_size - lookahead - strstart => more >= + * window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) => more >= + * window_size - 2*WSIZE + 2 In the BIG_MEM or MMAP case (not yet + * supported), window_size == input_size + MIN_LOOKAHEAD && strstart + + * s->lookahead <= input_size => more >= MIN_LOOKAHEAD. Otherwise, + * window_size == 2*WSIZE so more >= 2. If there was sliding, more >= WSIZE. + * So in all cases, more >= 2. + */ // Assert(more >= 2, "more < 2"); n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); s.lookahead += n; @@ -1196,20 +1196,20 @@ function fill_window(s) { } } /* - * If the whole input has less than MIN_MATCH bytes, ins_h is garbage, but - * this is not important since only literal bytes will be emitted. - */ + * If the whole input has less than MIN_MATCH bytes, ins_h is garbage, but + * this is not important since only literal bytes will be emitted. + */ } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); /* - * If the WIN_INIT bytes after the end of the current data have never been - * written, then zero those bytes in order to avoid memory check reports of - * the use of uninitialized (or uninitialised as Julian writes) bytes by the - * longest match routines. Update the high water mark for the next time - * through here. WIN_INIT is set to MAX_MATCH since the longest match - * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. - */ + * If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by the + * longest match routines. Update the high water mark for the next time + * through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ // if (s.high_water < s.window_size) { // var curr = s.strstart + s.lookahead; // var init = 0; @@ -1251,9 +1251,9 @@ function fill_window(s) { */ function deflate_stored(s, flush) { /* - * Stored blocks are limited to 0xffff bytes, pending_buf is limited to - * pending_buf_size, and each stored block has a 5 byte header: - */ + * Stored blocks are limited to 0xffff bytes, pending_buf is limited to + * pending_buf_size, and each stored block has a 5 byte header: + */ var max_block_size = 0xffff; if (max_block_size > s.pending_buf_size - 5) { @@ -1305,9 +1305,9 @@ function deflate_stored(s, flush) { } /* - * Flush if we may have to slide, otherwise block_start may become negative - * and the data will be gone: - */ + * Flush if we may have to slide, otherwise block_start may become negative + * and the data will be gone: + */ if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { /** * FLUSH_BLOCK(s, 0); ** */ flush_block_only(s, false); @@ -1355,10 +1355,10 @@ function deflate_fast(s, flush) { for (;;) { /* - * Make sure that we always have enough lookahead, except at the end of the - * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH - * bytes to insert the string following the next match. - */ + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH + * bytes to insert the string following the next match. + */ if (s.lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { @@ -1370,9 +1370,9 @@ function deflate_fast(s, flush) { } /* - * Insert the string window[strstart .. strstart+2] in the dictionary, and - * set hash_head to the head of the hash chain: - */ + * Insert the string window[strstart .. strstart+2] in the dictionary, and + * set hash_head to the head of the hash chain: + */ hash_head = 0/* NIL */; if (s.lookahead >= MIN_MATCH) { /** * INSERT_STRING(s, s.strstart, hash_head); ** */ @@ -1383,15 +1383,15 @@ function deflate_fast(s, flush) { } /* - * Find the longest match, discarding those <= prev_length. At this point we - * have always match_length < MIN_MATCH - */ + * Find the longest match, discarding those <= prev_length. At this point we + * have always match_length < MIN_MATCH + */ if (hash_head !== 0/* NIL */ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { /* - * To simplify the code, we prevent matches with the string of window - * index 0 (in particular we have to avoid a match of the string with - * itself at the start of the input file). - */ + * To simplify the code, we prevent matches with the string of window + * index 0 (in particular we have to avoid a match of the string with + * itself at the start of the input file). + */ s.match_length = longest_match(s, hash_head); /* longest_match() sets match_start */ } @@ -1400,17 +1400,17 @@ function deflate_fast(s, flush) { // debug only /*********************************************************************** - * * _tr_tally_dist(s, s.strstart - s.match_start, s.match_length - - * MIN_MATCH, bflush); - **********************************************************************/ + * * _tr_tally_dist(s, s.strstart - s.match_start, s.match_length - + * MIN_MATCH, bflush); + **********************************************************************/ bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); s.lookahead -= s.match_length; /* - * Insert new strings in the hash table only if the match length is not - * too large. This saves time but degrades compression. - */ + * Insert new strings in the hash table only if the match length is not + * too large. This saves time but degrades compression. + */ if (s.match_length <= s.max_lazy_match/* max_insert_length */ && s.lookahead >= MIN_MATCH) { s.match_length--; /* string at strstart already in table */ do { @@ -1421,9 +1421,9 @@ function deflate_fast(s, flush) { s.head[s.ins_h] = s.strstart; /***/ /* - * strstart never exceeds WSIZE-MAX_MATCH, so there are always - * MIN_MATCH bytes ahead. - */ + * strstart never exceeds WSIZE-MAX_MATCH, so there are always + * MIN_MATCH bytes ahead. + */ } while (--s.match_length !== 0); s.strstart++; } else @@ -1438,9 +1438,9 @@ function deflate_fast(s, flush) { // Call UPDATE_HASH() MIN_MATCH-3 more times // #endif /* - * If lookahead < MIN_MATCH, ins_h is garbage, but it does not matter - * since it will be recomputed at next deflate call. - */ + * If lookahead < MIN_MATCH, ins_h is garbage, but it does not matter + * since it will be recomputed at next deflate call. + */ } } else { /* No match, output a literal byte */ @@ -1496,10 +1496,10 @@ function deflate_slow(s, flush) { /* Process the input block. */ for (;;) { /* - * Make sure that we always have enough lookahead, except at the end of the - * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH - * bytes to insert the string following the next match. - */ + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the next match, plus MIN_MATCH + * bytes to insert the string following the next match. + */ if (s.lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { @@ -1509,9 +1509,9 @@ function deflate_slow(s, flush) { } /* - * Insert the string window[strstart .. strstart+2] in the dictionary, and - * set hash_head to the head of the hash chain: - */ + * Insert the string window[strstart .. strstart+2] in the dictionary, and + * set hash_head to the head of the hash chain: + */ hash_head = 0/* NIL */; if (s.lookahead >= MIN_MATCH) { /** * INSERT_STRING(s, s.strstart, hash_head); ** */ @@ -1522,8 +1522,8 @@ function deflate_slow(s, flush) { } /* - * Find the longest match, discarding those <= prev_length. - */ + * Find the longest match, discarding those <= prev_length. + */ s.prev_length = s.match_length; s.prev_match = s.match_start; s.match_length = MIN_MATCH - 1; @@ -1531,10 +1531,10 @@ function deflate_slow(s, flush) { if (hash_head !== 0/* NIL */ && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/* MAX_DIST(s) */) { /* - * To simplify the code, we prevent matches with the string of window - * index 0 (in particular we have to avoid a match of the string with - * itself at the start of the input file). - */ + * To simplify the code, we prevent matches with the string of window + * index 0 (in particular we have to avoid a match of the string with + * itself at the start of the input file). + */ s.match_length = longest_match(s, hash_head); /* longest_match() sets match_start */ @@ -1542,16 +1542,16 @@ function deflate_slow(s, flush) { (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/* TOO_FAR */))) { /* - * If prev_match is also MIN_MATCH, match_start is garbage but we will - * ignore the current match anyway. - */ + * If prev_match is also MIN_MATCH, match_start is garbage but we will + * ignore the current match anyway. + */ s.match_length = MIN_MATCH - 1; } } /* - * If there was a match at the previous step and the current match is not - * better, output the previous match: - */ + * If there was a match at the previous step and the current match is not + * better, output the previous match: + */ if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { max_insert = s.strstart + s.lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ @@ -1559,15 +1559,15 @@ function deflate_slow(s, flush) { // check_match(s, s.strstart-1, s.prev_match, s.prev_length); /*********************************************************************** - * *_tr_tally_dist(s, s.strstart - 1 - s.prev_match, s.prev_length - - * MIN_MATCH, bflush); - **********************************************************************/ + * *_tr_tally_dist(s, s.strstart - 1 - s.prev_match, s.prev_length - + * MIN_MATCH, bflush); + **********************************************************************/ bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); /* - * Insert in hash table all strings up to the end of the match. - * strstart-1 and strstart are already inserted. If there is not enough - * lookahead, the last two strings are not inserted in the hash table. - */ + * Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not enough + * lookahead, the last two strings are not inserted in the hash table. + */ s.lookahead -= s.prev_length - 1; s.prev_length -= 2; do { @@ -1594,10 +1594,10 @@ function deflate_slow(s, flush) { } else if (s.match_available) { /* - * If there was no match at the previous position, output a single - * literal. If there was a match but the current match is longer, - * truncate the previous match to a single literal. - */ + * If there was no match at the previous position, output a single + * literal. If there was a match but the current match is longer, + * truncate the previous match to a single literal. + */ // Tracevv((stderr,"%c", s->window[s->strstart-1])); /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */ bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); @@ -1614,9 +1614,9 @@ function deflate_slow(s, flush) { } } else { /* - * There is no previous match to compare with, wait for the next step to - * decide. - */ + * There is no previous match to compare with, wait for the next step to + * decide. + */ s.match_available = 1; s.strstart++; s.lookahead--; @@ -1668,10 +1668,10 @@ function deflate_rle(s, flush) { for (;;) { /* - * Make sure that we always have enough lookahead, except at the end of the - * input file. We need MAX_MATCH bytes for the longest run, plus one for the - * unrolled loop. - */ + * Make sure that we always have enough lookahead, except at the end of the + * input file. We need MAX_MATCH bytes for the longest run, plus one for the + * unrolled loop. + */ if (s.lookahead <= MAX_MATCH) { fill_window(s); if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { @@ -1828,9 +1828,9 @@ configuration_table = [ /* good lazy nice chain */ new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ new Config(4, 4, 8, 4, deflate_fast), /* - * 1 max speed, no lazy - * matches - */ + * 1 max speed, no lazy + * matches + */ new Config(4, 5, 16, 8, deflate_fast), /* 2 */ new Config(4, 6, 32, 32, deflate_fast), /* 3 */ @@ -1854,8 +1854,8 @@ function lm_init(s) { zero(s.head); // Fill with NIL (= 0); /* - * Set the default configuration parameters: - */ + * Set the default configuration parameters: + */ s.max_lazy_match = configuration_table[s.level].max_lazy; s.good_match = configuration_table[s.level].good_length; s.nice_match = configuration_table[s.level].nice_length; @@ -1890,25 +1890,25 @@ function DeflateState() { this.window = null; /* - * Sliding window. Input bytes are read into the second half of the window, - * and move to the first half later to keep a dictionary of at least wSize - * bytes. With this organization, matches are limited to a distance of - * wSize-MAX_MATCH bytes, but this ensures that IO is always performed with - * a length multiple of the block size. - */ + * Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always performed with + * a length multiple of the block size. + */ this.window_size = 0; /* - * Actual size of window: 2*wSize, except when the user input buffer is - * directly used as sliding window. - */ + * Actual size of window: 2*wSize, except when the user input buffer is + * directly used as sliding window. + */ this.prev = null; /* - * Link to older string with same hash index. To limit the size of this - * array to 64K, this link is maintained only for the last 32K strings. An - * index in this array is thus a window index modulo 32K. - */ + * Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. An + * index in this array is thus a window index modulo 32K. + */ this.head = null; /* Heads of the hash chains or NIL. */ @@ -1919,16 +1919,16 @@ function DeflateState() { this.hash_shift = 0; /* - * Number of bits by which ins_h must be shifted at each input step. It must - * be such that after MIN_MATCH steps, the oldest byte no longer takes part - * in the hash key, that is: hash_shift * MIN_MATCH >= hash_bits - */ + * Number of bits by which ins_h must be shifted at each input step. It must + * be such that after MIN_MATCH steps, the oldest byte no longer takes part + * in the hash key, that is: hash_shift * MIN_MATCH >= hash_bits + */ this.block_start = 0; /* - * Window position at the beginning of the current output block. Gets - * negative when the window is moved backwards. - */ + * Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ this.match_length = 0; /* length of best match */ this.prev_match = 0; /* previous match */ @@ -1939,29 +1939,29 @@ function DeflateState() { this.prev_length = 0; /* - * Length of the best match at previous step. Matches not greater than this - * are discarded. This is used in the lazy match evaluation. - */ + * Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ this.max_chain_length = 0; /* - * To speed up deflation, hash chains are never searched beyond this length. - * A higher limit improves compression ratio but degrades the speed. - */ + * To speed up deflation, hash chains are never searched beyond this length. + * A higher limit improves compression ratio but degrades the speed. + */ this.max_lazy_match = 0; /* - * Attempt to find a better match only when the current match is strictly - * smaller than this value. This mechanism is used only for compression - * levels >= 4. - */ + * Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ // That's alias to max_lazy_match, don't use directly // this.max_insert_length = 0; /* - * Insert new strings in the hash table only if the match length is not - * greater than this length. This saves time but degrades compression. - * max_insert_length is used only for compression levels <= 3. - */ + * Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ this.level = 0; /* compression level (1..9) */ this.strategy = 0; /* favor or force Huffman coding */ @@ -1999,52 +1999,52 @@ function DeflateState() { // int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ this.heap = new utils.Buf16(2 * L_CODES + 1); /* - * heap used to build the - * Huffman trees - */ + * heap used to build the + * Huffman trees + */ zero(this.heap); this.heap_len = 0; /* number of elements in the heap */ this.heap_max = 0; /* element of largest frequency */ /* - * The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. - * The same heap array is used to build all trees. - */ + * The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ this.depth = new utils.Buf16(2 * L_CODES + 1); // uch depth[2*L_CODES+1]; zero(this.depth); /* - * Depth of each subtree used as tie breaker for trees of equal frequency - */ + * Depth of each subtree used as tie breaker for trees of equal frequency + */ this.l_buf = 0; /* buffer index for literals or lengths */ this.lit_bufsize = 0; /* - * Size of match buffer for literals/lengths. There are 4 reasons for - * limiting lit_bufsize to 64K: - frequencies can be kept in 16 bit counters - - * if compression is not successful for the first block, all input data is - * still in the window so we can still emit a stored block even when input - * comes from standard input. (This can also be done for all blocks if - * lit_bufsize is not greater than 32K.) - if compression is not successful - * for a file smaller than 64K, we can even emit a stored file instead of a - * stored block (saving 5 bytes). This is applicable only for zip (not gzip - * or zlib). - creating new Huffman trees less frequently may not provide - * fast adaptation to changes in the input data statistics. (Take for - * example a binary file with poorly compressible code followed by a highly - * compressible string table.) Smaller buffer sizes give fast adaptation but - * have of course the overhead of transmitting trees more frequently. - I - * can't count above 4 - */ + * Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: - frequencies can be kept in 16 bit counters - + * if compression is not successful for the first block, all input data is + * still in the window so we can still emit a stored block even when input + * comes from standard input. (This can also be done for all blocks if + * lit_bufsize is not greater than 32K.) - if compression is not successful + * for a file smaller than 64K, we can even emit a stored file instead of a + * stored block (saving 5 bytes). This is applicable only for zip (not gzip + * or zlib). - creating new Huffman trees less frequently may not provide + * fast adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by a highly + * compressible string table.) Smaller buffer sizes give fast adaptation but + * have of course the overhead of transmitting trees more frequently. - I + * can't count above 4 + */ this.last_lit = 0; /* running index in l_buf */ this.d_buf = 0; /* - * Buffer index for distances. To simplify the code, d_buf and l_buf have - * the same number of elements. To use different lengths, an extra flag - * array would be necessary. - */ + * Buffer index for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ this.opt_len = 0; /* bit length of current block with optimal trees */ this.static_len = 0; /* bit length of current block with static trees */ @@ -2054,24 +2054,24 @@ function DeflateState() { this.bi_buf = 0; /* - * Output buffer. bits are inserted starting at the bottom (least - * significant bits). - */ + * Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ this.bi_valid = 0; /* - * Number of valid bits in bi_buf. All bits above the last valid bit are - * always zero. - */ + * Number of valid bits in bi_buf. All bits above the last valid bit are + * always zero. + */ // Used for window memory init. We safely ignore it for JS. That makes // sense only for pointers and memory check tools. // this.high_water = 0; /* - * High water mark offset in window for initialized bytes -- bytes above - * this are set to zero in order to avoid memory check warnings when longest - * match routines access bytes past the input. This is then updated to the - * new high water mark. - */ + * High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when longest + * match routines access bytes past the input. This is then updated to the + * new high water mark. + */ } @@ -2430,20 +2430,20 @@ function deflate(strm, flush) { flush_pending(strm); if (strm.avail_out === 0) { /* - * Since avail_out is 0, deflate will be called again with more output - * space, but possibly with both pending and avail_in equal to zero. - * There won't be anything to do, but this is not an error situation so - * make sure we return OK instead of BUF_ERROR at next call of deflate: - */ + * Since avail_out is 0, deflate will be called again with more output + * space, but possibly with both pending and avail_in equal to zero. + * There won't be anything to do, but this is not an error situation so + * make sure we return OK instead of BUF_ERROR at next call of deflate: + */ s.last_flush = -1; return Z_OK; } /* - * Make sure there is something to do and avoid duplicate consecutive - * flushes. For repeated and useless calls with Z_FINISH, we keep returning - * Z_STREAM_END instead of Z_BUF_ERROR. - */ + * Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep returning + * Z_STREAM_END instead of Z_BUF_ERROR. + */ } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) { return err(strm, Z_BUF_ERROR); @@ -2455,8 +2455,8 @@ function deflate(strm, flush) { } /* - * Start a new block or continue the current one. - */ + * Start a new block or continue the current one. + */ if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : @@ -2473,12 +2473,12 @@ function deflate(strm, flush) { } return Z_OK; /* - * If flush != Z_NO_FLUSH && avail_out == 0, the next call of deflate - * should use the same flush parameter to make sure that the flush is - * complete. So we don't have to output an empty block here, this will - * be done at next call. This also ensures that for a very small output - * buffer, we emit at most one empty block. - */ + * If flush != Z_NO_FLUSH && avail_out == 0, the next call of deflate + * should use the same flush parameter to make sure that the flush is + * complete. So we don't have to output an empty block here, this will + * be done at next call. This also ensures that for a very small output + * buffer, we emit at most one empty block. + */ } if (bstate === BS_BLOCK_DONE) { if (flush === Z_PARTIAL_FLUSH) { @@ -2488,9 +2488,9 @@ function deflate(strm, flush) { trees._tr_stored_block(s, 0, 0, false); /* - * For a full flush, this empty block will be recognized as a special - * marker by inflate_sync(). - */ + * For a full flush, this empty block will be recognized as a special + * marker by inflate_sync(). + */ if (flush === Z_FULL_FLUSH) { /** * CLEAR_HASH(s); ** */ /* forget history */ zero(s.head); // Fill with NIL (= 0); @@ -2534,9 +2534,9 @@ function deflate(strm, flush) { flush_pending(strm); /* - * If avail_out is zero, the application will call deflate again to flush - * the rest. - */ + * If avail_out is zero, the application will call deflate again to flush + * the rest. + */ if (s.wrap > 0) { s.wrap = -s.wrap; } /* write the trailer only once! */ return s.pending !== 0 ? Z_OK : Z_STREAM_END; @@ -2699,15 +2699,14 @@ var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ * reached end of block code, inflate() to interpret next block BAD -- error in * block data * - * Notes: - * - The maximum input bits used by a length/distance pair is 15 bits for the - * length code, 5 bits for the length extra, 15 bits for the distance code, and - * 13 bits for the distance extra. This totals 48 bits, or six bytes. Therefore - * if strm.avail_in >= 6, then there is enough input to avoid checking for - * available input while decoding. - * - The maximum bytes that a single length/distance pair can output is 258 - * bytes, which is the maximum length that can be coded. inflate_fast() requires - * strm.avail_out >= 258 for each loop to avoid checking for output space. + * Notes: - The maximum input bits used by a length/distance pair is 15 bits for + * the length code, 5 bits for the length extra, 15 bits for the distance code, + * and 13 bits for the distance extra. This totals 48 bits, or six bytes. + * Therefore if strm.avail_in >= 6, then there is enough input to avoid checking + * for available input while decoding. - The maximum bytes that a single + * length/distance pair can output is 258 bytes, which is the maximum length + * that can be coded. inflate_fast() requires strm.avail_out >= 258 for each + * loop to avoid checking for output space. */ module.exports = function inflate_fast(strm, start) { var state; @@ -2768,9 +2767,9 @@ module.exports = function inflate_fast(strm, start) { /* - * decode literals and length/distances until end-of-block or not enough - * input data or output space - */ + * decode literals and length/distances until end-of-block or not enough + * input data or output space + */ top: do { @@ -3052,9 +3051,9 @@ var HEAD = 1; /* i: waiting for magic header */ var FLAGS = 2; /* i: waiting for method and flags (gzip) */ var TIME = 3; /* i: waiting for modification time (gzip) */ var OS = 4; /* - * i: waiting for extra flags and operating system - * (gzip) - */ + * i: waiting for extra flags and operating system + * (gzip) + */ var EXLEN = 5; /* i: waiting for extra length (gzip) */ var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ var NAME = 7; /* i: waiting for end of file name (gzip) */ @@ -3064,24 +3063,24 @@ var DICTID = 10; /* i: waiting for dictionary check value */ var DICT = 11; /* waiting for inflateSetDictionary() call */ var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ var TYPEDO = 13; /* - * i: same, but skip check to exit inflate on new - * block - */ + * i: same, but skip check to exit inflate on new + * block + */ var STORED = 14; /* - * i: waiting for stored size (length and - * complement) - */ + * i: waiting for stored size (length and + * complement) + */ var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ var COPY = 16; /* - * i/o: waiting for input or output to copy stored - * block - */ + * i/o: waiting for input or output to copy stored + * block + */ var TABLE = 17; /* i: waiting for dynamic block table lengths */ var LENLENS = 18; /* i: waiting for code length code lengths */ var CODELENS = 19; /* - * i: waiting for length/lit and distance code - * lengths - */ + * i: waiting for length/lit and distance code + * lengths + */ var LEN_ = 20; /* i: same as LEN below, but only first time in */ var LEN = 21; /* i: waiting for length/lit/eob code */ var LENEXT = 22; /* i: waiting for length extra bits */ @@ -3094,13 +3093,13 @@ var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ var DONE = 29; /* finished check, done -- remain here until reset */ var BAD = 30; /* got a data error -- remain here until reset */ var MEM = 31; /* - * got an inflate() memory error -- remain here until - * reset - */ + * got an inflate() memory error -- remain here until + * reset + */ var SYNC = 32; /* - * looking for synchronization bytes to restart - * inflate() - */ + * looking for synchronization bytes to restart + * inflate() + */ /* =========================================================================== */ @@ -3170,18 +3169,18 @@ function InflateState() { this.work = new utils.Buf16(288); /* work area for code table building */ /* - * because we don't have pointers in js, we use lencode and distcode - * directly as buffers so we don't need codes - */ + * because we don't have pointers in js, we use lencode and distcode + * directly as buffers so we don't need codes + */ // this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ this.lendyn = null; /* - * dynamic table for length/literal codes - * (JS specific) - */ + * dynamic table for length/literal codes + * (JS specific) + */ this.distdyn = null; /* - * dynamic table for distance codes (JS - * specific) - */ + * dynamic table for distance codes (JS + * specific) + */ this.sane = 0; /* if false, allow invalid distance too far */ this.back = 0; /* bits back of last unprocessed length/lit */ this.was = 0; /* initial length of match */ @@ -3647,9 +3646,9 @@ function inflate(strm, flush) { // - no need for additional size check copy, /* - * len + copy > state.head.extra_max - len ? - * state.head.extra_max : copy, - */ + * len + copy > state.head.extra_max - len ? + * state.head.extra_max : copy, + */ len ); // zmemcpy(state.head.extra + len, next, @@ -4075,10 +4074,10 @@ function inflate(strm, flush) { } /* - * build code tables -- note: do not change the lenbits or distbits - * values here (9 and 6) without reading the comments in inftrees.h - * concerning the ENOUGH constants, which depend on those values - */ + * build code tables -- note: do not change the lenbits or distbits + * values here (9 and 6) without reading the comments in inftrees.h + * concerning the ENOUGH constants, which depend on those values + */ state.lenbits = 9; opts = { bits: state.lenbits }; @@ -4168,9 +4167,9 @@ function inflate(strm, flush) { for (;;) { here = state.lencode[last_val + ((hold & ((1 << (last_bits + last_op)) - 1))/* - * BITS(last.bits + - * last.op) - */ >> last_bits)]; + * BITS(last.bits + + * last.op) + */ >> last_bits)]; here_bits = here >>> 24; here_op = (here >>> 16) & 0xff; here_val = here & 0xffff; @@ -4260,9 +4259,9 @@ function inflate(strm, flush) { for (;;) { here = state.distcode[last_val + ((hold & ((1 << (last_bits + last_op)) - 1))/* - * BITS(last.bits + - * last.op) - */ >> last_bits)]; + * BITS(last.bits + + * last.op) + */ >> last_bits)]; here_bits = here >>> 24; here_op = (here >>> 16) & 0xff; here_val = here & 0xffff; @@ -4456,11 +4455,11 @@ function inflate(strm, flush) { // inf_leave" /* - * Return from inflate(), updating the total counts and the check value. If - * there was no progress during the inflate() call, return a buffer error. - * Call updatewindow() to create and/or update the window state. Note: a - * memory error from inflate() is non-recoverable. - */ + * Return from inflate(), updating the total counts and the check value. If + * there was no progress during the inflate() call, return a buffer error. + * Call updatewindow() to create and/or update the window state. Note: a + * memory error from inflate() is non-recoverable. + */ // --- RESTORE() --- strm.next_out = put; @@ -4485,9 +4484,9 @@ function inflate(strm, flush) { state.total += _out; if (state.wrap && _out) { strm.adler = state.check = /* - * UPDATE(state.check, strm.next_out - _out, - * _out); - */ + * UPDATE(state.check, strm.next_out - _out, + * _out); + */ (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out)); } strm.data_type = state.bits + (state.last ? 64 : 0) + @@ -4552,9 +4551,9 @@ function inflateSetDictionary(strm, dictionary) { } } /* - * copy dictionary to window using updatewindow(), which will amend the - * existing dictionary if appropriate - */ + * copy dictionary to window using updatewindow(), which will amend the + * existing dictionary if appropriate + */ ret = updatewindow(strm, dictionary, dictLength, dictLength); if (ret) { state.mode = MEM; @@ -4654,32 +4653,32 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta var here_bits, here_op, here_val; /* - * Process a set of code lengths to create a canonical Huffman code. The - * code lengths are lens[0..codes-1]. Each length corresponds to the symbols - * 0..codes-1. The Huffman code is generated by first sorting the symbols by - * length from short to long, and retaining the symbol order for codes with - * equal lengths. Then the code starts with all zero bits for the first code - * of the shortest length, and the codes are integer increments for the same - * length, and zeros are appended as the length increases. For the deflate - * format, these bits are stored backwards from their more natural integer - * increment ordering, and so when the decoding tables are built in the - * large loop below, the integer codes are incremented backwards. - * - * This routine assumes, but does not check, that all of the entries in - * lens[] are in the range 0..MAXBITS. The caller must assure this. - * 1..MAXBITS is interpreted as that code length. zero means that that - * symbol does not occur in this code. - * - * The codes are sorted by computing a count of codes for each length, - * creating from that a table of starting indices for each length in the - * sorted table, and then entering the symbols in order in the sorted table. - * The sorted table is work[], with that space being provided by the caller. - * - * The length counts are used for other purposes as well, i.e. finding the - * minimum and maximum length codes, determining if there are any codes at - * all, checking for a valid set of lengths, and looking ahead at length - * counts to determine sub-table sizes when building the decoding tables. - */ + * Process a set of code lengths to create a canonical Huffman code. The + * code lengths are lens[0..codes-1]. Each length corresponds to the symbols + * 0..codes-1. The Huffman code is generated by first sorting the symbols by + * length from short to long, and retaining the symbol order for codes with + * equal lengths. Then the code starts with all zero bits for the first code + * of the shortest length, and the codes are integer increments for the same + * length, and zeros are appended as the length increases. For the deflate + * format, these bits are stored backwards from their more natural integer + * increment ordering, and so when the decoding tables are built in the + * large loop below, the integer codes are incremented backwards. + * + * This routine assumes, but does not check, that all of the entries in + * lens[] are in the range 0..MAXBITS. The caller must assure this. + * 1..MAXBITS is interpreted as that code length. zero means that that + * symbol does not occur in this code. + * + * The codes are sorted by computing a count of codes for each length, + * creating from that a table of starting indices for each length in the + * sorted table, and then entering the symbols in order in the sorted table. + * The sorted table is work[], with that space being provided by the caller. + * + * The length counts are used for other purposes as well, i.e. finding the + * minimum and maximum length codes, determining if there are any codes at + * all, checking for a valid set of lengths, and looking ahead at length + * counts to determine sub-table sizes when building the decoding tables. + */ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ for (len = 0; len <= MAXBITS; len++) { @@ -4747,35 +4746,35 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta } /* - * Create and fill in decoding tables. In this loop, the table being filled - * is at next and has curr index bits. The code being used is huff with - * length len. That code is converted to an index by dropping drop bits off - * of the bottom. For codes where len is less than drop + curr, those top - * drop + curr - len bits are incremented through all values to fill the - * table with replicated entries. - * - * root is the number of index bits for the root table. When len exceeds - * root, sub-tables are created pointed to by the root entry with an index - * of the low root bits of huff. This is saved in low to check for when a - * new sub-table should be started. drop is zero when the root table is - * being filled, and drop is root when sub-tables are being filled. - * - * When a new sub-table is needed, it is necessary to look ahead in the code - * lengths to determine what size sub-table is needed. The length counts are - * used for this, and so count[] is decremented as codes are entered in the - * tables. - * - * used keeps track of how many table entries have been allocated from the - * provided *table space. It is checked for LENS and DIST tables against the - * constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in the - * initial root table size constants. See the comments in inftrees.h for - * more information. - * - * sym increments through all symbols, and the loop terminates when all - * codes of length max, i.e. all codes, have been processed. This routine - * permits incomplete codes, so another loop after this one fills in the - * rest of the decoding tables with invalid code markers. - */ + * Create and fill in decoding tables. In this loop, the table being filled + * is at next and has curr index bits. The code being used is huff with + * length len. That code is converted to an index by dropping drop bits off + * of the bottom. For codes where len is less than drop + curr, those top + * drop + curr - len bits are incremented through all values to fill the + * table with replicated entries. + * + * root is the number of index bits for the root table. When len exceeds + * root, sub-tables are created pointed to by the root entry with an index + * of the low root bits of huff. This is saved in low to check for when a + * new sub-table should be started. drop is zero when the root table is + * being filled, and drop is root when sub-tables are being filled. + * + * When a new sub-table is needed, it is necessary to look ahead in the code + * lengths to determine what size sub-table is needed. The length counts are + * used for this, and so count[] is decremented as codes are entered in the + * tables. + * + * used keeps track of how many table entries have been allocated from the + * provided *table space. It is checked for LENS and DIST tables against the + * constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in the + * initial root table size constants. See the comments in inftrees.h for + * more information. + * + * sym increments through all symbols, and the loop terminates when all + * codes of length max, i.e. all codes, have been processed. This routine + * permits incomplete codes, so another loop after this one fills in the + * rest of the decoding tables with invalid code markers. + */ /* set up for code type */ // poor man optimization - use if-else instead of switch, @@ -4891,18 +4890,18 @@ module.exports = function inflate_table(type, lens, lens_index, codes, table, ta /* point entry in root table to sub-table */ low = huff & mask; /* - * table.op[low] = curr; table.bits[low] = root; table.val[low] = next - - * opts.table_index; - */ + * table.op[low] = curr; table.bits[low] = root; table.val[low] = next - + * opts.table_index; + */ table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; } } /* - * fill in remaining table entry if code is incomplete (guaranteed to have - * at most one remaining entry, since if the code is incomplete, the maximum - * code length that was allowed to get this far is one bit) - */ + * fill in remaining table entry if code is incomplete (guaranteed to have + * at most one remaining entry, since if the code is incomplete, the maximum + * code length that was allowed to get this far is one bit) + */ if (huff !== 0) { // table.op[next + huff] = 64; /* invalid code marker */ // table.bits[next + huff] = len - drop; @@ -5217,9 +5216,9 @@ function gen_bitlen(s, desc) } /* - * In a first pass, compute the optimal bit lengths (which may overflow in - * the case of the bit length tree). - */ + * In a first pass, compute the optimal bit lengths (which may overflow in + * the case of the bit length tree). + */ tree[s.heap[s.heap_max] * 2 + 1]/* .Len */ = 0; /* root of the heap */ for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { @@ -5258,18 +5257,18 @@ function gen_bitlen(s, desc) s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */ s.bl_count[max_length]--; /* - * The brother of the overflow item also moves one step up, but this does - * not affect bl_count[max_length] - */ + * The brother of the overflow item also moves one step up, but this does + * not affect bl_count[max_length] + */ overflow -= 2; } while (overflow > 0); /* - * Now recompute all bit lengths, scanning in increasing frequency. h is - * still equal to HEAP_SIZE. (It is simpler to reconstruct all lengths - * instead of fixing only the wrong ones. This idea is taken from 'ar' - * written by Haruhiko Okumura.) - */ + * Now recompute all bit lengths, scanning in increasing frequency. h is + * still equal to HEAP_SIZE. (It is simpler to reconstruct all lengths + * instead of fixing only the wrong ones. This idea is taken from 'ar' + * written by Haruhiko Okumura.) + */ for (bits = max_length; bits !== 0; bits--) { n = s.bl_count[bits]; while (n !== 0) { @@ -5300,24 +5299,24 @@ function gen_codes(tree, max_code, bl_count) // ushf *bl_count; /* number of codes at each bit length */ { var next_code = new Array(MAX_BITS + 1); /* - * next code value for each bit - * length - */ + * next code value for each bit + * length + */ var code = 0; /* running code value */ var bits; /* bit index */ var n; /* code index */ /* - * The distribution counts are first used to generate the code values - * without bit reversal. - */ + * The distribution counts are first used to generate the code values + * without bit reversal. + */ for (bits = 1; bits <= MAX_BITS; bits++) { next_code[bits] = code = (code + bl_count[bits - 1]) << 1; } /* - * Check that the bit counts in bl_count are consistent. The last code must - * be all ones. - */ + * Check that the bit counts in bl_count are consistent. The last code must + * be all ones. + */ // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1, // "inconsistent bit counts"); // Tracev((stderr,"\ngen_codes: max_code %d ", max_code)); @@ -5368,10 +5367,10 @@ function tr_static_init() { } // Assert (length == 256, "tr_static_init: length != 256"); /* - * Note that the length 255 (match length 258) can be represented in two - * different ways: code 284 + 5 bits or code 285, so we overwrite - * length_code[255] to use the best encoding: - */ + * Note that the length 255 (match length 258) can be represented in two + * different ways: code 284 + 5 bits or code 285, so we overwrite + * length_code[255] to use the best encoding: + */ _length_code[length - 1] = code; /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ @@ -5419,9 +5418,9 @@ function tr_static_init() { bl_count[8]++; } /* - * Codes 286 and 287 do not exist, but we must include them in the tree - * construction to get a canonical Huffman tree (longest code all ones) - */ + * Codes 286 and 287 do not exist, but we must include them in the tree + * construction to get a canonical Huffman tree (longest code all ones) + */ gen_codes(static_ltree, L_CODES + 1, bl_count); /* The static distance tree is trivial: */ @@ -5624,10 +5623,10 @@ function build_tree(s, desc) var node; /* new node being created */ /* - * Construct the initial heap, with least frequent element in - * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. - * heap[0] is not used. - */ + * Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ s.heap_len = 0; s.heap_max = HEAP_SIZE; @@ -5642,11 +5641,11 @@ function build_tree(s, desc) } /* - * The pkzip format requires that at least one distance code exists, and - * that at least one bit should be sent even if there is only one possible - * code. So to avoid special checks later on we force at least two codes of - * non zero frequency. - */ + * The pkzip format requires that at least one distance code exists, and + * that at least one bit should be sent even if there is only one possible + * code. So to avoid special checks later on we force at least two codes of + * non zero frequency. + */ while (s.heap_len < 2) { node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); tree[node * 2]/* .Freq */ = 1; @@ -5661,15 +5660,15 @@ function build_tree(s, desc) desc.max_code = max_code; /* - * The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, - * establish sub-heaps of increasing lengths: - */ + * The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ for (n = (s.heap_len >> 1/* int /2 */); n >= 1; n--) { pqdownheap(s, tree, n); } /* - * Construct the Huffman tree by repeatedly combining the least two frequent - * nodes. - */ + * Construct the Huffman tree by repeatedly combining the least two frequent + * nodes. + */ node = elems; /* next internal node of the tree */ do { // pqremove(s, tree, n); /* n = node of least frequency */ @@ -5698,9 +5697,9 @@ function build_tree(s, desc) s.heap[--s.heap_max] = s.heap[1/* SMALLEST */]; /* - * At this point, the fields freq and dad are set. We can now generate the - * bit lengths. - */ + * At this point, the fields freq and dad are set. We can now generate the + * bit lengths. + */ gen_bitlen(s, desc); /* The field len is now set, we can generate the bit codes */ @@ -5862,15 +5861,15 @@ function build_bl_tree(s) { /* Build the bit length tree: */ build_tree(s, s.bl_desc); /* - * opt_len now includes the length of the tree representations, except the - * lengths of the bit lengths codes and the 5+5+4 bits for the counts. - */ + * opt_len now includes the length of the tree representations, except the + * lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ /* - * Determine the number of bit length codes to send. The pkzip format - * requires that at least 4 bit length codes be sent. (appnote.txt says 3 - * but the actual value used is 4.) - */ + * Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says 3 + * but the actual value used is 4.) + */ for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/* .Len */ !== 0) { break; @@ -5932,9 +5931,9 @@ function send_all_trees(s, lcodes, dcodes, blcodes) */ function detect_data_type(s) { /* - * black_mask is the bit mask of black-listed bytes set bits 0..6, 14..25, - * and 28..31 0xf3ffc07f = binary 11110011111111111100000001111111 - */ + * black_mask is the bit mask of black-listed bytes set bits 0..6, 14..25, + * and 28..31 0xf3ffc07f = binary 11110011111111111100000001111111 + */ var black_mask = 0xf3ffc07f; var n; @@ -5957,9 +5956,9 @@ function detect_data_type(s) { } /* - * There are no "black-listed" or "white-listed" bytes: this stream either - * is empty or has tolerated ("gray-listed") bytes only. - */ + * There are no "black-listed" or "white-listed" bytes: this stream either + * is empty or has tolerated ("gray-listed") bytes only. + */ return Z_BINARY; } @@ -6030,9 +6029,9 @@ function _tr_flush_block(s, buf, stored_len, last) { var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ var max_blindex = 0; /* - * index of last bit length code of non zero - * freq - */ + * index of last bit length code of non zero + * freq + */ /* Build the Huffman trees unless a stored block is forced */ if (s.level > 0) { @@ -6051,14 +6050,14 @@ function _tr_flush_block(s, buf, stored_len, last) // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, // s->static_len)); /* - * At this point, opt_len and static_len are the total bit lengths of the - * compressed block data, excluding the tree representations. - */ + * At this point, opt_len and static_len are the total bit lengths of the + * compressed block data, excluding the tree representations. + */ /* - * Build the bit length tree for the above two trees, and get the index in - * bl_order of the last bit length code to send. - */ + * Build the bit length tree for the above two trees, and get the index in + * bl_order of the last bit length code to send. + */ max_blindex = build_bl_tree(s); /* Determine the best encoding. Compute the block lengths in bytes. */ @@ -6080,11 +6079,11 @@ function _tr_flush_block(s, buf, stored_len, last) /* 4: two words for the lengths */ /* - * The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. Otherwise - * we can't have processed more than WSIZE input bytes since the last block - * flush, because compression would have been successful. If LIT_BUFSIZE <= - * WSIZE, it is never too late to transform a block into a stored block. - */ + * The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. Otherwise + * we can't have processed more than WSIZE input bytes since the last block + * flush, because compression would have been successful. If LIT_BUFSIZE <= + * WSIZE, it is never too late to transform a block into a stored block. + */ _tr_stored_block(s, buf, stored_len, last); } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { @@ -6099,9 +6098,9 @@ function _tr_flush_block(s, buf, stored_len, last) } // Assert (s->compressed_len == s->bits_sent, "bad compressed size"); /* - * The above check is made mod 2^32, for files larger than 512 MB and uLong - * implemented on 32 bits. - */ + * The above check is made mod 2^32, for files larger than 512 MB and uLong + * implemented on 32 bits. + */ init_block(s); if (last) { @@ -6170,9 +6169,9 @@ function _tr_tally(s, dist, lc) return (s.last_lit === s.lit_bufsize - 1); /* - * We avoid equality with lit_bufsize because of wraparound at 64K on 16 bit - * machines and because stored blocks are restricted to 64K-1 bytes. - */ + * We avoid equality with lit_bufsize because of wraparound at 64K on 16 bit + * machines and because stored blocks are restricted to 64K-1 bytes. + */ } exports._tr_init = _tr_init; @@ -13936,9 +13935,9 @@ RawEncoder.prototype._flush = function (cb) { * * @param schema * @param opts - * {Object} - * + `blockSize`, uncompressed. + `codec` + `codecs` + `noCheck` + - * `omitHeader`, useful to append to an existing block file. + * {Object} + `blockSize`, uncompressed. + `codec` + `codecs` + + * `noCheck` + `omitHeader`, useful to append to an existing block + * file. */ function BlockEncoder(schema, opts) { opts = opts || {}; @@ -16805,20 +16804,20 @@ function assembleProtocol(fpath, opts, cb) { /** * Convenience function to parse multiple inputs into protocols and schemas. * - * It should cover most basic use-cases but has a few limitations: - * + It doesn't allow passing options to the parsing step. + The protocol/type - * inference logic can be deceived. + * It should cover most basic use-cases but has a few limitations: + It doesn't + * allow passing options to the parsing step. + The protocol/type inference + * logic can be deceived. * - * The parsing logic is as follows: - * + If `str` contains `path.sep` (on windows `\`, otherwise `/`) and is a path - * to an existing file, it will first be read as JSON, then as an IDL - * specification if JSON parsing failed. If either succeeds, the result is - * returned, otherwise the next steps are run using the file's content instead - * of the input path. + If `str` is a valid JSON string, it is parsed then - * returned. + If `str` is a valid IDL protocol specification, it is parsed and - * returned if no imports are present (and an error is thrown if there are any - * imports). + If `str` is a valid IDL type specification, it is parsed and - * returned. + If neither of the above cases apply, `str` is returned. + * The parsing logic is as follows: + If `str` contains `path.sep` (on windows + * `\`, otherwise `/`) and is a path to an existing file, it will first be read + * as JSON, then as an IDL specification if JSON parsing failed. If either + * succeeds, the result is returned, otherwise the next steps are run using the + * file's content instead of the input path. + If `str` is a valid JSON string, + * it is parsed then returned. + If `str` is a valid IDL protocol specification, + * it is parsed and returned if no imports are present (and an error is thrown + * if there are any imports). + If `str` is a valid IDL type specification, it + * is parsed and returned. + If neither of the above cases apply, `str` is + * returned. */ function read(str) { var schema; @@ -17172,12 +17171,12 @@ Reader.prototype._readImports = function (imports, maybeMessage) { /** * Simple class to split an input string into tokens. * - * There are different types of tokens, characterized by their `id`: - * + `number` numbers. + `name` references. + `string` double-quoted. + - * `operator`, anything else, always single character. + `javadoc`, only emitted - * when `next` is called with `emitJavadoc` set. + `json`, only emitted when - * `next` is called with `'json'` as `id` (the tokenizer doesn't have enough - * context to predict these). + * There are different types of tokens, characterized by their `id`: + `number` + * numbers. + `name` references. + `string` double-quoted. + `operator`, + * anything else, always single character. + `javadoc`, only emitted when `next` + * is called with `emitJavadoc` set. + `json`, only emitted when `next` is + * called with `'json'` as `id` (the tokenizer doesn't have enough context to + * predict these). */ function Tokenizer(str) { this._str = str; @@ -17437,9 +17436,9 @@ var LOGICAL_TYPE = null; * * This class' constructor will register any named types to support recursive * schemas. All type values are represented in memory similarly to their JSON - * representation, except for: - * + `bytes` and `fixed` which are represented as `Buffer`s. + `union`s which - * will be "unwrapped" unless the `wrapUnions` option is set. + * representation, except for: + `bytes` and `fixed` which are represented as + * `Buffer`s. + `union`s which will be "unwrapped" unless the `wrapUnions` + * option is set. * * See individual subclasses for details. */ @@ -18576,9 +18575,8 @@ UnionType.prototype.getTypes = function () { return this.types; }; * number types are in the union). * * Currently, this union supports at most one type in each of the categories - * below: - * + `null` + `boolean` + `int`, `long`, `float`, `double` + `string`, `enum` + - * `bytes`, `fixed` + `array` + `map`, `record` + * below: + `null` + `boolean` + `int`, `long`, `float`, `double` + `string`, + * `enum` + `bytes`, `fixed` + `array` + `map`, `record` */ function UnwrappedUnionType(schema, opts) { UnionType.call(this, schema, opts); @@ -18763,15 +18761,15 @@ UnwrappedUnionType.prototype.random = function () { * contained type). * * This is not ideal, but is the most efficient way to unambiguously support all - * unions. Here are a few reasons why the wrapping object is necessary: - * + Unions with multiple number types would have undefined behavior, unless - * numbers are wrapped (either everywhere, leading to large performance and - * convenience costs; or only when necessary inside unions, making it hard to - * understand when numbers are wrapped or not). + Fixed types would have to be - * wrapped to be distinguished from bytes. + Using record's constructor names - * would work (after a slight change to use the fully qualified name), but would - * mean that generic objects could no longer be valid records (making it - * inconvenient to do simple things like creating new records). + * unions. Here are a few reasons why the wrapping object is necessary: + Unions + * with multiple number types would have undefined behavior, unless numbers are + * wrapped (either everywhere, leading to large performance and convenience + * costs; or only when necessary inside unions, making it hard to understand + * when numbers are wrapped or not). + Fixed types would have to be wrapped to + * be distinguished from bytes. + Using record's constructor names would work + * (after a slight change to use the fully qualified name), but would mean that + * generic objects could no longer be valid records (making it inconvenient to + * do simple things like creating new records). */ function WrappedUnionType(schema, opts) { UnionType.call(this, schema, opts); @@ -20284,9 +20282,9 @@ function readArraySize(tap) { * @param n * {Number} The number. * - * Two things to note: - * + We are not using the `Number` constants for compatibility with older - * browsers. + We must remove one from each bound because of rounding errors. + * Two things to note: + We are not using the `Number` constants for + * compatibility with older browsers. + We must remove one from each bound + * because of rounding errors. */ function isSafeLong(n) { return n >= -9007199254740990 && n <= 9007199254740990; diff --git a/client/client-monitoring/src/main/resources/webapp/js/jquery/jquery-1.12.4.js b/client/client-monitoring/src/main/resources/webapp/js/jquery/jquery-1.12.4.js deleted file mode 100644 index 13ca4772b..000000000 --- a/client/client-monitoring/src/main/resources/webapp/js/jquery/jquery-1.12.4.js +++ /dev/null @@ -1,13201 +0,0 @@ -/*! - * jQuery JavaScript Library v1.12.4 - * http://jquery.com/ - * - * Includes Sizzle.js - * http://sizzlejs.com/ - * - * Copyright jQuery Foundation and other contributors - * Released under the MIT license - * http://jquery.org/license - * - * Date: 2016-05-20T17:17Z - */ - -(function(global, factory) { - - if (typeof module === "object" && typeof module.exports === "object") { - // For CommonJS and CommonJS-like environments where a proper `window` - // is present, execute the factory and get jQuery. - // For environments that do not have a `window` with a `document` - // (such as Node.js), expose a factory as module.exports. - // This accentuates the need for the creation of a real `window`. - // e.g. var jQuery = require("jquery")(window); - // See ticket #14549 for more info. - module.exports = global.document ? factory(global, true) : function(w) { - if (!w.document) { - throw new Error("jQuery requires a window with a document"); - } - return factory(w); - }; - } else { - factory(global); - } - - // Pass this if window is not defined yet -} - ( - typeof window !== "undefined" ? window : this, - function(window, noGlobal) { - - // Support: Firefox 18+ - // Can't be in strict mode, several libs including ASP.NET - // trace - // the stack via arguments.caller.callee and Firefox dies if - // you try to trace through "use strict" call chains. - // (#13335) - // "use strict"; - var deletedIds = []; - - var document = window.document; - - var slice = deletedIds.slice; - - var concat = deletedIds.concat; - - var push = deletedIds.push; - - var indexOf = deletedIds.indexOf; - - var class2type = {}; - - var toString = class2type.toString; - - var hasOwn = class2type.hasOwnProperty; - - var support = {}; - - var version = "1.12.4", - - // Define a local copy of jQuery - jQuery = function(selector, context) { - - // The jQuery object is actually just the init - // constructor 'enhanced' - // Need init if jQuery is called (just allow error to be - // thrown if not included) - return new jQuery.fn.init(selector, context); - }, - - // Support: Android<4.1, IE<9 - // Make sure we trim BOM and NBSP - rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, - - // Matches dashed string for camelizing - rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, - - // Used by jQuery.camelCase as callback to replace() - fcamelCase = function(all, letter) { - return letter.toUpperCase(); - }; - - jQuery.fn = jQuery.prototype = { - - // The current version of jQuery being used - jquery : version, - - constructor : jQuery, - - // Start with an empty selector - selector : "", - - // The default length of a jQuery object is 0 - length : 0, - - toArray : function() { - return slice.call(this); - }, - - // Get the Nth element in the matched element set OR - // Get the whole matched element set as a clean array - get : function(num) { - return num != null ? - - // Return just the one element from the set - (num < 0 ? this[num + this.length] : this[num]) : - - // Return all the elements in a clean array - slice.call(this); - }, - - // Take an array of elements and push it onto the stack - // (returning the new matched element set) - pushStack : function(elems) { - - // Build a new jQuery matched element set - var ret = jQuery.merge(this.constructor(), elems); - - // Add the old object onto the stack (as a - // reference) - ret.prevObject = this; - ret.context = this.context; - - // Return the newly-formed element set - return ret; - }, - - // Execute a callback for every element in the matched - // set. - each : function(callback) { - return jQuery.each(this, callback); - }, - - map : function(callback) { - return this.pushStack(jQuery.map(this, function( - elem, i) { - return callback.call(elem, i, elem); - })); - }, - - slice : function() { - return this.pushStack(slice.apply(this, arguments)); - }, - - first : function() { - return this.eq(0); - }, - - last : function() { - return this.eq(-1); - }, - - eq : function(i) { - var len = this.length, j = +i + (i < 0 ? len : 0); - return this - .pushStack(j >= 0 && j < len ? [ this[j] ] - : []); - }, - - end : function() { - return this.prevObject || this.constructor(); - }, - - // For internal use only. - // Behaves like an Array's method, not like a jQuery - // method. - push : push, - sort : deletedIds.sort, - splice : deletedIds.splice - }; - - jQuery.extend = jQuery.fn.extend = function() { - var src, copyIsArray, copy, name, options, clone, target = arguments[0] - || {}, i = 1, length = arguments.length, deep = false; - - // Handle a deep copy situation - if (typeof target === "boolean") { - deep = target; - - // skip the boolean and the target - target = arguments[i] || {}; - i++; - } - - // Handle case when target is a string or something - // (possible in deep copy) - if (typeof target !== "object" - && !jQuery.isFunction(target)) { - target = {}; - } - - // extend jQuery itself if only one argument is passed - if (i === length) { - target = this; - i--; - } - - for (; i < length; i++) { - - // Only deal with non-null/undefined values - if ((options = arguments[i]) != null) { - - // Extend the base object - for (name in options) { - src = target[name]; - copy = options[name]; - - // Prevent never-ending loop - if (target === copy) { - continue; - } - - // Recurse if we're merging plain objects or - // arrays - if (deep - && copy - && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery - .isArray(copy)))) { - - if (copyIsArray) { - copyIsArray = false; - clone = src && jQuery.isArray(src) ? src - : []; - - } else { - clone = src - && jQuery - .isPlainObject(src) ? src - : {}; - } - - // Never move original objects, clone - // them - target[name] = jQuery.extend(deep, - clone, copy); - - // Don't bring in undefined values - } else if (copy !== undefined) { - target[name] = copy; - } - } - } - } - - // Return the modified object - return target; - }; - - jQuery - .extend({ - - // Unique for each copy of jQuery on the page - expando : "jQuery" - + (version + Math.random()).replace( - /\D/g, ""), - - // Assume jQuery is ready without the ready - // module - isReady : true, - - error : function(msg) { - throw new Error(msg); - }, - - noop : function() { - }, - - // See test/unit/core.js for details concerning - // isFunction. - // Since version 1.3, DOM methods and functions - // like alert - // aren't supported. They return false on IE - // (#2968). - isFunction : function(obj) { - return jQuery.type(obj) === "function"; - }, - - isArray : Array.isArray || function(obj) { - return jQuery.type(obj) === "array"; - }, - - isWindow : function(obj) { - /* jshint eqeqeq: false */ - return obj != null && obj == obj.window; - }, - - isNumeric : function(obj) { - - // parseFloat NaNs numeric-cast false - // positives (null|true|false|"") - // ...but misinterprets leading-number - // strings, particularly hex literals - // ("0x...") - // subtraction forces infinities to NaN - // adding 1 corrects loss of precision from - // parseFloat (#15100) - var realStringObj = obj && obj.toString(); - return !jQuery.isArray(obj) - && (realStringObj - - parseFloat(realStringObj) + 1) >= 0; - }, - - isEmptyObject : function(obj) { - var name; - for (name in obj) { - return false; - } - return true; - }, - - isPlainObject : function(obj) { - var key; - - // Must be an Object. - // Because of IE, we also have to check the - // presence of the constructor property. - // Make sure that DOM nodes and window - // objects don't pass through, as well - if (!obj || jQuery.type(obj) !== "object" - || obj.nodeType - || jQuery.isWindow(obj)) { - return false; - } - - try { - - // Not own constructor property must be - // Object - if (obj.constructor - && !hasOwn.call(obj, - "constructor") - && !hasOwn - .call( - obj.constructor.prototype, - "isPrototypeOf")) { - return false; - } - } catch (e) { - - // IE8,9 Will throw exceptions on - // certain host objects #9897 - return false; - } - - // Support: IE<9 - // Handle iteration over inherited - // properties before own properties. - if (!support.ownFirst) { - for (key in obj) { - return hasOwn.call(obj, key); - } - } - - // Own properties are enumerated firstly, so - // to speed up, - // if last one is own, then all properties - // are own. - for (key in obj) { - } - - return key === undefined - || hasOwn.call(obj, key); - }, - - type : function(obj) { - if (obj == null) { - return obj + ""; - } - return typeof obj === "object" - || typeof obj === "function" ? class2type[toString - .call(obj)] - || "object" - : typeof obj; - }, - - // Workarounds based on findings by Jim Driscoll - // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context - globalEval : function(data) { - if (data && jQuery.trim(data)) { - - // We use execScript on Internet - // Explorer - // We use an anonymous function so that - // context is window - // rather than jQuery in Firefox - (window.execScript || function(data) { - window["eval"].call(window, data); // jscs:ignore - // requireDotNotation - })(data); - } - }, - - // Convert dashed to camelCase; used by the css - // and data modules - // Microsoft forgot to hump their vendor prefix - // (#9572) - camelCase : function(string) { - return string.replace(rmsPrefix, "ms-") - .replace(rdashAlpha, fcamelCase); - }, - - nodeName : function(elem, name) { - return elem.nodeName - && elem.nodeName.toLowerCase() === name - .toLowerCase(); - }, - - each : function(obj, callback) { - var length, i = 0; - - if (isArrayLike(obj)) { - length = obj.length; - for (; i < length; i++) { - if (callback - .call(obj[i], i, obj[i]) === false) { - break; - } - } - } else { - for (i in obj) { - if (callback - .call(obj[i], i, obj[i]) === false) { - break; - } - } - } - - return obj; - }, - - // Support: Android<4.1, IE<9 - trim : function(text) { - return text == null ? "" : (text + "") - .replace(rtrim, ""); - }, - - // results is for internal usage only - makeArray : function(arr, results) { - var ret = results || []; - - if (arr != null) { - if (isArrayLike(Object(arr))) { - jQuery - .merge( - ret, - typeof arr === "string" ? [ arr ] - : arr); - } else { - push.call(ret, arr); - } - } - - return ret; - }, - - inArray : function(elem, arr, i) { - var len; - - if (arr) { - if (indexOf) { - return indexOf.call(arr, elem, i); - } - - len = arr.length; - i = i ? i < 0 ? Math.max(0, len + i) - : i : 0; - - for (; i < len; i++) { - - // Skip accessing in sparse arrays - if (i in arr && arr[i] === elem) { - return i; - } - } - } - - return -1; - }, - - merge : function(first, second) { - var len = +second.length, j = 0, i = first.length; - - while (j < len) { - first[i++] = second[j++]; - } - - // Support: IE<9 - // Workaround casting of .length to NaN on - // otherwise arraylike objects (e.g., - // NodeLists) - if (len !== len) { - while (second[j] !== undefined) { - first[i++] = second[j++]; - } - } - - first.length = i; - - return first; - }, - - grep : function(elems, callback, invert) { - var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; - - // Go through the array, only saving the - // items - // that pass the validator function - for (; i < length; i++) { - callbackInverse = !callback(elems[i], i); - if (callbackInverse !== callbackExpect) { - matches.push(elems[i]); - } - } - - return matches; - }, - - // arg is for internal usage only - map : function(elems, callback, arg) { - var length, value, i = 0, ret = []; - - // Go through the array, translating each of - // the items to their new values - if (isArrayLike(elems)) { - length = elems.length; - for (; i < length; i++) { - value = callback(elems[i], i, arg); - - if (value != null) { - ret.push(value); - } - } - - // Go through every key on the object, - } else { - for (i in elems) { - value = callback(elems[i], i, arg); - - if (value != null) { - ret.push(value); - } - } - } - - // Flatten any nested arrays - return concat.apply([], ret); - }, - - // A global GUID counter for objects - guid : 1, - - // Bind a function to a context, optionally - // partially applying any - // arguments. - proxy : function(fn, context) { - var args, proxy, tmp; - - if (typeof context === "string") { - tmp = fn[context]; - context = fn; - fn = tmp; - } - - // Quick check to determine if target is - // callable, in the spec - // this throws a TypeError, but we will just - // return undefined. - if (!jQuery.isFunction(fn)) { - return undefined; - } - - // Simulated bind - args = slice.call(arguments, 2); - proxy = function() { - return fn.apply(context || this, args - .concat(slice.call(arguments))); - }; - - // Set the guid of unique handler to the - // same of original handler, so it can be - // removed - proxy.guid = fn.guid = fn.guid - || jQuery.guid++; - - return proxy; - }, - - now : function() { - return +(new Date()); - }, - - // jQuery.support is not used in Core but other - // projects attach their - // properties to it so it needs to exist. - support : support - }); - - // JSHint would error on this code due to the Symbol not - // being defined in ES5. - // Defining this global in .jshintrc would create a danger - // of using the global - // unguarded in another place, it seems safer to just - // disable JSHint for these - // three lines. - /* jshint ignore: start */ - if (typeof Symbol === "function") { - jQuery.fn[Symbol.iterator] = deletedIds[Symbol.iterator]; - } - /* jshint ignore: end */ - - // Populate the class2type map - jQuery.each( - "Boolean Number String Function Array Date RegExp Object Error Symbol" - .split(" "), function(i, name) { - class2type["[object " + name + "]"] = name - .toLowerCase(); - }); - - function isArrayLike(obj) { - - // Support: iOS 8.2 (not reproducible in simulator) - // `in` check used to prevent JIT error (gh-2145) - // hasOwn isn't used here due to false negatives - // regarding Nodelist length in IE - var length = !!obj && "length" in obj && obj.length, type = jQuery - .type(obj); - - if (type === "function" || jQuery.isWindow(obj)) { - return false; - } - - return type === "array" || length === 0 - || typeof length === "number" && length > 0 - && (length - 1) in obj; - } - var Sizzle = - /* - * ! Sizzle CSS Selector Engine v2.2.1 http://sizzlejs.com/ - * - * Copyright jQuery Foundation and other contributors - * Released under the MIT license http://jquery.org/license - * - * Date: 2015-10-17 - */ - (function(window) { - - var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, - - // Local document vars - setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, - - // Instance-specific data - expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( - a, b) { - if (a === b) { - hasDuplicate = true; - } - return 0; - }, - - // General-purpose constants - MAX_NEGATIVE = 1 << 31, - - // Instance methods - hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, - // Use a stripped-down indexOf as it's faster than - // native - // http://jsperf.com/thor-indexof-vs-for/5 - indexOf = function(list, elem) { - var i = 0, len = list.length; - for (; i < len; i++) { - if (list[i] === elem) { - return i; - } - } - return -1; - }, - - booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", - - // Regular expressions - - // http://www.w3.org/TR/css3-selectors/#whitespace - whitespace = "[\\x20\\t\\r\\n\\f]", - - // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier - identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", - - // Attribute selectors: - // http://www.w3.org/TR/selectors/#attribute-selectors - attributes = "\\[" + whitespace + "*(" + identifier - + ")(?:" + whitespace + - // Operator (capture 2) - "*([*^$|!~]?=)" + whitespace + - // "Attribute values must be CSS identifiers - // [capture 5] or strings [capture 3 or capture - // 4]" - "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" - + identifier + "))|)" + whitespace + "*\\]", - - pseudos = ":(" + identifier + ")(?:\\((" + - // To reduce the number of selectors needing tokenize in - // the preFilter, prefer arguments: - // 1. quoted (capture 3; capture 4 or capture 5) - "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" - + - // 2. simple (capture 6) - "((?:\\\\.|[^\\\\()[\\]]|" + attributes - + ")*)|" + - // 3. anything else (capture 2) - ".*" + ")\\)|)", - - // Leading and non-escaped trailing whitespace, - // capturing some non-whitespace characters preceding - // the latter - rwhitespace = new RegExp(whitespace + "+", "g"), rtrim = new RegExp( - "^" + whitespace - + "+|((?:^|[^\\\\])(?:\\\\.)*)" - + whitespace + "+$", "g"), - - rcomma = new RegExp("^" + whitespace + "*," - + whitespace + "*"), rcombinators = new RegExp( - "^" + whitespace + "*([>+~]|" + whitespace - + ")" + whitespace + "*"), - - rattributeQuotes = new RegExp("=" + whitespace - + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"), - - rpseudo = new RegExp(pseudos), ridentifier = new RegExp( - "^" + identifier + "$"), - - matchExpr = { - "ID" : new RegExp("^#(" + identifier + ")"), - "CLASS" : new RegExp("^\\.(" + identifier + ")"), - "TAG" : new RegExp("^(" + identifier + "|[*])"), - "ATTR" : new RegExp("^" + attributes), - "PSEUDO" : new RegExp("^" + pseudos), - "CHILD" : new RegExp( - "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" - + whitespace - + "*(even|odd|(([+-]|)(\\d*)n|)" - + whitespace + "*(?:([+-]|)" - + whitespace + "*(\\d+)|))" - + whitespace + "*\\)|)", "i"), - "bool" : new RegExp("^(?:" + booleans + ")$", "i"), - // For use in libraries implementing .is() - // We use this for POS matching in `select` - "needsContext" : new RegExp( - "^" - + whitespace - + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" - + whitespace + "*((?:-\\d)?\\d*)" - + whitespace + "*\\)|)(?=[^-]|$)", - "i") - }, - - rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, - - rnative = /^[^{]+\{\s*\[native \w/, - - // Easily-parseable/retrievable ID or TAG or CLASS - // selectors - rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, - - rsibling = /[+~]/, rescape = /'|\\/g, - - // CSS escapes - // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters - runescape = new RegExp("\\\\([\\da-f]{1,6}" - + whitespace + "?|(" + whitespace + ")|.)", - "ig"), funescape = function(_, escaped, - escapedWhitespace) { - var high = "0x" + escaped - 0x10000; - // NaN means non-codepoint - // Support: Firefox<24 - // Workaround erroneous numeric interpretation of - // +"0x" - return high !== high || escapedWhitespace ? escaped - : high < 0 ? - // BMP codepoint - String.fromCharCode(high + 0x10000) : - // Supplemental Plane codepoint (surrogate - // pair) - String.fromCharCode(high >> 10 | 0xD800, - high & 0x3FF | 0xDC00); - }, - - // Used for iframes - // See setDocument() - // Removing the function wrapper causes a "Permission - // Denied" - // error in IE - unloadHandler = function() { - setDocument(); - }; - - // Optimize for push.apply( _, NodeList ) - try { - push.apply((arr = slice - .call(preferredDoc.childNodes)), - preferredDoc.childNodes); - // Support: Android<4.0 - // Detect silently failing push.apply - arr[preferredDoc.childNodes.length].nodeType; - } catch (e) { - push = { - apply : arr.length ? - - // Leverage slice if possible - function(target, els) { - push_native.apply(target, slice.call(els)); - } : - - // Support: IE<9 - // Otherwise append directly - function(target, els) { - var j = target.length, i = 0; - // Can't trust NodeList.length - while ((target[j++] = els[i++])) { - } - target.length = j - 1; - } - }; - } - - function Sizzle(selector, context, results, seed) { - var m, i, elem, nid, nidselect, match, groups, newSelector, newContext = context - && context.ownerDocument, - - // nodeType defaults to 9, since context defaults to - // document - nodeType = context ? context.nodeType : 9; - - results = results || []; - - // Return early from calls with invalid selector or - // context - if (typeof selector !== "string" || !selector - || nodeType !== 1 && nodeType !== 9 - && nodeType !== 11) { - - return results; - } - - // Try to shortcut find operations (as opposed to - // filters) in HTML documents - if (!seed) { - - if ((context ? context.ownerDocument || context - : preferredDoc) !== document) { - setDocument(context); - } - context = context || document; - - if (documentIsHTML) { - - // If the selector is sufficiently simple, - // try using a "get*By*" DOM method - // (excepting DocumentFragment context, - // where the methods don't exist) - if (nodeType !== 11 - && (match = rquickExpr - .exec(selector))) { - - // ID selector - if ((m = match[1])) { - - // Document context - if (nodeType === 9) { - if ((elem = context - .getElementById(m))) { - - // Support: IE, Opera, - // Webkit - // TODO: identify versions - // getElementById can match - // elements by name instead - // of ID - if (elem.id === m) { - results.push(elem); - return results; - } - } else { - return results; - } - - // Element context - } else { - - // Support: IE, Opera, Webkit - // TODO: identify versions - // getElementById can match - // elements by name instead of - // ID - if (newContext - && (elem = newContext - .getElementById(m)) - && contains(context, - elem) - && elem.id === m) { - - results.push(elem); - return results; - } - } - - // Type selector - } else if (match[2]) { - push - .apply( - results, - context - .getElementsByTagName(selector)); - return results; - - // Class selector - } else if ((m = match[3]) - && support.getElementsByClassName - && context.getElementsByClassName) { - - push.apply(results, context - .getElementsByClassName(m)); - return results; - } - } - - // Take advantage of querySelectorAll - if (support.qsa - && !compilerCache[selector + " "] - && (!rbuggyQSA || !rbuggyQSA - .test(selector))) { - - if (nodeType !== 1) { - newContext = context; - newSelector = selector; - - // qSA looks outside Element - // context, which is not what we - // want - // Thanks to Andrew Dupont for this - // workaround technique - // Support: IE <=8 - // Exclude object elements - } else if (context.nodeName - .toLowerCase() !== "object") { - - // Capture the context ID, setting - // it first if necessary - if ((nid = context - .getAttribute("id"))) { - nid = nid.replace(rescape, - "\\$&"); - } else { - context.setAttribute("id", - (nid = expando)); - } - - // Prefix every selector in the list - groups = tokenize(selector); - i = groups.length; - nidselect = ridentifier.test(nid) ? "#" - + nid - : "[id='" + nid + "']"; - while (i--) { - groups[i] = nidselect + " " - + toSelector(groups[i]); - } - newSelector = groups.join(","); - - // Expand context for sibling - // selectors - newContext = rsibling - .test(selector) - && testContext(context.parentNode) - || context; - } - - if (newSelector) { - try { - push - .apply( - results, - newContext - .querySelectorAll(newSelector)); - return results; - } catch (qsaError) { - } finally { - if (nid === expando) { - context - .removeAttribute("id"); - } - } - } - } - } - } - - // All others - return select(selector.replace(rtrim, "$1"), - context, results, seed); - } - - /** - * Create key-value caches of limited size - * - * @returns {function(string, object)} Returns the - * Object data after storing it on itself with - * property name the (space-suffixed) string - * and (if the cache is larger than - * Expr.cacheLength) deleting the oldest entry - */ - function createCache() { - var keys = []; - - function cache(key, value) { - // Use (key + " ") to avoid collision with - // native prototype properties (see Issue #157) - if (keys.push(key + " ") > Expr.cacheLength) { - // Only keep the most recent entries - delete cache[keys.shift()]; - } - return (cache[key + " "] = value); - } - return cache; - } - - /** - * Mark a function for special use by Sizzle - * - * @param {Function} - * fn The function to mark - */ - function markFunction(fn) { - fn[expando] = true; - return fn; - } - - /** - * Support testing using an element - * - * @param {Function} - * fn Passed the created div and expects a - * boolean result - */ - function assert(fn) { - var div = document.createElement("div"); - - try { - return !!fn(div); - } catch (e) { - return false; - } finally { - // Remove from its parent by default - if (div.parentNode) { - div.parentNode.removeChild(div); - } - // release memory in IE - div = null; - } - } - - /** - * Adds the same handler for all of the specified attrs - * - * @param {String} - * attrs Pipe-separated list of attributes - * @param {Function} - * handler The method that will be applied - */ - function addHandle(attrs, handler) { - var arr = attrs.split("|"), i = arr.length; - - while (i--) { - Expr.attrHandle[arr[i]] = handler; - } - } - - /** - * Checks document order of two siblings - * - * @param {Element} - * a - * @param {Element} - * b - * @returns {Number} Returns less than 0 if a precedes - * b, greater than 0 if a follows b - */ - function siblingCheck(a, b) { - var cur = b && a, diff = cur && a.nodeType === 1 - && b.nodeType === 1 - && (~b.sourceIndex || MAX_NEGATIVE) - - (~a.sourceIndex || MAX_NEGATIVE); - - // Use IE sourceIndex if available on both nodes - if (diff) { - return diff; - } - - // Check if b follows a - if (cur) { - while ((cur = cur.nextSibling)) { - if (cur === b) { - return -1; - } - } - } - - return a ? 1 : -1; - } - - /** - * Returns a function to use in pseudos for input types - * - * @param {String} - * type - */ - function createInputPseudo(type) { - return function(elem) { - var name = elem.nodeName.toLowerCase(); - return name === "input" && elem.type === type; - }; - } - - /** - * Returns a function to use in pseudos for buttons - * - * @param {String} - * type - */ - function createButtonPseudo(type) { - return function(elem) { - var name = elem.nodeName.toLowerCase(); - return (name === "input" || name === "button") - && elem.type === type; - }; - } - - /** - * Returns a function to use in pseudos for positionals - * - * @param {Function} - * fn - */ - function createPositionalPseudo(fn) { - return markFunction(function(argument) { - argument = +argument; - return markFunction(function(seed, matches) { - var j, matchIndexes = fn([], seed.length, - argument), i = matchIndexes.length; - - // Match elements found at the specified - // indexes - while (i--) { - if (seed[(j = matchIndexes[i])]) { - seed[j] = !(matches[j] = seed[j]); - } - } - }); - }); - } - - /** - * Checks a node for validity as a Sizzle context - * - * @param {Element|Object=} - * context - * @returns {Element|Object|Boolean} The input node if - * acceptable, otherwise a falsy value - */ - function testContext(context) { - return context - && typeof context.getElementsByTagName !== "undefined" - && context; - } - - // Expose support vars for convenience - support = Sizzle.support = {}; - - /** - * Detects XML nodes - * - * @param {Element|Object} - * elem An element or a document - * @returns {Boolean} True iff elem is a non-HTML XML - * node - */ - isXML = Sizzle.isXML = function(elem) { - // documentElement is verified for cases where it - // doesn't yet exist - // (such as loading iframes in IE - #4833) - var documentElement = elem - && (elem.ownerDocument || elem).documentElement; - return documentElement ? documentElement.nodeName !== "HTML" - : false; - }; - - /** - * Sets document-related variables once based on the - * current document - * - * @param {Element|Object} - * [doc] An element or document object to use - * to set the document - * @returns {Object} Returns the current document - */ - setDocument = Sizzle.setDocument = function(node) { - var hasCompare, parent, doc = node ? node.ownerDocument - || node - : preferredDoc; - - // Return early if doc is invalid or already - // selected - if (doc === document || doc.nodeType !== 9 - || !doc.documentElement) { - return document; - } - - // Update global variables - document = doc; - docElem = document.documentElement; - documentIsHTML = !isXML(document); - - // Support: IE 9-11, Edge - // Accessing iframe documents after unload throws - // "permission denied" errors (jQuery #13936) - if ((parent = document.defaultView) - && parent.top !== parent) { - // Support: IE 11 - if (parent.addEventListener) { - parent.addEventListener("unload", - unloadHandler, false); - - // Support: IE 9 - 10 only - } else if (parent.attachEvent) { - parent.attachEvent("onunload", - unloadHandler); - } - } - - /* - * Attributes - * ---------------------------------------------------------------------- - */ - - // Support: IE<8 - // Verify that getAttribute really returns - // attributes and not properties - // (excepting IE8 booleans) - support.attributes = assert(function(div) { - div.className = "i"; - return !div.getAttribute("className"); - }); - - /*************************************************** - * getElement(s)By - * ---------------------------------------------------------------------- - */ - - // Check if getElementsByTagName("*") returns only - // elements - support.getElementsByTagName = assert(function(div) { - div.appendChild(document.createComment("")); - return !div.getElementsByTagName("*").length; - }); - - // Support: IE<9 - support.getElementsByClassName = rnative - .test(document.getElementsByClassName); - - // Support: IE<10 - // Check if getElementById returns elements by name - // The broken getElementById methods don't pick up - // programatically-set names, - // so use a roundabout getElementsByName test - support.getById = assert(function(div) { - docElem.appendChild(div).id = expando; - return !document.getElementsByName - || !document.getElementsByName(expando).length; - }); - - // ID find and filter - if (support.getById) { - Expr.find["ID"] = function(id, context) { - if (typeof context.getElementById !== "undefined" - && documentIsHTML) { - var m = context.getElementById(id); - return m ? [ m ] : []; - } - }; - Expr.filter["ID"] = function(id) { - var attrId = id.replace(runescape, - funescape); - return function(elem) { - return elem.getAttribute("id") === attrId; - }; - }; - } else { - // Support: IE6/7 - // getElementById is not reliable as a find - // shortcut - delete Expr.find["ID"]; - - Expr.filter["ID"] = function(id) { - var attrId = id.replace(runescape, - funescape); - return function(elem) { - var node = typeof elem.getAttributeNode !== "undefined" - && elem.getAttributeNode("id"); - return node && node.value === attrId; - }; - }; - } - - // Tag - Expr.find["TAG"] = support.getElementsByTagName ? function( - tag, context) { - if (typeof context.getElementsByTagName !== "undefined") { - return context.getElementsByTagName(tag); - - // DocumentFragment nodes don't have gEBTN - } else if (support.qsa) { - return context.querySelectorAll(tag); - } - } - : - - function(tag, context) { - var elem, tmp = [], i = 0, - // By happy coincidence, a (broken) - // gEBTN appears on DocumentFragment - // nodes too - results = context - .getElementsByTagName(tag); - - // Filter out possible comments - if (tag === "*") { - while ((elem = results[i++])) { - if (elem.nodeType === 1) { - tmp.push(elem); - } - } - - return tmp; - } - return results; - }; - - // Class - Expr.find["CLASS"] = support.getElementsByClassName - && function(className, context) { - if (typeof context.getElementsByClassName !== "undefined" - && documentIsHTML) { - return context - .getElementsByClassName(className); - } - }; - - /* - * QSA/matchesSelector - * ---------------------------------------------------------------------- - */ - - // QSA and matchesSelector support - // matchesSelector(:active) reports false when true - // (IE9/Opera 11.5) - rbuggyMatches = []; - - // qSa(:focus) reports false when true (Chrome 21) - // We allow this because of a bug in IE8/9 that - // throws an error - // whenever `document.activeElement` is accessed on - // an iframe - // So, we allow :focus to pass through QSA all the - // time to avoid the IE error - // See http://bugs.jquery.com/ticket/13378 - rbuggyQSA = []; - - if ((support.qsa = rnative - .test(document.querySelectorAll))) { - // Build QSA regex - // Regex strategy adopted from Diego Perini - assert(function(div) { - // Select is set to empty string on purpose - // This is to test IE's treatment of not - // explicitly - // setting a boolean content attribute, - // since its presence should be enough - // http://bugs.jquery.com/ticket/12359 - docElem.appendChild(div).innerHTML = "<a id='" - + expando - + "'></a>" - + "<select id='" - + expando - + "-\r\\' msallowcapture=''>" - + "<option selected=''></option></select>"; - - // Support: IE8, Opera 11-12.16 - // Nothing should be selected when empty - // strings follow ^= or $= or *= - // The test attribute must be unknown in - // Opera but "safe" for WinRT - // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section - if (div - .querySelectorAll("[msallowcapture^='']").length) { - rbuggyQSA.push("[*^$]=" + whitespace - + "*(?:''|\"\")"); - } - - // Support: IE8 - // Boolean attributes and "value" are not - // treated correctly - if (!div.querySelectorAll("[selected]").length) { - rbuggyQSA - .push("\\[" + whitespace - + "*(?:value|" - + booleans + ")"); - } - - // Support: Chrome<29, Android<4.4, - // Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ - if (!div.querySelectorAll("[id~=" + expando - + "-]").length) { - rbuggyQSA.push("~="); - } - - // Webkit/Opera - :checked should return - // selected option elements - // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked - // IE8 throws error here and will not see - // later tests - if (!div.querySelectorAll(":checked").length) { - rbuggyQSA.push(":checked"); - } - - // Support: Safari 8+, iOS 8+ - // https://bugs.webkit.org/show_bug.cgi?id=136851 - // In-page `selector#id sibing-combinator - // selector` fails - if (!div.querySelectorAll("a#" + expando - + "+*").length) { - rbuggyQSA.push(".#.+[+~]"); - } - }); - - assert(function(div) { - // Support: Windows 8 Native Apps - // The type and name attributes are - // restricted during .innerHTML assignment - var input = document.createElement("input"); - input.setAttribute("type", "hidden"); - div.appendChild(input).setAttribute("name", - "D"); - - // Support: IE8 - // Enforce case-sensitivity of name - // attribute - if (div.querySelectorAll("[name=d]").length) { - rbuggyQSA.push("name" + whitespace - + "*[*^$|!~]?="); - } - - // FF 3.5 - :enabled/:disabled and hidden - // elements (hidden elements are still - // enabled) - // IE8 throws error here and will not see - // later tests - if (!div.querySelectorAll(":enabled").length) { - rbuggyQSA.push(":enabled", ":disabled"); - } - - // Opera 10-11 does not throw on post-comma - // invalid pseudos - div.querySelectorAll("*,:x"); - rbuggyQSA.push(",.*:"); - }); - } - - if ((support.matchesSelector = rnative - .test((matches = docElem.matches - || docElem.webkitMatchesSelector - || docElem.mozMatchesSelector - || docElem.oMatchesSelector - || docElem.msMatchesSelector)))) { - - assert(function(div) { - // Check to see if it's possible to do - // matchesSelector - // on a disconnected node (IE 9) - support.disconnectedMatch = matches.call( - div, "div"); - - // This should fail with an exception - // Gecko does not error, returns false - // instead - matches.call(div, "[s!='']:x"); - rbuggyMatches.push("!=", pseudos); - }); - } - - rbuggyQSA = rbuggyQSA.length - && new RegExp(rbuggyQSA.join("|")); - rbuggyMatches = rbuggyMatches.length - && new RegExp(rbuggyMatches.join("|")); - - /* - * Contains - * ---------------------------------------------------------------------- - */ - hasCompare = rnative - .test(docElem.compareDocumentPosition); - - // Element contains another - // Purposefully self-exclusive - // As in, an element does not contain itself - contains = hasCompare - || rnative.test(docElem.contains) ? function( - a, b) { - var adown = a.nodeType === 9 ? a.documentElement - : a, bup = b && b.parentNode; - return a === bup - || !!(bup && bup.nodeType === 1 && (adown.contains ? adown - .contains(bup) - : a.compareDocumentPosition - && a - .compareDocumentPosition(bup) - & 16)); - } - : function(a, b) { - if (b) { - while ((b = b.parentNode)) { - if (b === a) { - return true; - } - } - } - return false; - }; - - /* - * Sorting - * ---------------------------------------------------------------------- - */ - - // Document order sorting - sortOrder = hasCompare ? function(a, b) { - - // Flag for duplicate removal - if (a === b) { - hasDuplicate = true; - return 0; - } - - // Sort on method existence if only one input - // has compareDocumentPosition - var compare = !a.compareDocumentPosition - - !b.compareDocumentPosition; - if (compare) { - return compare; - } - - // Calculate position if both inputs belong to - // the same document - compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a - .compareDocumentPosition(b) - : - - // Otherwise we know they are - // disconnected - 1; - - // Disconnected nodes - if (compare - & 1 - || (!support.sortDetached && b - .compareDocumentPosition(a) === compare)) { - - // Choose the first element that is related - // to our preferred document - if (a === document - || a.ownerDocument === preferredDoc - && contains(preferredDoc, a)) { - return -1; - } - if (b === document - || b.ownerDocument === preferredDoc - && contains(preferredDoc, b)) { - return 1; - } - - // Maintain original order - return sortInput ? (indexOf(sortInput, a) - indexOf( - sortInput, b)) - : 0; - } - - return compare & 4 ? -1 : 1; - } - : function(a, b) { - // Exit early if the nodes are identical - if (a === b) { - hasDuplicate = true; - return 0; - } - - var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; - - // Parentless nodes are either documents - // or disconnected - if (!aup || !bup) { - return a === document ? -1 - : b === document ? 1 - : aup ? -1 - : bup ? 1 - : sortInput ? (indexOf( - sortInput, - a) - indexOf( - sortInput, - b)) - : 0; - - // If the nodes are siblings, we can - // do a quick check - } else if (aup === bup) { - return siblingCheck(a, b); - } - - // Otherwise we need full lists of their - // ancestors for comparison - cur = a; - while ((cur = cur.parentNode)) { - ap.unshift(cur); - } - cur = b; - while ((cur = cur.parentNode)) { - bp.unshift(cur); - } - - // Walk down the tree looking for a - // discrepancy - while (ap[i] === bp[i]) { - i++; - } - - return i ? - // Do a sibling check if the nodes have - // a common ancestor - siblingCheck(ap[i], bp[i]) : - - // Otherwise nodes in our document sort - // first - ap[i] === preferredDoc ? -1 - : bp[i] === preferredDoc ? 1 - : 0; - }; - - return document; - }; - - Sizzle.matches = function(expr, elements) { - return Sizzle(expr, null, null, elements); - }; - - Sizzle.matchesSelector = function(elem, expr) { - // Set document vars if needed - if ((elem.ownerDocument || elem) !== document) { - setDocument(elem); - } - - // Make sure that attribute selectors are quoted - expr = expr.replace(rattributeQuotes, "='$1']"); - - if (support.matchesSelector - && documentIsHTML - && !compilerCache[expr + " "] - && (!rbuggyMatches || !rbuggyMatches - .test(expr)) - && (!rbuggyQSA || !rbuggyQSA.test(expr))) { - - try { - var ret = matches.call(elem, expr); - - // IE 9's matchesSelector returns false on - // disconnected nodes - if (ret || support.disconnectedMatch || - // As well, disconnected nodes are said to - // be in a document - // fragment in IE 9 - elem.document - && elem.document.nodeType !== 11) { - return ret; - } - } catch (e) { - } - } - - return Sizzle(expr, document, null, [ elem ]).length > 0; - }; - - Sizzle.contains = function(context, elem) { - // Set document vars if needed - if ((context.ownerDocument || context) !== document) { - setDocument(context); - } - return contains(context, elem); - }; - - Sizzle.attr = function(elem, name) { - // Set document vars if needed - if ((elem.ownerDocument || elem) !== document) { - setDocument(elem); - } - - var fn = Expr.attrHandle[name.toLowerCase()], - // Don't get fooled by Object.prototype properties - // (jQuery #13807) - val = fn - && hasOwn.call(Expr.attrHandle, name - .toLowerCase()) ? fn(elem, name, - !documentIsHTML) : undefined; - - return val !== undefined ? val : support.attributes - || !documentIsHTML ? elem - .getAttribute(name) : (val = elem - .getAttributeNode(name)) - && val.specified ? val.value : null; - }; - - Sizzle.error = function(msg) { - throw new Error( - "Syntax error, unrecognized expression: " - + msg); - }; - - /** - * Document sorting and removing duplicates - * - * @param {ArrayLike} - * results - */ - Sizzle.uniqueSort = function(results) { - var elem, duplicates = [], j = 0, i = 0; - - // Unless we *know* we can detect duplicates, assume - // their presence - hasDuplicate = !support.detectDuplicates; - sortInput = !support.sortStable && results.slice(0); - results.sort(sortOrder); - - if (hasDuplicate) { - while ((elem = results[i++])) { - if (elem === results[i]) { - j = duplicates.push(i); - } - } - while (j--) { - results.splice(duplicates[j], 1); - } - } - - // Clear input after sorting to release objects - // See https://github.com/jquery/sizzle/pull/225 - sortInput = null; - - return results; - }; - - /** - * Utility function for retrieving the text value of an - * array of DOM nodes - * - * @param {Array|Element} - * elem - */ - getText = Sizzle.getText = function(elem) { - var node, ret = "", i = 0, nodeType = elem.nodeType; - - if (!nodeType) { - // If no nodeType, this is expected to be an - // array - while ((node = elem[i++])) { - // Do not traverse comment nodes - ret += getText(node); - } - } else if (nodeType === 1 || nodeType === 9 - || nodeType === 11) { - // Use textContent for elements - // innerText usage removed for consistency of - // new lines (jQuery #11153) - if (typeof elem.textContent === "string") { - return elem.textContent; - } else { - // Traverse its children - for (elem = elem.firstChild; elem; elem = elem.nextSibling) { - ret += getText(elem); - } - } - } else if (nodeType === 3 || nodeType === 4) { - return elem.nodeValue; - } - // Do not include comment or processing instruction - // nodes - - return ret; - }; - - Expr = Sizzle.selectors = { - - // Can be adjusted by the user - cacheLength : 50, - - createPseudo : markFunction, - - match : matchExpr, - - attrHandle : {}, - - find : {}, - - relative : { - ">" : { - dir : "parentNode", - first : true - }, - " " : { - dir : "parentNode" - }, - "+" : { - dir : "previousSibling", - first : true - }, - "~" : { - dir : "previousSibling" - } - }, - - preFilter : { - "ATTR" : function(match) { - match[1] = match[1].replace(runescape, - funescape); - - // Move the given value to match[3] whether - // quoted or unquoted - match[3] = (match[3] || match[4] - || match[5] || "").replace( - runescape, funescape); - - if (match[2] === "~=") { - match[3] = " " + match[3] + " "; - } - - return match.slice(0, 4); - }, - - "CHILD" : function(match) { - /* - * matches from matchExpr["CHILD"] 1 type - * (only|nth|...) 2 what (child|of-type) 3 - * argument - * (even|odd|\d*|\d*n([+-]\d+)?|...) 4 - * xn-component of xn+y argument - * ([+-]?\d*n|) 5 sign of xn-component 6 x - * of xn-component 7 sign of y-component 8 y - * of y-component - */ - match[1] = match[1].toLowerCase(); - - if (match[1].slice(0, 3) === "nth") { - // nth-* requires argument - if (!match[3]) { - Sizzle.error(match[0]); - } - - // numeric x and y parameters for - // Expr.filter.CHILD - // remember that false/true cast - // respectively to 0/1 - match[4] = +(match[4] ? match[5] - + (match[6] || 1) - : 2 * (match[3] === "even" || match[3] === "odd")); - match[5] = +((match[7] + match[8]) || match[3] === "odd"); - - // other types prohibit arguments - } else if (match[3]) { - Sizzle.error(match[0]); - } - - return match; - }, - - "PSEUDO" : function(match) { - var excess, unquoted = !match[6] - && match[2]; - - if (matchExpr["CHILD"].test(match[0])) { - return null; - } - - // Accept quoted arguments as-is - if (match[3]) { - match[2] = match[4] || match[5] || ""; - - // Strip excess characters from unquoted - // arguments - } else if (unquoted - && rpseudo.test(unquoted) - && - // Get excess from tokenize - // (recursively) - (excess = tokenize(unquoted, true)) - && - // advance to the next closing - // parenthesis - (excess = unquoted.indexOf(")", - unquoted.length - excess) - - unquoted.length)) { - - // excess is a negative index - match[0] = match[0].slice(0, excess); - match[2] = unquoted.slice(0, excess); - } - - // Return only captures needed by the pseudo - // filter method (type and argument) - return match.slice(0, 3); - } - }, - - filter : { - - "TAG" : function(nodeNameSelector) { - var nodeName = nodeNameSelector.replace( - runescape, funescape).toLowerCase(); - return nodeNameSelector === "*" ? function() { - return true; - } - : function(elem) { - return elem.nodeName - && elem.nodeName - .toLowerCase() === nodeName; - }; - }, - - "CLASS" : function(className) { - var pattern = classCache[className + " "]; - - return pattern - || (pattern = new RegExp("(^|" - + whitespace + ")" - + className + "(" - + whitespace + "|$)")) - && classCache( - className, - function(elem) { - return pattern - .test(typeof elem.className === "string" - && elem.className - || typeof elem.getAttribute !== "undefined" - && elem - .getAttribute("class") - || ""); - }); - }, - - "ATTR" : function(name, operator, check) { - return function(elem) { - var result = Sizzle.attr(elem, name); - - if (result == null) { - return operator === "!="; - } - if (!operator) { - return true; - } - - result += ""; - - return operator === "=" ? result === check - : operator === "!=" ? result !== check - : operator === "^=" ? check - && result - .indexOf(check) === 0 - : operator === "*=" ? check - && result - .indexOf(check) > -1 - : operator === "$=" ? check - && result - .slice(-check.length) === check - : operator === "~=" ? (" " - + result - .replace( - rwhitespace, - " ") + " ") - .indexOf(check) > -1 - : operator === "|=" ? result === check - || result - .slice( - 0, - check.length + 1) === check - + "-" - : false; - }; - }, - - "CHILD" : function(type, what, argument, first, - last) { - var simple = type.slice(0, 3) !== "nth", forward = type - .slice(-4) !== "last", ofType = what === "of-type"; - - return first === 1 && last === 0 ? - - // Shortcut for :nth-*(n) - function(elem) { - return !!elem.parentNode; - } - : - - function(elem, context, xml) { - var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" - : "previousSibling", parent = elem.parentNode, name = ofType - && elem.nodeName - .toLowerCase(), useCache = !xml - && !ofType, diff = false; - - if (parent) { - - // :(first|last|only)-(child|of-type) - if (simple) { - while (dir) { - node = elem; - while ((node = node[dir])) { - if (ofType ? node.nodeName - .toLowerCase() === name - : node.nodeType === 1) { - - return false; - } - } - // Reverse direction - // for :only-* (if - // we haven't yet - // done so) - start = dir = type === "only" - && !start - && "nextSibling"; - } - return true; - } - - start = [ forward ? parent.firstChild - : parent.lastChild ]; - - // non-xml :nth-child(...) - // stores cache data on - // `parent` - if (forward && useCache) { - - // Seek `elem` from a - // previously-cached - // index - - // ...in a gzip-friendly - // way - node = parent; - outerCache = node[expando] - || (node[expando] = {}); - - // Support: IE <9 only - // Defend against cloned - // attroperties (jQuery - // gh-1709) - uniqueCache = outerCache[node.uniqueID] - || (outerCache[node.uniqueID] = {}); - - cache = uniqueCache[type] - || []; - nodeIndex = cache[0] === dirruns - && cache[1]; - diff = nodeIndex - && cache[2]; - node = nodeIndex - && parent.childNodes[nodeIndex]; - - while ((node = ++nodeIndex - && node - && node[dir] - || - - // Fallback to - // seeking - // `elem` from - // the start - (diff = nodeIndex = 0) - || start.pop())) { - - // When found, cache - // indexes on - // `parent` and - // break - if (node.nodeType === 1 - && ++diff - && node === elem) { - uniqueCache[type] = [ - dirruns, - nodeIndex, - diff ]; - break; - } - } - - } else { - // Use previously-cached - // element index if - // available - if (useCache) { - // ...in a - // gzip-friendly way - node = elem; - outerCache = node[expando] - || (node[expando] = {}); - - // Support: IE <9 - // only - // Defend against - // cloned - // attroperties - // (jQuery gh-1709) - uniqueCache = outerCache[node.uniqueID] - || (outerCache[node.uniqueID] = {}); - - cache = uniqueCache[type] - || []; - nodeIndex = cache[0] === dirruns - && cache[1]; - diff = nodeIndex; - } - - // xml :nth-child(...) - // or - // :nth-last-child(...) - // or - // :nth(-last)?-of-type(...) - if (diff === false) { - // Use the same loop - // as above to seek - // `elem` from the - // start - while ((node = ++nodeIndex - && node - && node[dir] - || (diff = nodeIndex = 0) - || start - .pop())) { - - if ((ofType ? node.nodeName - .toLowerCase() === name - : node.nodeType === 1) - && ++diff) { - - // Cache the - // index of - // each - // encountered - // element - if (useCache) { - outerCache = node[expando] - || (node[expando] = {}); - - // Support: - // IE <9 - // only - // Defend - // against - // cloned - // attroperties - // (jQuery - // gh-1709) - uniqueCache = outerCache[node.uniqueID] - || (outerCache[node.uniqueID] = {}); - - uniqueCache[type] = [ - dirruns, - diff ]; - } - - if (node === elem) { - break; - } - } - } - } - } - - // Incorporate the offset, - // then check against cycle - // size - diff -= last; - return diff === first - || (diff % first === 0 && diff - / first >= 0); - } - }; - }, - - "PSEUDO" : function(pseudo, argument) { - // pseudo-class names are case-insensitive - // http://www.w3.org/TR/selectors/#pseudo-classes - // Prioritize by case sensitivity in case - // custom pseudos are added with uppercase - // letters - // Remember that setFilters inherits from - // pseudos - var args, fn = Expr.pseudos[pseudo] - || Expr.setFilters[pseudo - .toLowerCase()] - || Sizzle - .error("unsupported pseudo: " - + pseudo); - - // The user may use createPseudo to indicate - // that - // arguments are needed to create the filter - // function - // just as Sizzle does - if (fn[expando]) { - return fn(argument); - } - - // But maintain support for old signatures - if (fn.length > 1) { - args = [ pseudo, pseudo, "", argument ]; - return Expr.setFilters - .hasOwnProperty(pseudo - .toLowerCase()) ? markFunction(function( - seed, matches) { - var idx, matched = fn(seed, - argument), i = matched.length; - while (i--) { - idx = indexOf(seed, matched[i]); - seed[idx] = !(matches[idx] = matched[i]); - } - }) - : function(elem) { - return fn(elem, 0, args); - }; - } - - return fn; - } - }, - - pseudos : { - // Potentially complex pseudos - "not" : markFunction(function(selector) { - // Trim the selector passed to compile - // to avoid treating leading and trailing - // spaces as combinators - var input = [], results = [], matcher = compile(selector - .replace(rtrim, "$1")); - - return matcher[expando] ? markFunction(function( - seed, matches, context, xml) { - var elem, unmatched = matcher(seed, - null, xml, []), i = seed.length; - - // Match elements unmatched by `matcher` - while (i--) { - if ((elem = unmatched[i])) { - seed[i] = !(matches[i] = elem); - } - } - }) - : function(elem, context, xml) { - input[0] = elem; - matcher(input, null, xml, - results); - // Don't keep the element (issue - // #299) - input[0] = null; - return !results.pop(); - }; - }), - - "has" : markFunction(function(selector) { - return function(elem) { - return Sizzle(selector, elem).length > 0; - }; - }), - - "contains" : markFunction(function(text) { - text = text.replace(runescape, funescape); - return function(elem) { - return (elem.textContent - || elem.innerText || getText(elem)) - .indexOf(text) > -1; - }; - }), - - // "Whether an element is represented by a - // :lang() selector - // is based solely on the element's language - // value - // being equal to the identifier C, - // or beginning with the identifier C - // immediately followed by "-". - // The matching of C against the element's - // language value is performed - // case-insensitively. - // The identifier C does not have to be a valid - // language name." - // http://www.w3.org/TR/selectors/#lang-pseudo - "lang" : markFunction(function(lang) { - // lang value must be a valid identifier - if (!ridentifier.test(lang || "")) { - Sizzle.error("unsupported lang: " - + lang); - } - lang = lang.replace(runescape, funescape) - .toLowerCase(); - return function(elem) { - var elemLang; - do { - if ((elemLang = documentIsHTML ? elem.lang - : elem - .getAttribute("xml:lang") - || elem - .getAttribute("lang"))) { - - elemLang = elemLang - .toLowerCase(); - return elemLang === lang - || elemLang - .indexOf(lang - + "-") === 0; - } - } while ((elem = elem.parentNode) - && elem.nodeType === 1); - return false; - }; - }), - - // Miscellaneous - "target" : function(elem) { - var hash = window.location - && window.location.hash; - return hash && hash.slice(1) === elem.id; - }, - - "root" : function(elem) { - return elem === docElem; - }, - - "focus" : function(elem) { - return elem === document.activeElement - && (!document.hasFocus || document - .hasFocus()) - && !!(elem.type || elem.href || ~elem.tabIndex); - }, - - // Boolean properties - "enabled" : function(elem) { - return elem.disabled === false; - }, - - "disabled" : function(elem) { - return elem.disabled === true; - }, - - "checked" : function(elem) { - // In CSS3, :checked should return both - // checked and selected elements - // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked - var nodeName = elem.nodeName.toLowerCase(); - return (nodeName === "input" && !!elem.checked) - || (nodeName === "option" && !!elem.selected); - }, - - "selected" : function(elem) { - // Accessing this property makes - // selected-by-default - // options in Safari work properly - if (elem.parentNode) { - elem.parentNode.selectedIndex; - } - - return elem.selected === true; - }, - - // Contents - "empty" : function(elem) { - // http://www.w3.org/TR/selectors/#empty-pseudo - // :empty is negated by element (1) or - // content nodes (text: 3; cdata: 4; entity - // ref: 5), - // but not by others (comment: 8; processing - // instruction: 7; etc.) - // nodeType < 6 works because attributes (2) - // do not appear as children - for (elem = elem.firstChild; elem; elem = elem.nextSibling) { - if (elem.nodeType < 6) { - return false; - } - } - return true; - }, - - "parent" : function(elem) { - return !Expr.pseudos["empty"](elem); - }, - - // Element/input types - "header" : function(elem) { - return rheader.test(elem.nodeName); - }, - - "input" : function(elem) { - return rinputs.test(elem.nodeName); - }, - - "button" : function(elem) { - var name = elem.nodeName.toLowerCase(); - return name === "input" - && elem.type === "button" - || name === "button"; - }, - - "text" : function(elem) { - var attr; - return elem.nodeName.toLowerCase() === "input" - && elem.type === "text" - && - - // Support: IE<8 - // New HTML5 attribute values (e.g., - // "search") appear with elem.type - // === "text" - ((attr = elem.getAttribute("type")) == null || attr - .toLowerCase() === "text"); - }, - - // Position-in-collection - "first" : createPositionalPseudo(function() { - return [ 0 ]; - }), - - "last" : createPositionalPseudo(function( - matchIndexes, length) { - return [ length - 1 ]; - }), - - "eq" : createPositionalPseudo(function( - matchIndexes, length, argument) { - return [ argument < 0 ? argument + length - : argument ]; - }), - - "even" : createPositionalPseudo(function( - matchIndexes, length) { - var i = 0; - for (; i < length; i += 2) { - matchIndexes.push(i); - } - return matchIndexes; - }), - - "odd" : createPositionalPseudo(function( - matchIndexes, length) { - var i = 1; - for (; i < length; i += 2) { - matchIndexes.push(i); - } - return matchIndexes; - }), - - "lt" : createPositionalPseudo(function( - matchIndexes, length, argument) { - var i = argument < 0 ? argument + length - : argument; - for (; --i >= 0;) { - matchIndexes.push(i); - } - return matchIndexes; - }), - - "gt" : createPositionalPseudo(function( - matchIndexes, length, argument) { - var i = argument < 0 ? argument + length - : argument; - for (; ++i < length;) { - matchIndexes.push(i); - } - return matchIndexes; - }) - } - }; - - Expr.pseudos["nth"] = Expr.pseudos["eq"]; - - // Add button/input type pseudos - for (i in { - radio : true, - checkbox : true, - file : true, - password : true, - image : true - }) { - Expr.pseudos[i] = createInputPseudo(i); - } - for (i in { - submit : true, - reset : true - }) { - Expr.pseudos[i] = createButtonPseudo(i); - } - - // Easy API for creating new setFilters - function setFilters() { - } - setFilters.prototype = Expr.filters = Expr.pseudos; - Expr.setFilters = new setFilters(); - - tokenize = Sizzle.tokenize = function(selector, - parseOnly) { - var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector - + " "]; - - if (cached) { - return parseOnly ? 0 : cached.slice(0); - } - - soFar = selector; - groups = []; - preFilters = Expr.preFilter; - - while (soFar) { - - // Comma and first run - if (!matched || (match = rcomma.exec(soFar))) { - if (match) { - // Don't consume trailing commas as - // valid - soFar = soFar.slice(match[0].length) - || soFar; - } - groups.push((tokens = [])); - } - - matched = false; - - // Combinators - if ((match = rcombinators.exec(soFar))) { - matched = match.shift(); - tokens.push({ - value : matched, - // Cast descendant combinators to space - type : match[0].replace(rtrim, " ") - }); - soFar = soFar.slice(matched.length); - } - - // Filters - for (type in Expr.filter) { - if ((match = matchExpr[type].exec(soFar)) - && (!preFilters[type] || (match = preFilters[type] - (match)))) { - matched = match.shift(); - tokens.push({ - value : matched, - type : type, - matches : match - }); - soFar = soFar.slice(matched.length); - } - } - - if (!matched) { - break; - } - } - - // Return the length of the invalid excess - // if we're just parsing - // Otherwise, throw an error or return tokens - return parseOnly ? soFar.length : soFar ? Sizzle - .error(selector) : - // Cache the tokens - tokenCache(selector, groups).slice(0); - }; - - function toSelector(tokens) { - var i = 0, len = tokens.length, selector = ""; - for (; i < len; i++) { - selector += tokens[i].value; - } - return selector; - } - - function addCombinator(matcher, combinator, base) { - var dir = combinator.dir, checkNonElements = base - && dir === "parentNode", doneName = done++; - - return combinator.first ? - // Check against closest ancestor/preceding element - function(elem, context, xml) { - while ((elem = elem[dir])) { - if (elem.nodeType === 1 || checkNonElements) { - return matcher(elem, context, xml); - } - } - } - : - - // Check against all ancestor/preceding - // elements - function(elem, context, xml) { - var oldCache, uniqueCache, outerCache, newCache = [ - dirruns, doneName ]; - - // We can't set arbitrary data on XML - // nodes, so they don't benefit from - // combinator caching - if (xml) { - while ((elem = elem[dir])) { - if (elem.nodeType === 1 - || checkNonElements) { - if (matcher(elem, context, - xml)) { - return true; - } - } - } - } else { - while ((elem = elem[dir])) { - if (elem.nodeType === 1 - || checkNonElements) { - outerCache = elem[expando] - || (elem[expando] = {}); - - // Support: IE <9 only - // Defend against cloned - // attroperties (jQuery - // gh-1709) - uniqueCache = outerCache[elem.uniqueID] - || (outerCache[elem.uniqueID] = {}); - - if ((oldCache = uniqueCache[dir]) - && oldCache[0] === dirruns - && oldCache[1] === doneName) { - - // Assign to newCache so - // results - // back-propagate to - // previous elements - return (newCache[2] = oldCache[2]); - } else { - // Reuse newcache so - // results - // back-propagate to - // previous elements - uniqueCache[dir] = newCache; - - // A match means we're - // done; a fail means we - // have to keep checking - if ((newCache[2] = matcher( - elem, context, - xml))) { - return true; - } - } - } - } - } - }; - } - - function elementMatcher(matchers) { - return matchers.length > 1 ? function(elem, - context, xml) { - var i = matchers.length; - while (i--) { - if (!matchers[i](elem, context, xml)) { - return false; - } - } - return true; - } : matchers[0]; - } - - function multipleContexts(selector, contexts, results) { - var i = 0, len = contexts.length; - for (; i < len; i++) { - Sizzle(selector, contexts[i], results); - } - return results; - } - - function condense(unmatched, map, filter, context, xml) { - var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; - - for (; i < len; i++) { - if ((elem = unmatched[i])) { - if (!filter || filter(elem, context, xml)) { - newUnmatched.push(elem); - if (mapped) { - map.push(i); - } - } - } - } - - return newUnmatched; - } - - function setMatcher(preFilter, selector, matcher, - postFilter, postFinder, postSelector) { - if (postFilter && !postFilter[expando]) { - postFilter = setMatcher(postFilter); - } - if (postFinder && !postFinder[expando]) { - postFinder = setMatcher(postFinder, - postSelector); - } - return markFunction(function(seed, results, - context, xml) { - var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, - - // Get initial elements from seed or context - elems = seed - || multipleContexts(selector || "*", - context.nodeType ? [ context ] - : context, []), - - // Prefilter to get matcher input, preserving a - // map for seed-results synchronization - matcherIn = preFilter && (seed || !selector) ? condense( - elems, preMap, preFilter, context, xml) - : elems, - - matcherOut = matcher ? - // If we have a postFinder, or filtered seed, or - // non-seed postFilter or preexisting results, - postFinder - || (seed ? preFilter : preexisting - || postFilter) ? - - // ...intermediate processing is necessary - [] : - - // ...otherwise use results directly - results : matcherIn; - - // Find primary matches - if (matcher) { - matcher(matcherIn, matcherOut, context, xml); - } - - // Apply postFilter - if (postFilter) { - temp = condense(matcherOut, postMap); - postFilter(temp, [], context, xml); - - // Un-match failing elements by moving them - // back to matcherIn - i = temp.length; - while (i--) { - if ((elem = temp[i])) { - matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem); - } - } - } - - if (seed) { - if (postFinder || preFilter) { - if (postFinder) { - // Get the final matcherOut by - // condensing this intermediate into - // postFinder contexts - temp = []; - i = matcherOut.length; - while (i--) { - if ((elem = matcherOut[i])) { - // Restore matcherIn since - // elem is not yet a final - // match - temp - .push((matcherIn[i] = elem)); - } - } - postFinder(null, (matcherOut = []), - temp, xml); - } - - // Move matched elements from seed to - // results to keep them synchronized - i = matcherOut.length; - while (i--) { - if ((elem = matcherOut[i]) - && (temp = postFinder ? indexOf( - seed, elem) - : preMap[i]) > -1) { - - seed[temp] = !(results[temp] = elem); - } - } - } - - // Add elements to results, through - // postFinder if defined - } else { - matcherOut = condense(matcherOut === results ? matcherOut - .splice(preexisting, - matcherOut.length) - : matcherOut); - if (postFinder) { - postFinder(null, results, matcherOut, - xml); - } else { - push.apply(results, matcherOut); - } - } - }); - } - - function matcherFromTokens(tokens) { - var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative - || Expr.relative[" "], i = leadingRelative ? 1 - : 0, - - // The foundational matcher ensures that elements - // are reachable from top-level context(s) - matchContext = addCombinator(function(elem) { - return elem === checkContext; - }, implicitRelative, true), matchAnyContext = addCombinator( - function(elem) { - return indexOf(checkContext, elem) > -1; - }, implicitRelative, true), matchers = [ function( - elem, context, xml) { - var ret = (!leadingRelative && (xml || context !== outermostContext)) - || ((checkContext = context).nodeType ? matchContext( - elem, context, xml) - : matchAnyContext(elem, - context, xml)); - // Avoid hanging onto element (issue #299) - checkContext = null; - return ret; - } ]; - - for (; i < len; i++) { - if ((matcher = Expr.relative[tokens[i].type])) { - matchers = [ addCombinator( - elementMatcher(matchers), matcher) ]; - } else { - matcher = Expr.filter[tokens[i].type] - .apply(null, tokens[i].matches); - - // Return special upon seeing a positional - // matcher - if (matcher[expando]) { - // Find the next relative operator (if - // any) for proper handling - j = ++i; - for (; j < len; j++) { - if (Expr.relative[tokens[j].type]) { - break; - } - } - return setMatcher( - i > 1 - && elementMatcher(matchers), - i > 1 - && toSelector( - // If the - // preceding - // token was a - // descendant - // combinator, - // insert an - // implicit - // any-element - // `*` - tokens - .slice( - 0, - i - 1) - .concat( - { - value : tokens[i - 2].type === " " ? "*" - : "" - })) - .replace(rtrim, - "$1"), - matcher, - i < j - && matcherFromTokens(tokens - .slice(i, j)), - j < len - && matcherFromTokens((tokens = tokens - .slice(j))), - j < len && toSelector(tokens)); - } - matchers.push(matcher); - } - } - - return elementMatcher(matchers); - } - - function matcherFromGroupMatchers(elementMatchers, - setMatchers) { - var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( - seed, context, xml, results, outermost) { - var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed - && [], setMatched = [], contextBackup = outermostContext, - // We must always have either seed elements or - // outermost context - elems = seed || byElement - && Expr.find["TAG"]("*", outermost), - // Use integer dirruns iff this is the outermost - // matcher - dirrunsUnique = (dirruns += contextBackup == null ? 1 - : Math.random() || 0.1), len = elems.length; - - if (outermost) { - outermostContext = context === document - || context || outermost; - } - - // Add elements passing elementMatchers directly - // to results - // Support: IE<9, Safari - // Tolerate NodeList properties (IE: "length"; - // Safari: <number>) matching elements by id - for (; i !== len && (elem = elems[i]) != null; i++) { - if (byElement && elem) { - j = 0; - if (!context - && elem.ownerDocument !== document) { - setDocument(elem); - xml = !documentIsHTML; - } - while ((matcher = elementMatchers[j++])) { - if (matcher(elem, context - || document, xml)) { - results.push(elem); - break; - } - } - if (outermost) { - dirruns = dirrunsUnique; - } - } - - // Track unmatched elements for set filters - if (bySet) { - // They will have gone through all - // possible matchers - if ((elem = !matcher && elem)) { - matchedCount--; - } - - // Lengthen the array for every element, - // matched or not - if (seed) { - unmatched.push(elem); - } - } - } - - // `i` is now the count of elements visited - // above, and adding it to `matchedCount` - // makes the latter nonnegative. - matchedCount += i; - - // Apply set filters to unmatched elements - // NOTE: This can be skipped if there are no - // unmatched elements (i.e., `matchedCount` - // equals `i`), unless we didn't visit _any_ - // elements in the above loop because we have - // no element matchers and no seed. - // Incrementing an initially-string "0" `i` - // allows `i` to remain a string only in that - // case, which will result in a "00" - // `matchedCount` that differs from `i` but is - // also - // numerically zero. - if (bySet && i !== matchedCount) { - j = 0; - while ((matcher = setMatchers[j++])) { - matcher(unmatched, setMatched, context, - xml); - } - - if (seed) { - // Reintegrate element matches to - // eliminate the need for sorting - if (matchedCount > 0) { - while (i--) { - if (!(unmatched[i] || setMatched[i])) { - setMatched[i] = pop - .call(results); - } - } - } - - // Discard index placeholder values to - // get only actual matches - setMatched = condense(setMatched); - } - - // Add matches to results - push.apply(results, setMatched); - - // Seedless set matches succeeding multiple - // successful matchers stipulate sorting - if (outermost - && !seed - && setMatched.length > 0 - && (matchedCount + setMatchers.length) > 1) { - - Sizzle.uniqueSort(results); - } - } - - // Override manipulation of globals by nested - // matchers - if (outermost) { - dirruns = dirrunsUnique; - outermostContext = contextBackup; - } - - return unmatched; - }; - - return bySet ? markFunction(superMatcher) - : superMatcher; - } - - compile = Sizzle.compile = function(selector, match /* - * Internal - * Use - * Only - */) { - var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector - + " "]; - - if (!cached) { - // Generate a function of recursive functions - // that can be used to check each element - if (!match) { - match = tokenize(selector); - } - i = match.length; - while (i--) { - cached = matcherFromTokens(match[i]); - if (cached[expando]) { - setMatchers.push(cached); - } else { - elementMatchers.push(cached); - } - } - - // Cache the compiled function - cached = compilerCache(selector, - matcherFromGroupMatchers( - elementMatchers, setMatchers)); - - // Save selector and tokenization - cached.selector = selector; - } - return cached; - }; - - /** - * A low-level selection function that works with - * Sizzle's compiled selector functions - * - * @param {String|Function} - * selector A selector or a pre-compiled - * selector function built with - * Sizzle.compile - * @param {Element} - * context - * @param {Array} - * [results] - * @param {Array} - * [seed] A set of elements to match against - */ - select = Sizzle.select = function(selector, context, - results, seed) { - var i, tokens, token, type, find, compiled = typeof selector === "function" - && selector, match = !seed - && tokenize((selector = compiled.selector - || selector)); - - results = results || []; - - // Try to minimize operations if there is only one - // selector in the list and no seed - // (the latter of which guarantees us context) - if (match.length === 1) { - - // Reduce context if the leading compound - // selector is an ID - tokens = match[0] = match[0].slice(0); - if (tokens.length > 2 - && (token = tokens[0]).type === "ID" - && support.getById - && context.nodeType === 9 - && documentIsHTML - && Expr.relative[tokens[1].type]) { - - context = (Expr.find["ID"](token.matches[0] - .replace(runescape, funescape), - context) || [])[0]; - if (!context) { - return results; - - // Precompiled matchers will still - // verify ancestry, so step up a level - } else if (compiled) { - context = context.parentNode; - } - - selector = selector - .slice(tokens.shift().value.length); - } - - // Fetch a seed set for right-to-left matching - i = matchExpr["needsContext"].test(selector) ? 0 - : tokens.length; - while (i--) { - token = tokens[i]; - - // Abort if we hit a combinator - if (Expr.relative[(type = token.type)]) { - break; - } - if ((find = Expr.find[type])) { - // Search, expanding context for leading - // sibling combinators - if ((seed = find( - token.matches[0].replace( - runescape, funescape), - rsibling.test(tokens[0].type) - && testContext(context.parentNode) - || context))) { - - // If seed is empty or no tokens - // remain, we can return early - tokens.splice(i, 1); - selector = seed.length - && toSelector(tokens); - if (!selector) { - push.apply(results, seed); - return results; - } - - break; - } - } - } - } - - // Compile and execute a filtering function if one - // is not provided - // Provide `match` to avoid retokenization if we - // modified the selector above - (compiled || compile(selector, match))(seed, - context, !documentIsHTML, results, !context - || rsibling.test(selector) - && testContext(context.parentNode) - || context); - return results; - }; - - // One-time assignments - - // Sort stability - support.sortStable = expando.split("").sort(sortOrder) - .join("") === expando; - - // Support: Chrome 14-35+ - // Always assume duplicates if they aren't passed to the - // comparison function - support.detectDuplicates = !!hasDuplicate; - - // Initialize against the default document - setDocument(); - - // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 - // (fixed in Chrome 27) - // Detached nodes confoundingly follow *each other* - support.sortDetached = assert(function(div1) { - // Should return 1, but returns 4 (following) - return div1.compareDocumentPosition(document - .createElement("div")) & 1; - }); - - // Support: IE<8 - // Prevent attribute/property "interpolation" - // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx - if (!assert(function(div) { - div.innerHTML = "<a href='#'></a>"; - return div.firstChild.getAttribute("href") === "#"; - })) { - addHandle("type|href|height|width", function(elem, - name, isXML) { - if (!isXML) { - return elem.getAttribute(name, name - .toLowerCase() === "type" ? 1 : 2); - } - }); - } - - // Support: IE<9 - // Use defaultValue in place of getAttribute("value") - if (!support.attributes || !assert(function(div) { - div.innerHTML = "<input/>"; - div.firstChild.setAttribute("value", ""); - return div.firstChild.getAttribute("value") === ""; - })) { - addHandle( - "value", - function(elem, name, isXML) { - if (!isXML - && elem.nodeName.toLowerCase() === "input") { - return elem.defaultValue; - } - }); - } - - // Support: IE<9 - // Use getAttributeNode to fetch booleans when - // getAttribute lies - if (!assert(function(div) { - return div.getAttribute("disabled") == null; - })) { - addHandle( - booleans, - function(elem, name, isXML) { - var val; - if (!isXML) { - return elem[name] === true ? name - .toLowerCase() - : (val = elem - .getAttributeNode(name)) - && val.specified ? val.value - : null; - } - }); - } - - return Sizzle; - - })(window); - - jQuery.find = Sizzle; - jQuery.expr = Sizzle.selectors; - jQuery.expr[":"] = jQuery.expr.pseudos; - jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; - jQuery.text = Sizzle.getText; - jQuery.isXMLDoc = Sizzle.isXML; - jQuery.contains = Sizzle.contains; - - var dir = function(elem, dir, until) { - var matched = [], truncate = until !== undefined; - - while ((elem = elem[dir]) && elem.nodeType !== 9) { - if (elem.nodeType === 1) { - if (truncate && jQuery(elem).is(until)) { - break; - } - matched.push(elem); - } - } - return matched; - }; - - var siblings = function(n, elem) { - var matched = []; - - for (; n; n = n.nextSibling) { - if (n.nodeType === 1 && n !== elem) { - matched.push(n); - } - } - - return matched; - }; - - var rneedsContext = jQuery.expr.match.needsContext; - - var rsingleTag = (/^<([\w-]+)\s*\/?>(?:<\/\1>|)$/); - - var risSimple = /^.[^:#\[\.,]*$/; - - // Implement the identical functionality for filter and not - function winnow(elements, qualifier, not) { - if (jQuery.isFunction(qualifier)) { - return jQuery.grep(elements, function(elem, i) { - /* jshint -W018 */ - return !!qualifier.call(elem, i, elem) !== not; - }); - - } - - if (qualifier.nodeType) { - return jQuery.grep(elements, function(elem) { - return (elem === qualifier) !== not; - }); - - } - - if (typeof qualifier === "string") { - if (risSimple.test(qualifier)) { - return jQuery.filter(qualifier, elements, not); - } - - qualifier = jQuery.filter(qualifier, elements); - } - - return jQuery - .grep(elements, - function(elem) { - return (jQuery.inArray(elem, - qualifier) > -1) !== not; - }); - } - - jQuery.filter = function(expr, elems, not) { - var elem = elems[0]; - - if (not) { - expr = ":not(" + expr + ")"; - } - - return elems.length === 1 && elem.nodeType === 1 ? jQuery.find - .matchesSelector(elem, expr) ? [ elem ] : [] - : jQuery.find.matches(expr, jQuery.grep(elems, - function(elem) { - return elem.nodeType === 1; - })); - }; - - jQuery.fn - .extend({ - find : function(selector) { - var i, ret = [], self = this, len = self.length; - - if (typeof selector !== "string") { - return this - .pushStack(jQuery(selector) - .filter( - function() { - for (i = 0; i < len; i++) { - if (jQuery - .contains( - self[i], - this)) { - return true; - } - } - })); - } - - for (i = 0; i < len; i++) { - jQuery.find(selector, self[i], ret); - } - - // Needed because $( selector, context ) - // becomes $( context ).find( selector ) - ret = this.pushStack(len > 1 ? jQuery - .unique(ret) : ret); - ret.selector = this.selector ? this.selector - + " " + selector - : selector; - return ret; - }, - filter : function(selector) { - return this.pushStack(winnow(this, selector - || [], false)); - }, - not : function(selector) { - return this.pushStack(winnow(this, selector - || [], true)); - }, - is : function(selector) { - return !!winnow( - this, - - // If this is a positional/relative - // selector, check membership in the - // returned set - // so $("p:first").is("p:last") - // won't return true for a doc with - // two "p". - typeof selector === "string" - && rneedsContext - .test(selector) ? jQuery(selector) - : selector || [], false).length; - } - }); - - // Initialize a jQuery object - - // A central reference to the root jQuery(document) - var rootjQuery, - - // A simple way to check for HTML strings - // Prioritize #id over <tag> to avoid XSS via location.hash - // (#9521) - // Strict HTML recognition (#11290: must start with <) - rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, - - init = jQuery.fn.init = function(selector, context, root) { - var match, elem; - - // HANDLE: $(""), $(null), $(undefined), $(false) - if (!selector) { - return this; - } - - // init accepts an alternate rootjQuery - // so migrate can support jQuery.sub (gh-2101) - root = root || rootjQuery; - - // Handle HTML strings - if (typeof selector === "string") { - if (selector.charAt(0) === "<" - && selector.charAt(selector.length - 1) === ">" - && selector.length >= 3) { - - // Assume that strings that start and end with - // <> are HTML and skip the regex check - match = [ null, selector, null ]; - - } else { - match = rquickExpr.exec(selector); - } - - // Match html or make sure no context is specified - // for #id - if (match && (match[1] || !context)) { - - // HANDLE: $(html) -> $(array) - if (match[1]) { - context = context instanceof jQuery ? context[0] - : context; - - // scripts is true for back-compat - // Intentionally let the error be thrown if - // parseHTML is not present - jQuery - .merge( - this, - jQuery - .parseHTML( - match[1], - context - && context.nodeType ? context.ownerDocument - || context - : document, - true)); - - // HANDLE: $(html, props) - if (rsingleTag.test(match[1]) - && jQuery.isPlainObject(context)) { - for (match in context) { - - // Properties of context are called - // as methods if possible - if (jQuery.isFunction(this[match])) { - this[match](context[match]); - - // ...and otherwise set as - // attributes - } else { - this - .attr(match, - context[match]); - } - } - } - - return this; - - // HANDLE: $(#id) - } else { - elem = document.getElementById(match[2]); - - // Check parentNode to catch when Blackberry - // 4.6 returns - // nodes that are no longer in the document - // #6963 - if (elem && elem.parentNode) { - - // Handle the case where IE and Opera - // return items - // by name instead of ID - if (elem.id !== match[2]) { - return rootjQuery.find(selector); - } - - // Otherwise, we inject the element - // directly into the jQuery object - this.length = 1; - this[0] = elem; - } - - this.context = document; - this.selector = selector; - return this; - } - - // HANDLE: $(expr, $(...)) - } else if (!context || context.jquery) { - return (context || root).find(selector); - - // HANDLE: $(expr, context) - // (which is just equivalent to: - // $(context).find(expr) - } else { - return this.constructor(context).find(selector); - } - - // HANDLE: $(DOMElement) - } else if (selector.nodeType) { - this.context = this[0] = selector; - this.length = 1; - return this; - - // HANDLE: $(function) - // Shortcut for document ready - } else if (jQuery.isFunction(selector)) { - return typeof root.ready !== "undefined" ? root - .ready(selector) : - - // Execute immediately if ready is not present - selector(jQuery); - } - - if (selector.selector !== undefined) { - this.selector = selector.selector; - this.context = selector.context; - } - - return jQuery.makeArray(selector, this); - }; - - // Give the init function the jQuery prototype for later - // instantiation - init.prototype = jQuery.fn; - - // Initialize central reference - rootjQuery = jQuery(document); - - var rparentsprev = /^(?:parents|prev(?:Until|All))/, - - // methods guaranteed to produce a unique set when starting - // from a unique set - guaranteedUnique = { - children : true, - contents : true, - next : true, - prev : true - }; - - jQuery.fn - .extend({ - has : function(target) { - var i, targets = jQuery(target, this), len = targets.length; - - return this.filter(function() { - for (i = 0; i < len; i++) { - if (jQuery.contains(this, - targets[i])) { - return true; - } - } - }); - }, - - closest : function(selectors, context) { - var cur, i = 0, l = this.length, matched = [], pos = rneedsContext - .test(selectors) - || typeof selectors !== "string" ? jQuery( - selectors, context || this.context) - : 0; - - for (; i < l; i++) { - for (cur = this[i]; cur - && cur !== context; cur = cur.parentNode) { - - // Always skip document fragments - if (cur.nodeType < 11 - && (pos ? pos.index(cur) > -1 - : - - // Don't pass - // non-elements to - // Sizzle - cur.nodeType === 1 - && jQuery.find - .matchesSelector( - cur, - selectors))) { - - matched.push(cur); - break; - } - } - } - - return this - .pushStack(matched.length > 1 ? jQuery - .uniqueSort(matched) - : matched); - }, - - // Determine the position of an element within - // the matched set of elements - index : function(elem) { - - // No argument, return index in parent - if (!elem) { - return (this[0] && this[0].parentNode) ? this - .first().prevAll().length - : -1; - } - - // index in selector - if (typeof elem === "string") { - return jQuery.inArray(this[0], - jQuery(elem)); - } - - // Locate the position of the desired - // element - return jQuery.inArray( - - // If it receives a jQuery object, the first - // element is used - elem.jquery ? elem[0] : elem, this); - }, - - add : function(selector, context) { - return this - .pushStack(jQuery - .uniqueSort(jQuery.merge( - this.get(), jQuery( - selector, - context)))); - }, - - addBack : function(selector) { - return this - .add(selector == null ? this.prevObject - : this.prevObject - .filter(selector)); - } - }); - - function sibling(cur, dir) { - do { - cur = cur[dir]; - } while (cur && cur.nodeType !== 1); - - return cur; - } - - jQuery - .each( - { - parent : function(elem) { - var parent = elem.parentNode; - return parent - && parent.nodeType !== 11 ? parent - : null; - }, - parents : function(elem) { - return dir(elem, "parentNode"); - }, - parentsUntil : function(elem, i, until) { - return dir(elem, "parentNode", - until); - }, - next : function(elem) { - return sibling(elem, "nextSibling"); - }, - prev : function(elem) { - return sibling(elem, - "previousSibling"); - }, - nextAll : function(elem) { - return dir(elem, "nextSibling"); - }, - prevAll : function(elem) { - return dir(elem, "previousSibling"); - }, - nextUntil : function(elem, i, until) { - return dir(elem, "nextSibling", - until); - }, - prevUntil : function(elem, i, until) { - return dir(elem, "previousSibling", - until); - }, - siblings : function(elem) { - return siblings( - (elem.parentNode || {}).firstChild, - elem); - }, - children : function(elem) { - return siblings(elem.firstChild); - }, - contents : function(elem) { - return jQuery.nodeName(elem, - "iframe") ? elem.contentDocument - || elem.contentWindow.document - : jQuery.merge([], - elem.childNodes); - } - }, - function(name, fn) { - jQuery.fn[name] = function(until, - selector) { - var ret = jQuery.map(this, fn, - until); - - if (name.slice(-5) !== "Until") { - selector = until; - } - - if (selector - && typeof selector === "string") { - ret = jQuery.filter(selector, - ret); - } - - if (this.length > 1) { - - // Remove duplicates - if (!guaranteedUnique[name]) { - ret = jQuery - .uniqueSort(ret); - } - - // Reverse order for parents* - // and prev-derivatives - if (rparentsprev.test(name)) { - ret = ret.reverse(); - } - } - - return this.pushStack(ret); - }; - }); - var rnotwhite = (/\S+/g); - - // Convert String-formatted options into Object-formatted - // ones - function createOptions(options) { - var object = {}; - jQuery.each(options.match(rnotwhite) || [], function(_, - flag) { - object[flag] = true; - }); - return object; - } - - /* - * Create a callback list using the following parameters: - * - * options: an optional list of space-separated options that - * will change how the callback list behaves or a more - * traditional option object - * - * By default a callback list will act like an event - * callback list and can be "fired" multiple times. - * - * Possible options: - * - * once: will ensure the callback list can only be fired - * once (like a Deferred) - * - * memory: will keep track of previous values and will call - * any callback added after the list has been fired right - * away with the latest "memorized" values (like a Deferred) - * - * unique: will ensure a callback can only be added once (no - * duplicate in the list) - * - * stopOnFalse: interrupt callings when a callback returns - * false - * - */ - jQuery.Callbacks = function(options) { - - // Convert options from String-formatted to - // Object-formatted if needed - // (we check in cache first) - options = typeof options === "string" ? createOptions(options) - : jQuery.extend({}, options); - - var // Flag to know if list is currently firing - firing, - - // Last fire value for non-forgettable lists - memory, - - // Flag to know if list was already fired - fired, - - // Flag to prevent firing - locked, - - // Actual callback list - list = [], - - // Queue of execution data for repeatable lists - queue = [], - - // Index of currently firing callback (modified by - // add/remove as needed) - firingIndex = -1, - - // Fire callbacks - fire = function() { - - // Enforce single-firing - locked = options.once; - - // Execute callbacks for all pending executions, - // respecting firingIndex overrides and runtime - // changes - fired = firing = true; - for (; queue.length; firingIndex = -1) { - memory = queue.shift(); - while (++firingIndex < list.length) { - - // Run callback and check for early - // termination - if (list[firingIndex].apply(memory[0], - memory[1]) === false - && options.stopOnFalse) { - - // Jump to end and forget the data so - // .add doesn't re-fire - firingIndex = list.length; - memory = false; - } - } - } - - // Forget the data if we're done with it - if (!options.memory) { - memory = false; - } - - firing = false; - - // Clean up if we're done firing for good - if (locked) { - - // Keep an empty list if we have data for future - // add calls - if (memory) { - list = []; - - // Otherwise, this object is spent - } else { - list = ""; - } - } - }, - - // Actual Callbacks object - self = { - - // Add a callback or a collection of callbacks to - // the list - add : function() { - if (list) { - - // If we have memory from a past run, we - // should fire after adding - if (memory && !firing) { - firingIndex = list.length - 1; - queue.push(memory); - } - - (function add(args) { - jQuery - .each( - args, - function(_, arg) { - if (jQuery - .isFunction(arg)) { - if (!options.unique - || !self - .has(arg)) { - list - .push(arg); - } - } else if (arg - && arg.length - && jQuery - .type(arg) !== "string") { - - // Inspect - // recursively - add(arg); - } - }); - })(arguments); - - if (memory && !firing) { - fire(); - } - } - return this; - }, - - // Remove a callback from the list - remove : function() { - jQuery.each(arguments, function(_, arg) { - var index; - while ((index = jQuery.inArray(arg, list, - index)) > -1) { - list.splice(index, 1); - - // Handle firing indexes - if (index <= firingIndex) { - firingIndex--; - } - } - }); - return this; - }, - - // Check if a given callback is in the list. - // If no argument is given, return whether or not - // list has callbacks attached. - has : function(fn) { - return fn ? jQuery.inArray(fn, list) > -1 - : list.length > 0; - }, - - // Remove all callbacks from the list - empty : function() { - if (list) { - list = []; - } - return this; - }, - - // Disable .fire and .add - // Abort any current/pending executions - // Clear all callbacks and values - disable : function() { - locked = queue = []; - list = memory = ""; - return this; - }, - disabled : function() { - return !list; - }, - - // Disable .fire - // Also disable .add unless we have memory (since it - // would have no effect) - // Abort any pending executions - lock : function() { - locked = true; - if (!memory) { - self.disable(); - } - return this; - }, - locked : function() { - return !!locked; - }, - - // Call all callbacks with the given context and - // arguments - fireWith : function(context, args) { - if (!locked) { - args = args || []; - args = [ context, - args.slice ? args.slice() : args ]; - queue.push(args); - if (!firing) { - fire(); - } - } - return this; - }, - - // Call all the callbacks with the given arguments - fire : function() { - self.fireWith(this, arguments); - return this; - }, - - // To know if the callbacks have already been called - // at least once - fired : function() { - return !!fired; - } - }; - - return self; - }; - - jQuery - .extend({ - - Deferred : function(func) { - var tuples = [ - - // action, add listener, listener - // list, final state - [ - "resolve", - "done", - jQuery - .Callbacks("once memory"), - "resolved" ], - [ - "reject", - "fail", - jQuery - .Callbacks("once memory"), - "rejected" ], - [ "notify", "progress", - jQuery.Callbacks("memory") ] ], state = "pending", promise = { - state : function() { - return state; - }, - always : function() { - deferred.done(arguments).fail( - arguments); - return this; - }, - then : function( /* - * fnDone, fnFail, - * fnProgress - */) { - var fns = arguments; - return jQuery - .Deferred( - function(newDefer) { - jQuery - .each( - tuples, - function( - i, - tuple) { - var fn = jQuery - .isFunction(fns[i]) - && fns[i]; - - // deferred[ - // done - // | - // fail - // | - // progress - // ] - // for - // forwarding - // actions - // to - // newDefer - deferred[tuple[1]] - (function() { - var returned = fn - && fn - .apply( - this, - arguments); - if (returned - && jQuery - .isFunction(returned.promise)) { - returned - .promise() - .progress( - newDefer.notify) - .done( - newDefer.resolve) - .fail( - newDefer.reject); - } else { - newDefer[tuple[0] - + "With"] - ( - this === promise ? newDefer - .promise() - : this, - fn ? [ returned ] - : arguments); - } - }); - }); - fns = null; - }).promise(); - }, - - // Get a promise for this deferred - // If obj is provided, the promise - // aspect is added to the object - promise : function(obj) { - return obj != null ? jQuery.extend( - obj, promise) : promise; - } - }, deferred = {}; - - // Keep pipe for back-compat - promise.pipe = promise.then; - - // Add list-specific methods - jQuery - .each( - tuples, - function(i, tuple) { - var list = tuple[2], stateString = tuple[3]; - - // promise[ done | fail - // | progress ] = - // list.add - promise[tuple[1]] = list.add; - - // Handle state - if (stateString) { - list - .add( - function() { - - // state - // = [ - // resolved - // | - // rejected - // ] - state = stateString; - - // [ - // reject_list - // | - // resolve_list - // ].disable; - // progress_list.lock - }, - tuples[i ^ 1][2].disable, - tuples[2][2].lock); - } - - // deferred[ resolve | - // reject | notify ] - deferred[tuple[0]] = function() { - deferred[tuple[0] - + "With"] - ( - this === deferred ? promise - : this, - arguments); - return this; - }; - deferred[tuple[0] - + "With"] = list.fireWith; - }); - - // Make the deferred a promise - promise.promise(deferred); - - // Call given func if any - if (func) { - func.call(deferred, deferred); - } - - // All done! - return deferred; - }, - - // Deferred helper - when : function(subordinate /* - * , ..., - * subordinateN - */) { - var i = 0, resolveValues = slice - .call(arguments), length = resolveValues.length, - - // the count of uncompleted subordinates - remaining = length !== 1 - || (subordinate && jQuery - .isFunction(subordinate.promise)) ? length - : 0, - - // the master Deferred. - // If resolveValues consist of only a single - // Deferred, just use that. - deferred = remaining === 1 ? subordinate - : jQuery.Deferred(), - - // Update function for both resolve and - // progress values - updateFunc = function(i, contexts, values) { - return function(value) { - contexts[i] = this; - values[i] = arguments.length > 1 ? slice - .call(arguments) - : value; - if (values === progressValues) { - deferred.notifyWith(contexts, - values); - - } else if (!(--remaining)) { - deferred.resolveWith(contexts, - values); - } - }; - }, - - progressValues, progressContexts, resolveContexts; - - // add listeners to Deferred subordinates; - // treat others as resolved - if (length > 1) { - progressValues = new Array(length); - progressContexts = new Array(length); - resolveContexts = new Array(length); - for (; i < length; i++) { - if (resolveValues[i] - && jQuery - .isFunction(resolveValues[i].promise)) { - resolveValues[i] - .promise() - .progress( - updateFunc( - i, - progressContexts, - progressValues)) - .done( - updateFunc( - i, - resolveContexts, - resolveValues)) - .fail(deferred.reject); - } else { - --remaining; - } - } - } - - // if we're not waiting on anything, resolve - // the master - if (!remaining) { - deferred.resolveWith(resolveContexts, - resolveValues); - } - - return deferred.promise(); - } - }); - - // The deferred used on DOM ready - var readyList; - - jQuery.fn.ready = function(fn) { - - // Add the callback - jQuery.ready.promise().done(fn); - - return this; - }; - - jQuery.extend({ - - // Is the DOM ready to be used? Set to true once it - // occurs. - isReady : false, - - // A counter to track how many items to wait for before - // the ready event fires. See #6781 - readyWait : 1, - - // Hold (or release) the ready event - holdReady : function(hold) { - if (hold) { - jQuery.readyWait++; - } else { - jQuery.ready(true); - } - }, - - // Handle when the DOM is ready - ready : function(wait) { - - // Abort if there are pending holds or we're already - // ready - if (wait === true ? --jQuery.readyWait - : jQuery.isReady) { - return; - } - - // Remember that the DOM is ready - jQuery.isReady = true; - - // If a normal DOM Ready event fired, decrement, and - // wait if need be - if (wait !== true && --jQuery.readyWait > 0) { - return; - } - - // If there are functions bound, to execute - readyList.resolveWith(document, [ jQuery ]); - - // Trigger any bound ready events - if (jQuery.fn.triggerHandler) { - jQuery(document).triggerHandler("ready"); - jQuery(document).off("ready"); - } - } - }); - - /** - * Clean-up method for dom ready events - */ - function detach() { - if (document.addEventListener) { - document.removeEventListener("DOMContentLoaded", - completed); - window.removeEventListener("load", completed); - - } else { - document.detachEvent("onreadystatechange", - completed); - window.detachEvent("onload", completed); - } - } - - /** - * The ready event handler and self cleanup method - */ - function completed() { - - // readyState === "complete" is good enough for us to - // call the dom ready in oldIE - if (document.addEventListener - || window.event.type === "load" - || document.readyState === "complete") { - - detach(); - jQuery.ready(); - } - } - - jQuery.ready.promise = function(obj) { - if (!readyList) { - - readyList = jQuery.Deferred(); - - // Catch cases where $(document).ready() is called - // after the browser event has already occurred. - // Support: IE6-10 - // Older IE sometimes signals "interactive" too soon - if (document.readyState === "complete" - || (document.readyState !== "loading" && !document.documentElement.doScroll)) { - - // Handle it asynchronously to allow scripts the - // opportunity to delay ready - window.setTimeout(jQuery.ready); - - // Standards-based browsers support - // DOMContentLoaded - } else if (document.addEventListener) { - - // Use the handy event callback - document.addEventListener("DOMContentLoaded", - completed); - - // A fallback to window.onload, that will always - // work - window.addEventListener("load", completed); - - // If IE event model is used - } else { - - // Ensure firing before onload, maybe late but - // safe also for iframes - document.attachEvent("onreadystatechange", - completed); - - // A fallback to window.onload, that will always - // work - window.attachEvent("onload", completed); - - // If IE and not a frame - // continually check to see if the document is - // ready - var top = false; - - try { - top = window.frameElement == null - && document.documentElement; - } catch (e) { - } - - if (top && top.doScroll) { - (function doScrollCheck() { - if (!jQuery.isReady) { - - try { - - // Use the trick by Diego Perini - // http://javascript.nwbox.com/IEContentLoaded/ - top.doScroll("left"); - } catch (e) { - return window.setTimeout( - doScrollCheck, 50); - } - - // detach all dom ready events - detach(); - - // and execute any waiting functions - jQuery.ready(); - } - })(); - } - } - } - return readyList.promise(obj); - }; - - // Kick off the DOM ready check even if the user does not - jQuery.ready.promise(); - - // Support: IE<9 - // Iteration over object's inherited properties before its - // own - var i; - for (i in jQuery(support)) { - break; - } - support.ownFirst = i === "0"; - - // Note: most support tests are defined in their respective - // modules. - // false until the test is run - support.inlineBlockNeedsLayout = false; - - // Execute ASAP in case we need to set body.style.zoom - jQuery(function() { - - // Minified: var a,b,c,d - var val, div, body, container; - - body = document.getElementsByTagName("body")[0]; - if (!body || !body.style) { - - // Return for frameset docs that don't have a body - return; - } - - // Setup - div = document.createElement("div"); - container = document.createElement("div"); - container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; - body.appendChild(container).appendChild(div); - - if (typeof div.style.zoom !== "undefined") { - - // Support: IE<8 - // Check if natively block-level elements act like - // inline-block - // elements when setting their display to 'inline' - // and giving - // them layout - div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1"; - - support.inlineBlockNeedsLayout = val = div.offsetWidth === 3; - if (val) { - - // Prevent IE 6 from affecting layout for - // positioned elements #11048 - // Prevent IE from shrinking the body in IE 7 - // mode #12869 - // Support: IE<8 - body.style.zoom = 1; - } - } - - body.removeChild(container); - }); - - (function() { - var div = document.createElement("div"); - - // Support: IE<9 - support.deleteExpando = true; - try { - delete div.test; - } catch (e) { - support.deleteExpando = false; - } - - // Null elements to avoid leaks in IE. - div = null; - })(); - var acceptData = function(elem) { - var noData = jQuery.noData[(elem.nodeName + " ") - .toLowerCase()], nodeType = +elem.nodeType || 1; - - // Do not set data on non-element DOM nodes because it - // will not be cleared (#8335). - return nodeType !== 1 && nodeType !== 9 ? false : - - // Nodes accept data unless otherwise specified; - // rejection can be conditional - !noData || noData !== true - && elem.getAttribute("classid") === noData; - }; - - var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /([A-Z])/g; - - function dataAttr(elem, key, data) { - - // If nothing was found internally, try to fetch any - // data from the HTML5 data-* attribute - if (data === undefined && elem.nodeType === 1) { - - var name = "data-" - + key.replace(rmultiDash, "-$1") - .toLowerCase(); - - data = elem.getAttribute(name); - - if (typeof data === "string") { - try { - data = data === "true" ? true - : data === "false" ? false - : data === "null" ? null - : - - // Only convert to a - // number if it - // doesn't change - // the string - +data + "" === data ? +data - : rbrace - .test(data) ? jQuery - .parseJSON(data) - : data; - } catch (e) { - } - - // Make sure we set the data so it isn't changed - // later - jQuery.data(elem, key, data); - - } else { - data = undefined; - } - } - - return data; - } - - // checks a cache object for emptiness - function isEmptyDataObject(obj) { - var name; - for (name in obj) { - - // if the public data object is empty, the private - // is still empty - if (name === "data" - && jQuery.isEmptyObject(obj[name])) { - continue; - } - if (name !== "toJSON") { - return false; - } - } - - return true; - } - - function internalData(elem, name, data, pvt /* - * Internal Use - * Only - */) { - if (!acceptData(elem)) { - return; - } - - var ret, thisCache, internalKey = jQuery.expando, - - // We have to handle DOM nodes and JS objects - // differently because IE6-7 - // can't GC object references properly across the DOM-JS - // boundary - isNode = elem.nodeType, - - // Only DOM nodes need the global jQuery cache; JS - // object data is - // attached directly to the object so GC can occur - // automatically - cache = isNode ? jQuery.cache : elem, - - // Only defining an ID for JS objects if its cache - // already exists allows - // the code to shortcut on the same path as a DOM node - // with no cache - id = isNode ? elem[internalKey] : elem[internalKey] - && internalKey; - - // Avoid doing any more work than we need to when trying - // to get data on an - // object that has no data at all - if ((!id || !cache[id] || (!pvt && !cache[id].data)) - && data === undefined - && typeof name === "string") { - return; - } - - if (!id) { - - // Only DOM nodes need a new unique ID for each - // element since their data - // ends up in the global cache - if (isNode) { - id = elem[internalKey] = deletedIds.pop() - || jQuery.guid++; - } else { - id = internalKey; - } - } - - if (!cache[id]) { - - // Avoid exposing jQuery metadata on plain JS - // objects when the object - // is serialized using JSON.stringify - cache[id] = isNode ? {} : { - toJSON : jQuery.noop - }; - } - - // An object can be passed to jQuery.data instead of a - // key/value pair; this gets - // shallow copied over onto the existing cache - if (typeof name === "object" - || typeof name === "function") { - if (pvt) { - cache[id] = jQuery.extend(cache[id], name); - } else { - cache[id].data = jQuery.extend(cache[id].data, - name); - } - } - - thisCache = cache[id]; - - // jQuery data() is stored in a separate object inside - // the object's internal data - // cache in order to avoid key collisions between - // internal data and user-defined - // data. - if (!pvt) { - if (!thisCache.data) { - thisCache.data = {}; - } - - thisCache = thisCache.data; - } - - if (data !== undefined) { - thisCache[jQuery.camelCase(name)] = data; - } - - // Check for both converted-to-camel and non-converted - // data property names - // If a data property was specified - if (typeof name === "string") { - - // First Try to find as-is property data - ret = thisCache[name]; - - // Test for null|undefined property data - if (ret == null) { - - // Try to find the camelCased property - ret = thisCache[jQuery.camelCase(name)]; - } - } else { - ret = thisCache; - } - - return ret; - } - - function internalRemoveData(elem, name, pvt) { - if (!acceptData(elem)) { - return; - } - - var thisCache, i, isNode = elem.nodeType, - - // See jQuery.data for more information - cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] - : jQuery.expando; - - // If there is already no cache entry for this object, - // there is no - // purpose in continuing - if (!cache[id]) { - return; - } - - if (name) { - - thisCache = pvt ? cache[id] : cache[id].data; - - if (thisCache) { - - // Support array or space separated string names - // for data keys - if (!jQuery.isArray(name)) { - - // try the string as a key before any - // manipulation - if (name in thisCache) { - name = [ name ]; - } else { - - // split the camel cased version by - // spaces unless a key with the spaces - // exists - name = jQuery.camelCase(name); - if (name in thisCache) { - name = [ name ]; - } else { - name = name.split(" "); - } - } - } else { - - // If "name" is an array of keys... - // When data is initially created, via - // ("key", "val") signature, - // keys will be converted to camelCase. - // Since there is no way to tell _how_ a key - // was added, remove - // both plain key and camelCase key. #12786 - // This will only penalize the array - // argument path. - name = name.concat(jQuery.map(name, - jQuery.camelCase)); - } - - i = name.length; - while (i--) { - delete thisCache[name[i]]; - } - - // If there is no data left in the cache, we - // want to continue - // and let the cache object itself get destroyed - if (pvt ? !isEmptyDataObject(thisCache) - : !jQuery.isEmptyObject(thisCache)) { - return; - } - } - } - - // See jQuery.data for more information - if (!pvt) { - delete cache[id].data; - - // Don't destroy the parent cache unless the - // internal data object - // had been the only thing left in it - if (!isEmptyDataObject(cache[id])) { - return; - } - } - - // Destroy the cache - if (isNode) { - jQuery.cleanData([ elem ], true); - - // Use delete when supported for expandos or `cache` - // is not a window per isWindow (#10080) - /* jshint eqeqeq: false */ - } else if (support.deleteExpando - || cache != cache.window) { - /* jshint eqeqeq: true */ - delete cache[id]; - - // When all else fails, undefined - } else { - cache[id] = undefined; - } - } - - jQuery - .extend({ - cache : {}, - - // The following elements (space-suffixed to - // avoid Object.prototype collisions) - // throw uncatchable exceptions if you attempt - // to set expando properties - noData : { - "applet " : true, - "embed " : true, - - // ...but Flash objects (which have this - // classid) *can* handle expandos - "object " : "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" - }, - - hasData : function(elem) { - elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] - : elem[jQuery.expando]; - return !!elem && !isEmptyDataObject(elem); - }, - - data : function(elem, name, data) { - return internalData(elem, name, data); - }, - - removeData : function(elem, name) { - return internalRemoveData(elem, name); - }, - - // For internal use only. - _data : function(elem, name, data) { - return internalData(elem, name, data, true); - }, - - _removeData : function(elem, name) { - return internalRemoveData(elem, name, true); - } - }); - - jQuery.fn - .extend({ - data : function(key, value) { - var i, name, data, elem = this[0], attrs = elem - && elem.attributes; - - // Special expections of .data basically - // thwart jQuery.access, - // so implement the relevant behavior - // ourselves - - // Gets all values - if (key === undefined) { - if (this.length) { - data = jQuery.data(elem); - - if (elem.nodeType === 1 - && !jQuery._data(elem, - "parsedAttrs")) { - i = attrs.length; - while (i--) { - - // Support: IE11+ - // The attrs elements can be - // null (#14894) - if (attrs[i]) { - name = attrs[i].name; - if (name - .indexOf("data-") === 0) { - name = jQuery - .camelCase(name - .slice(5)); - dataAttr(elem, - name, - data[name]); - } - } - } - jQuery._data(elem, - "parsedAttrs", true); - } - } - - return data; - } - - // Sets multiple values - if (typeof key === "object") { - return this.each(function() { - jQuery.data(this, key); - }); - } - - return arguments.length > 1 ? - - // Sets one value - this.each(function() { - jQuery.data(this, key, value); - }) : - - // Gets one value - // Try to fetch any internally stored data - // first - elem ? dataAttr(elem, key, jQuery.data( - elem, key)) : undefined; - }, - - removeData : function(key) { - return this.each(function() { - jQuery.removeData(this, key); - }); - } - }); - - jQuery - .extend({ - queue : function(elem, type, data) { - var queue; - - if (elem) { - type = (type || "fx") + "queue"; - queue = jQuery._data(elem, type); - - // Speed up dequeue by getting out - // quickly if this is just a lookup - if (data) { - if (!queue || jQuery.isArray(data)) { - queue = jQuery._data(elem, - type, - jQuery.makeArray(data)); - } else { - queue.push(data); - } - } - return queue || []; - } - }, - - dequeue : function(elem, type) { - type = type || "fx"; - - var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue - .shift(), hooks = jQuery - ._queueHooks(elem, type), next = function() { - jQuery.dequeue(elem, type); - }; - - // If the fx queue is dequeued, always - // remove the progress sentinel - if (fn === "inprogress") { - fn = queue.shift(); - startLength--; - } - - if (fn) { - - // Add a progress sentinel to prevent - // the fx queue from being - // automatically dequeued - if (type === "fx") { - queue.unshift("inprogress"); - } - - // clear up the last queue stop function - delete hooks.stop; - fn.call(elem, next, hooks); - } - - if (!startLength && hooks) { - hooks.empty.fire(); - } - }, - - // not intended for public consumption - - // generates a queueHooks object, - // or returns the current one - _queueHooks : function(elem, type) { - var key = type + "queueHooks"; - return jQuery._data(elem, key) - || jQuery - ._data( - elem, - key, - { - empty : jQuery - .Callbacks( - "once memory") - .add( - function() { - jQuery - ._removeData( - elem, - type - + "queue"); - jQuery - ._removeData( - elem, - key); - }) - }); - } - }); - - jQuery.fn - .extend({ - queue : function(type, data) { - var setter = 2; - - if (typeof type !== "string") { - data = type; - type = "fx"; - setter--; - } - - if (arguments.length < setter) { - return jQuery.queue(this[0], type); - } - - return data === undefined ? this - : this - .each(function() { - var queue = jQuery - .queue(this, - type, - data); - - // ensure a hooks for - // this queue - jQuery._queueHooks( - this, type); - - if (type === "fx" - && queue[0] !== "inprogress") { - jQuery.dequeue( - this, type); - } - }); - }, - dequeue : function(type) { - return this.each(function() { - jQuery.dequeue(this, type); - }); - }, - clearQueue : function(type) { - return this.queue(type || "fx", []); - }, - - // Get a promise resolved when queues of a - // certain type - // are emptied (fx is the type by default) - promise : function(type, obj) { - var tmp, count = 1, defer = jQuery - .Deferred(), elements = this, i = this.length, resolve = function() { - if (!(--count)) { - defer.resolveWith(elements, - [ elements ]); - } - }; - - if (typeof type !== "string") { - obj = type; - type = undefined; - } - type = type || "fx"; - - while (i--) { - tmp = jQuery._data(elements[i], type - + "queueHooks"); - if (tmp && tmp.empty) { - count++; - tmp.empty.add(resolve); - } - } - resolve(); - return defer.promise(obj); - } - }); - - (function() { - var shrinkWrapBlocksVal; - - support.shrinkWrapBlocks = function() { - if (shrinkWrapBlocksVal != null) { - return shrinkWrapBlocksVal; - } - - // Will be changed later if needed. - shrinkWrapBlocksVal = false; - - // Minified: var b,c,d - var div, body, container; - - body = document.getElementsByTagName("body")[0]; - if (!body || !body.style) { - - // Test fired too early or in an unsupported - // environment, exit. - return; - } - - // Setup - div = document.createElement("div"); - container = document.createElement("div"); - container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; - body.appendChild(container).appendChild(div); - - // Support: IE6 - // Check if elements with layout shrink-wrap their - // children - if (typeof div.style.zoom !== "undefined") { - - // Reset CSS: box-sizing; display; margin; - // border - div.style.cssText = - - // Support: Firefox<29, Android 2.3 - // Vendor-prefix box-sizing - "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" - + "box-sizing:content-box;display:block;margin:0;border:0;" - + "padding:1px;width:1px;zoom:1"; - div.appendChild(document.createElement("div")).style.width = "5px"; - shrinkWrapBlocksVal = div.offsetWidth !== 3; - } - - body.removeChild(container); - - return shrinkWrapBlocksVal; - }; - - })(); - var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source; - - var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum - + ")([a-z%]*)$", "i"); - - var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; - - var isHidden = function(elem, el) { - - // isHidden might be called from jQuery#filter function; - // in that case, element will be second argument - elem = el || elem; - return jQuery.css(elem, "display") === "none" - || !jQuery.contains(elem.ownerDocument, elem); - }; - - function adjustCSS(elem, prop, valueParts, tween) { - var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function() { - return tween.cur(); - } - : function() { - return jQuery.css(elem, prop, ""); - }, initial = currentValue(), unit = valueParts - && valueParts[3] - || (jQuery.cssNumber[prop] ? "" : "px"), - - // Starting value computation is required for potential - // unit mismatches - initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" - && +initial) - && rcssNum.exec(jQuery.css(elem, prop)); - - if (initialInUnit && initialInUnit[3] !== unit) { - - // Trust units reported by jQuery.css - unit = unit || initialInUnit[3]; - - // Make sure we update the tween properties later on - valueParts = valueParts || []; - - // Iteratively approximate from a nonzero starting - // point - initialInUnit = +initial || 1; - - do { - - // If previous iteration zeroed out, double - // until we get *something*. - // Use string for doubling so we don't - // accidentally see scale as unchanged below - scale = scale || ".5"; - - // Adjust and apply - initialInUnit = initialInUnit / scale; - jQuery.style(elem, prop, initialInUnit + unit); - - // Update scale, tolerating zero or NaN from - // tween.cur() - // Break the loop if scale is unchanged or - // perfect, or if we've just had enough. - } while (scale !== (scale = currentValue() - / initial) - && scale !== 1 && --maxIterations); - } - - if (valueParts) { - initialInUnit = +initialInUnit || +initial || 0; - - // Apply relative offset (+=/-=) if specified - adjusted = valueParts[1] ? initialInUnit - + (valueParts[1] + 1) * valueParts[2] - : +valueParts[2]; - if (tween) { - tween.unit = unit; - tween.start = initialInUnit; - tween.end = adjusted; - } - } - return adjusted; - } - - // Multifunctional method to get and set values of a - // collection - // The value/s can optionally be executed if it's a function - var access = function(elems, fn, key, value, chainable, - emptyGet, raw) { - var i = 0, length = elems.length, bulk = key == null; - - // Sets many values - if (jQuery.type(key) === "object") { - chainable = true; - for (i in key) { - access(elems, fn, i, key[i], true, emptyGet, - raw); - } - - // Sets one value - } else if (value !== undefined) { - chainable = true; - - if (!jQuery.isFunction(value)) { - raw = true; - } - - if (bulk) { - - // Bulk operations run against the entire set - if (raw) { - fn.call(elems, value); - fn = null; - - // ...except when executing function values - } else { - bulk = fn; - fn = function(elem, key, value) { - return bulk.call(jQuery(elem), value); - }; - } - } - - if (fn) { - for (; i < length; i++) { - fn(elems[i], key, raw ? value : value.call( - elems[i], i, fn(elems[i], key))); - } - } - } - - return chainable ? elems : - - // Gets - bulk ? fn.call(elems) : length ? fn(elems[0], key) - : emptyGet; - }; - var rcheckableType = (/^(?:checkbox|radio)$/i); - - var rtagName = (/<([\w:-]+)/); - - var rscriptType = (/^$|\/(?:java|ecma)script/i); - - var rleadingWhitespace = (/^\s+/); - - var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" - + "details|dialog|figcaption|figure|footer|header|hgroup|main|" - + "mark|meter|nav|output|picture|progress|section|summary|template|time|video"; - - function createSafeFragment(document) { - var list = nodeNames.split("|"), safeFrag = document - .createDocumentFragment(); - - if (safeFrag.createElement) { - while (list.length) { - safeFrag.createElement(list.pop()); - } - } - return safeFrag; - } - - (function() { - var div = document.createElement("div"), fragment = document - .createDocumentFragment(), input = document - .createElement("input"); - - // Setup - div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; - - // IE strips leading whitespace when .innerHTML is used - support.leadingWhitespace = div.firstChild.nodeType === 3; - - // Make sure that tbody elements aren't automatically - // inserted - // IE will insert them into empty tables - support.tbody = !div.getElementsByTagName("tbody").length; - - // Make sure that link elements get serialized correctly - // by innerHTML - // This requires a wrapper element in IE - support.htmlSerialize = !!div - .getElementsByTagName("link").length; - - // Makes sure cloning an html5 element does not cause - // problems - // Where outerHTML is undefined, this still works - support.html5Clone = document.createElement("nav") - .cloneNode(true).outerHTML !== "<:nav></:nav>"; - - // Check if a disconnected checkbox will retain its - // checked - // value of true after appended to the DOM (IE6/7) - input.type = "checkbox"; - input.checked = true; - fragment.appendChild(input); - support.appendChecked = input.checked; - - // Make sure textarea (and checkbox) defaultValue is - // properly cloned - // Support: IE6-IE11+ - div.innerHTML = "<textarea>x</textarea>"; - support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; - - // #11217 - WebKit loses check when the name is after - // the checked attribute - fragment.appendChild(div); - - // Support: Windows Web Apps (WWA) - // `name` and `type` must use .setAttribute for WWA - // (#14901) - input = document.createElement("input"); - input.setAttribute("type", "radio"); - input.setAttribute("checked", "checked"); - input.setAttribute("name", "t"); - - div.appendChild(input); - - // Support: Safari 5.1, iOS 5.1, Android 4.x, Android - // 2.3 - // old WebKit doesn't clone checked state correctly in - // fragments - support.checkClone = div.cloneNode(true) - .cloneNode(true).lastChild.checked; - - // Support: IE<9 - // Cloned elements keep attachEvent handlers, we use - // addEventListener on IE9+ - support.noCloneEvent = !!div.addEventListener; - - // Support: IE<9 - // Since attributes and properties are the same in IE, - // cleanData must set properties to undefined rather - // than use removeAttribute - div[jQuery.expando] = 1; - support.attributes = !div.getAttribute(jQuery.expando); - })(); - - // We have to close these tags to support XHTML (#13200) - var wrapMap = { - option : [ 1, "<select multiple='multiple'>", - "</select>" ], - legend : [ 1, "<fieldset>", "</fieldset>" ], - area : [ 1, "<map>", "</map>" ], - - // Support: IE8 - param : [ 1, "<object>", "</object>" ], - thead : [ 1, "<table>", "</table>" ], - tr : [ 2, "<table><tbody>", "</tbody></table>" ], - col : [ 2, "<table><tbody></tbody><colgroup>", - "</colgroup></table>" ], - td : [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], - - // IE6-8 can't serialize link, script, style, or any - // html5 (NoScope) tags, - // unless wrapped in a div with non-breaking characters - // in front of it. - _default : support.htmlSerialize ? [ 0, "", "" ] : [ 1, - "X<div>", "</div>" ] - }; - - // Support: IE8-IE9 - wrapMap.optgroup = wrapMap.option; - - wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; - wrapMap.th = wrapMap.td; - - function getAll(context, tag) { - var elems, elem, i = 0, found = typeof context.getElementsByTagName !== "undefined" ? context - .getElementsByTagName(tag || "*") - : typeof context.querySelectorAll !== "undefined" ? context - .querySelectorAll(tag || "*") - : undefined; - - if (!found) { - for (found = [], elems = context.childNodes - || context; (elem = elems[i]) != null; i++) { - if (!tag || jQuery.nodeName(elem, tag)) { - found.push(elem); - } else { - jQuery.merge(found, getAll(elem, tag)); - } - } - } - - return tag === undefined || tag - && jQuery.nodeName(context, tag) ? jQuery - .merge([ context ], found) : found; - } - - // Mark scripts as having already been evaluated - function setGlobalEval(elems, refElements) { - var elem, i = 0; - for (; (elem = elems[i]) != null; i++) { - jQuery._data(elem, "globalEval", !refElements - || jQuery._data(refElements[i], - "globalEval")); - } - } - - var rhtml = /<|&#?\w+;/, rtbody = /<tbody/i; - - function fixDefaultChecked(elem) { - if (rcheckableType.test(elem.type)) { - elem.defaultChecked = elem.checked; - } - } - - function buildFragment(elems, context, scripts, selection, - ignored) { - var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, - - // Ensure a safe fragment - safe = createSafeFragment(context), - - nodes = [], i = 0; - - for (; i < l; i++) { - elem = elems[i]; - - if (elem || elem === 0) { - - // Add nodes directly - if (jQuery.type(elem) === "object") { - jQuery.merge(nodes, - elem.nodeType ? [ elem ] : elem); - - // Convert non-html into a text node - } else if (!rhtml.test(elem)) { - nodes.push(context.createTextNode(elem)); - - // Convert html into DOM nodes - } else { - tmp = tmp - || safe.appendChild(context - .createElement("div")); - - // Deserialize a standard representation - tag = (rtagName.exec(elem) || [ "", "" ])[1] - .toLowerCase(); - wrap = wrapMap[tag] || wrapMap._default; - - tmp.innerHTML = wrap[1] - + jQuery.htmlPrefilter(elem) - + wrap[2]; - - // Descend through wrappers to the right - // content - j = wrap[0]; - while (j--) { - tmp = tmp.lastChild; - } - - // Manually add leading whitespace removed - // by IE - if (!support.leadingWhitespace - && rleadingWhitespace.test(elem)) { - nodes - .push(context - .createTextNode(rleadingWhitespace - .exec(elem)[0])); - } - - // Remove IE's autoinserted <tbody> from - // table fragments - if (!support.tbody) { - - // String was a <table>, *may* have - // spurious <tbody> - elem = tag === "table" - && !rtbody.test(elem) ? tmp.firstChild - : - - // String was a bare <thead> or - // <tfoot> - wrap[1] === "<table>" - && !rtbody.test(elem) ? tmp - : 0; - - j = elem && elem.childNodes.length; - while (j--) { - if (jQuery - .nodeName( - (tbody = elem.childNodes[j]), - "tbody") - && !tbody.childNodes.length) { - - elem.removeChild(tbody); - } - } - } - - jQuery.merge(nodes, tmp.childNodes); - - // Fix #12392 for WebKit and IE > 9 - tmp.textContent = ""; - - // Fix #12392 for oldIE - while (tmp.firstChild) { - tmp.removeChild(tmp.firstChild); - } - - // Remember the top-level container for - // proper cleanup - tmp = safe.lastChild; - } - } - } - - // Fix #11356: Clear elements from fragment - if (tmp) { - safe.removeChild(tmp); - } - - // Reset defaultChecked for any radios and checkboxes - // about to be appended to the DOM in IE 6/7 (#8060) - if (!support.appendChecked) { - jQuery.grep(getAll(nodes, "input"), - fixDefaultChecked); - } - - i = 0; - while ((elem = nodes[i++])) { - - // Skip elements already in the context collection - // (trac-4087) - if (selection - && jQuery.inArray(elem, selection) > -1) { - if (ignored) { - ignored.push(elem); - } - - continue; - } - - contains = jQuery - .contains(elem.ownerDocument, elem); - - // Append to fragment - tmp = getAll(safe.appendChild(elem), "script"); - - // Preserve script evaluation history - if (contains) { - setGlobalEval(tmp); - } - - // Capture executables - if (scripts) { - j = 0; - while ((elem = tmp[j++])) { - if (rscriptType.test(elem.type || "")) { - scripts.push(elem); - } - } - } - } - - tmp = null; - - return safe; - } - - (function() { - var i, eventName, div = document.createElement("div"); - - // Support: IE<9 (lack submit/change bubble), Firefox - // (lack focus(in | out) events) - for (i in { - submit : true, - change : true, - focusin : true - }) { - eventName = "on" + i; - - if (!(support[i] = eventName in window)) { - - // Beware of CSP restrictions - // (https://developer.mozilla.org/en/Security/CSP) - div.setAttribute(eventName, "t"); - support[i] = div.attributes[eventName].expando === false; - } - } - - // Null elements to avoid leaks in IE. - div = null; - })(); - - var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; - - function returnTrue() { - return true; - } - - function returnFalse() { - return false; - } - - // Support: IE9 - // See #13393 for more info - function safeActiveElement() { - try { - return document.activeElement; - } catch (err) { - } - } - - function on(elem, types, selector, data, fn, one) { - var origFn, type; - - // Types can be a map of types/handlers - if (typeof types === "object") { - - // ( types-Object, selector, data ) - if (typeof selector !== "string") { - - // ( types-Object, data ) - data = data || selector; - selector = undefined; - } - for (type in types) { - on(elem, type, selector, data, types[type], one); - } - return elem; - } - - if (data == null && fn == null) { - - // ( types, fn ) - fn = selector; - data = selector = undefined; - } else if (fn == null) { - if (typeof selector === "string") { - - // ( types, selector, fn ) - fn = data; - data = undefined; - } else { - - // ( types, data, fn ) - fn = data; - data = selector; - selector = undefined; - } - } - if (fn === false) { - fn = returnFalse; - } else if (!fn) { - return elem; - } - - if (one === 1) { - origFn = fn; - fn = function(event) { - - // Can use an empty set, since event contains - // the info - jQuery().off(event); - return origFn.apply(this, arguments); - }; - - // Use same guid so caller can remove using origFn - fn.guid = origFn.guid - || (origFn.guid = jQuery.guid++); - } - return elem.each(function() { - jQuery.event.add(this, types, fn, data, selector); - }); - } - - /* - * Helper functions for managing events -- not part of the - * public interface. Props to Dean Edwards' addEvent library - * for many of the ideas. - */ - jQuery.event = { - - global : {}, - - add : function(elem, types, handler, data, selector) { - var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery - ._data(elem); - - // Don't attach events to noData or text/comment - // nodes (but allow plain objects) - if (!elemData) { - return; - } - - // Caller can pass in an object of custom data in - // lieu of the handler - if (handler.handler) { - handleObjIn = handler; - handler = handleObjIn.handler; - selector = handleObjIn.selector; - } - - // Make sure that the handler has a unique ID, used - // to find/remove it later - if (!handler.guid) { - handler.guid = jQuery.guid++; - } - - // Init the element's event structure and main - // handler, if this is the first - if (!(events = elemData.events)) { - events = elemData.events = {}; - } - if (!(eventHandle = elemData.handle)) { - eventHandle = elemData.handle = function(e) { - - // Discard the second event of a - // jQuery.event.trigger() and - // when an event is called after a page has - // unloaded - return typeof jQuery !== "undefined" - && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.dispatch - .apply(eventHandle.elem, arguments) - : undefined; - }; - - // Add elem as a property of the handle fn to - // prevent a memory leak - // with IE non-native events - eventHandle.elem = elem; - } - - // Handle multiple events separated by a space - types = (types || "").match(rnotwhite) || [ "" ]; - t = types.length; - while (t--) { - tmp = rtypenamespace.exec(types[t]) || []; - type = origType = tmp[1]; - namespaces = (tmp[2] || "").split(".").sort(); - - // There *must* be a type, no attaching - // namespace-only handlers - if (!type) { - continue; - } - - // If event changes its type, use the special - // event handlers for the changed type - special = jQuery.event.special[type] || {}; - - // If selector defined, determine special event - // api type, otherwise given type - type = (selector ? special.delegateType - : special.bindType) - || type; - - // Update special based on newly reset type - special = jQuery.event.special[type] || {}; - - // handleObj is passed to all event handlers - handleObj = jQuery.extend({ - type : type, - origType : origType, - data : data, - handler : handler, - guid : handler.guid, - selector : selector, - needsContext : selector - && jQuery.expr.match.needsContext - .test(selector), - namespace : namespaces.join(".") - }, handleObjIn); - - // Init the event handler queue if we're the - // first - if (!(handlers = events[type])) { - handlers = events[type] = []; - handlers.delegateCount = 0; - - // Only use addEventListener/attachEvent if - // the special events handler returns false - if (!special.setup - || special.setup.call(elem, data, - namespaces, eventHandle) === false) { - - // Bind the global event handler to the - // element - if (elem.addEventListener) { - elem.addEventListener(type, - eventHandle, false); - - } else if (elem.attachEvent) { - elem.attachEvent("on" + type, - eventHandle); - } - } - } - - if (special.add) { - special.add.call(elem, handleObj); - - if (!handleObj.handler.guid) { - handleObj.handler.guid = handler.guid; - } - } - - // Add to the element's handler list, delegates - // in front - if (selector) { - handlers.splice(handlers.delegateCount++, - 0, handleObj); - } else { - handlers.push(handleObj); - } - - // Keep track of which events have ever been - // used, for event optimization - jQuery.event.global[type] = true; - } - - // Nullify elem to prevent memory leaks in IE - elem = null; - }, - - // Detach an event or set of events from an element - remove : function(elem, types, handler, selector, - mappedTypes) { - var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery - .hasData(elem) - && jQuery._data(elem); - - if (!elemData || !(events = elemData.events)) { - return; - } - - // Once for each type.namespace in types; type may - // be omitted - types = (types || "").match(rnotwhite) || [ "" ]; - t = types.length; - while (t--) { - tmp = rtypenamespace.exec(types[t]) || []; - type = origType = tmp[1]; - namespaces = (tmp[2] || "").split(".").sort(); - - // Unbind all events (on this namespace, if - // provided) for the element - if (!type) { - for (type in events) { - jQuery.event.remove(elem, type - + types[t], handler, selector, - true); - } - continue; - } - - special = jQuery.event.special[type] || {}; - type = (selector ? special.delegateType - : special.bindType) - || type; - handlers = events[type] || []; - tmp = tmp[2] - && new RegExp("(^|\\.)" - + namespaces - .join("\\.(?:.*\\.|)") - + "(\\.|$)"); - - // Remove matching events - origCount = j = handlers.length; - while (j--) { - handleObj = handlers[j]; - - if ((mappedTypes || origType === handleObj.origType) - && (!handler || handler.guid === handleObj.guid) - && (!tmp || tmp - .test(handleObj.namespace)) - && (!selector - || selector === handleObj.selector || selector === "**" - && handleObj.selector)) { - handlers.splice(j, 1); - - if (handleObj.selector) { - handlers.delegateCount--; - } - if (special.remove) { - special.remove - .call(elem, handleObj); - } - } - } - - // Remove generic event handler if we removed - // something and no more handlers exist - // (avoids potential for endless recursion - // during removal of special event handlers) - if (origCount && !handlers.length) { - if (!special.teardown - || special.teardown - .call(elem, namespaces, - elemData.handle) === false) { - - jQuery.removeEvent(elem, type, - elemData.handle); - } - - delete events[type]; - } - } - - // Remove the expando if it's no longer used - if (jQuery.isEmptyObject(events)) { - delete elemData.handle; - - // removeData also checks for emptiness and - // clears the expando if empty - // so use it instead of delete - jQuery._removeData(elem, "events"); - } - }, - - trigger : function(event, data, elem, onlyHandlers) { - var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [ elem - || document ], type = hasOwn.call(event, - "type") ? event.type : event, namespaces = hasOwn - .call(event, "namespace") ? event.namespace - .split(".") : []; - - cur = tmp = elem = elem || document; - - // Don't do events on text and comment nodes - if (elem.nodeType === 3 || elem.nodeType === 8) { - return; - } - - // focus/blur morphs to focusin/out; ensure we're - // not firing them right now - if (rfocusMorph.test(type + jQuery.event.triggered)) { - return; - } - - if (type.indexOf(".") > -1) { - - // Namespaced trigger; create a regexp to match - // event type in handle() - namespaces = type.split("."); - type = namespaces.shift(); - namespaces.sort(); - } - ontype = type.indexOf(":") < 0 && "on" + type; - - // Caller can pass in a jQuery.Event object, Object, - // or just an event type string - event = event[jQuery.expando] ? event - : new jQuery.Event(type, - typeof event === "object" && event); - - // Trigger bitmask: & 1 for native handlers; & 2 for - // jQuery (always true) - event.isTrigger = onlyHandlers ? 2 : 3; - event.namespace = namespaces.join("."); - event.rnamespace = event.namespace ? new RegExp( - "(^|\\.)" - + namespaces.join("\\.(?:.*\\.|)") - + "(\\.|$)") : null; - - // Clean up the event in case it is being reused - event.result = undefined; - if (!event.target) { - event.target = elem; - } - - // Clone any incoming data and prepend the event, - // creating the handler arg list - data = data == null ? [ event ] : jQuery.makeArray( - data, [ event ]); - - // Allow special events to draw outside the lines - special = jQuery.event.special[type] || {}; - if (!onlyHandlers - && special.trigger - && special.trigger.apply(elem, data) === false) { - return; - } - - // Determine event propagation path in advance, per - // W3C events spec (#9951) - // Bubble up to document, then to window; watch for - // a global ownerDocument var (#9724) - if (!onlyHandlers && !special.noBubble - && !jQuery.isWindow(elem)) { - - bubbleType = special.delegateType || type; - if (!rfocusMorph.test(bubbleType + type)) { - cur = cur.parentNode; - } - for (; cur; cur = cur.parentNode) { - eventPath.push(cur); - tmp = cur; - } - - // Only add window if we got to document (e.g., - // not plain obj or detached DOM) - if (tmp === (elem.ownerDocument || document)) { - eventPath.push(tmp.defaultView - || tmp.parentWindow || window); - } - } - - // Fire handlers on the event path - i = 0; - while ((cur = eventPath[i++]) - && !event.isPropagationStopped()) { - - event.type = i > 1 ? bubbleType - : special.bindType || type; - - // jQuery handler - handle = (jQuery._data(cur, "events") || {})[event.type] - && jQuery._data(cur, "handle"); - - if (handle) { - handle.apply(cur, data); - } - - // Native handler - handle = ontype && cur[ontype]; - if (handle && handle.apply && acceptData(cur)) { - event.result = handle.apply(cur, data); - if (event.result === false) { - event.preventDefault(); - } - } - } - event.type = type; - - // If nobody prevented the default action, do it now - if (!onlyHandlers && !event.isDefaultPrevented()) { - - if ((!special._default || special._default - .apply(eventPath.pop(), data) === false) - && acceptData(elem)) { - - // Call a native DOM method on the target - // with the same name name as the event. - // Can't use an .isFunction() check here - // because IE6/7 fails that test. - // Don't do default actions on window, - // that's where global variables be (#6170) - if (ontype && elem[type] - && !jQuery.isWindow(elem)) { - - // Don't re-trigger an onFOO event when - // we call its FOO() method - tmp = elem[ontype]; - - if (tmp) { - elem[ontype] = null; - } - - // Prevent re-triggering of the same - // event, since we already bubbled it - // above - jQuery.event.triggered = type; - try { - elem[type](); - } catch (e) { - - // IE<9 dies on focus/blur to hidden - // element (#1486,#12518) - // only reproducible on winXP IE8 - // native, not IE9 in IE8 mode - } - jQuery.event.triggered = undefined; - - if (tmp) { - elem[ontype] = tmp; - } - } - } - } - - return event.result; - }, - - dispatch : function(event) { - - // Make a writable jQuery.Event from the native - // event object - event = jQuery.event.fix(event); - - var i, j, ret, matched, handleObj, handlerQueue = [], args = slice - .call(arguments), handlers = (jQuery._data( - this, "events") || {})[event.type] - || [], special = jQuery.event.special[event.type] - || {}; - - // Use the fix-ed jQuery.Event rather than the - // (read-only) native event - args[0] = event; - event.delegateTarget = this; - - // Call the preDispatch hook for the mapped type, - // and let it bail if desired - if (special.preDispatch - && special.preDispatch.call(this, event) === false) { - return; - } - - // Determine handlers - handlerQueue = jQuery.event.handlers.call(this, - event, handlers); - - // Run delegates first; they may want to stop - // propagation beneath us - i = 0; - while ((matched = handlerQueue[i++]) - && !event.isPropagationStopped()) { - event.currentTarget = matched.elem; - - j = 0; - while ((handleObj = matched.handlers[j++]) - && !event - .isImmediatePropagationStopped()) { - - // Triggered event must either 1) have no - // namespace, or 2) have namespace(s) - // a subset or equal to those in the bound - // event (both can have no namespace). - if (!event.rnamespace - || event.rnamespace - .test(handleObj.namespace)) { - - event.handleObj = handleObj; - event.data = handleObj.data; - - ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler) - .apply(matched.elem, args); - - if (ret !== undefined) { - if ((event.result = ret) === false) { - event.preventDefault(); - event.stopPropagation(); - } - } - } - } - } - - // Call the postDispatch hook for the mapped type - if (special.postDispatch) { - special.postDispatch.call(this, event); - } - - return event.result; - }, - - handlers : function(event, handlers) { - var i, matches, sel, handleObj, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; - - // Support (at least): Chrome, IE9 - // Find delegate handlers - // Black-hole SVG <use> instance trees (#13180) - // - // Support: Firefox<=42+ - // Avoid non-left-click in FF but don't block IE - // radio events (#3861, gh-2343) - if (delegateCount - && cur.nodeType - && (event.type !== "click" - || isNaN(event.button) || event.button < 1)) { - - /* jshint eqeqeq: false */ - for (; cur != this; cur = cur.parentNode - || this) { - /* jshint eqeqeq: true */ - - // Don't check non-elements (#13208) - // Don't process clicks on disabled elements - // (#6911, #8165, #11382, #11764) - if (cur.nodeType === 1 - && (cur.disabled !== true || event.type !== "click")) { - matches = []; - for (i = 0; i < delegateCount; i++) { - handleObj = handlers[i]; - - // Don't conflict with - // Object.prototype properties - // (#13203) - sel = handleObj.selector + " "; - - if (matches[sel] === undefined) { - matches[sel] = handleObj.needsContext ? jQuery( - sel, this).index(cur) > -1 - : jQuery.find(sel, - this, null, - [ cur ]).length; - } - if (matches[sel]) { - matches.push(handleObj); - } - } - if (matches.length) { - handlerQueue.push({ - elem : cur, - handlers : matches - }); - } - } - } - } - - // Add the remaining (directly-bound) handlers - if (delegateCount < handlers.length) { - handlerQueue.push({ - elem : this, - handlers : handlers.slice(delegateCount) - }); - } - - return handlerQueue; - }, - - fix : function(event) { - if (event[jQuery.expando]) { - return event; - } - - // Create a writable copy of the event object and - // normalize some properties - var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type]; - - if (!fixHook) { - this.fixHooks[type] = fixHook = rmouseEvent - .test(type) ? this.mouseHooks - : rkeyEvent.test(type) ? this.keyHooks - : {}; - } - copy = fixHook.props ? this.props - .concat(fixHook.props) : this.props; - - event = new jQuery.Event(originalEvent); - - i = copy.length; - while (i--) { - prop = copy[i]; - event[prop] = originalEvent[prop]; - } - - // Support: IE<9 - // Fix target property (#1925) - if (!event.target) { - event.target = originalEvent.srcElement - || document; - } - - // Support: Safari 6-8+ - // Target should not be a text node (#504, #13143) - if (event.target.nodeType === 3) { - event.target = event.target.parentNode; - } - - // Support: IE<9 - // For mouse/key events, metaKey==false if it's - // undefined (#3368, #11328) - event.metaKey = !!event.metaKey; - - return fixHook.filter ? fixHook.filter(event, - originalEvent) : event; - }, - - // Includes some event props shared by KeyEvent and - // MouseEvent - props : ("altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " - + "metaKey relatedTarget shiftKey target timeStamp view which") - .split(" "), - - fixHooks : {}, - - keyHooks : { - props : "char charCode key keyCode".split(" "), - filter : function(event, original) { - - // Add which for key events - if (event.which == null) { - event.which = original.charCode != null ? original.charCode - : original.keyCode; - } - - return event; - } - }, - - mouseHooks : { - props : ("button buttons clientX clientY fromElement offsetX offsetY " - + "pageX pageY screenX screenY toElement") - .split(" "), - filter : function(event, original) { - var body, eventDoc, doc, button = original.button, fromElement = original.fromElement; - - // Calculate pageX/Y if missing and clientX/Y - // available - if (event.pageX == null - && original.clientX != null) { - eventDoc = event.target.ownerDocument - || document; - doc = eventDoc.documentElement; - body = eventDoc.body; - - event.pageX = original.clientX - + (doc && doc.scrollLeft || body - && body.scrollLeft || 0) - - (doc && doc.clientLeft || body - && body.clientLeft || 0); - event.pageY = original.clientY - + (doc && doc.scrollTop || body - && body.scrollTop || 0) - - (doc && doc.clientTop || body - && body.clientTop || 0); - } - - // Add relatedTarget, if necessary - if (!event.relatedTarget && fromElement) { - event.relatedTarget = fromElement === event.target ? original.toElement - : fromElement; - } - - // Add which for click: 1 === left; 2 === - // middle; 3 === right - // Note: button is not normalized, so don't use - // it - if (!event.which && button !== undefined) { - event.which = (button & 1 ? 1 - : (button & 2 ? 3 : (button & 4 ? 2 - : 0))); - } - - return event; - } - }, - - special : { - load : { - - // Prevent triggered image.load events from - // bubbling to window.load - noBubble : true - }, - focus : { - - // Fire native event if possible so blur/focus - // sequence is correct - trigger : function() { - if (this !== safeActiveElement() - && this.focus) { - try { - this.focus(); - return false; - } catch (e) { - - // Support: IE<9 - // If we error on focus to hidden - // element (#1486, #12518), - // let .trigger() run the handlers - } - } - }, - delegateType : "focusin" - }, - blur : { - trigger : function() { - if (this === safeActiveElement() - && this.blur) { - this.blur(); - return false; - } - }, - delegateType : "focusout" - }, - click : { - - // For checkbox, fire native event so checked - // state will be right - trigger : function() { - if (jQuery.nodeName(this, "input") - && this.type === "checkbox" - && this.click) { - this.click(); - return false; - } - }, - - // For cross-browser consistency, don't fire - // native .click() on links - _default : function(event) { - return jQuery.nodeName(event.target, "a"); - } - }, - - beforeunload : { - postDispatch : function(event) { - - // Support: Firefox 20+ - // Firefox doesn't alert if the returnValue - // field is not set. - if (event.result !== undefined - && event.originalEvent) { - event.originalEvent.returnValue = event.result; - } - } - } - }, - - // Piggyback on a donor event to simulate a different - // one - simulate : function(type, elem, event) { - var e = jQuery.extend(new jQuery.Event(), event, { - type : type, - isSimulated : true - - // Previously, `originalEvent: {}` was set here, so - // stopPropagation call - // would not be triggered on donor event, since in - // our own - // jQuery.event.stopPropagation function we had a - // check for existence of - // originalEvent.stopPropagation method, so, - // consequently it would be a noop. - // - // Guard for simulated events was moved to - // jQuery.event.stopPropagation function - // since `originalEvent` should point to the - // original event for the - // constancy with other events and for more focused - // logic - }); - - jQuery.event.trigger(e, null, elem); - - if (e.isDefaultPrevented()) { - event.preventDefault(); - } - } - }; - - jQuery.removeEvent = document.removeEventListener ? function( - elem, type, handle) { - - // This "if" is needed for plain objects - if (elem.removeEventListener) { - elem.removeEventListener(type, handle); - } - } - : function(elem, type, handle) { - var name = "on" + type; - - if (elem.detachEvent) { - - // #8545, #7054, preventing memory leaks for - // custom events in IE6-8 - // detachEvent needed property on element, - // by name of that event, - // to properly expose it to GC - if (typeof elem[name] === "undefined") { - elem[name] = null; - } - - elem.detachEvent(name, handle); - } - }; - - jQuery.Event = function(src, props) { - - // Allow instantiation without the 'new' keyword - if (!(this instanceof jQuery.Event)) { - return new jQuery.Event(src, props); - } - - // Event object - if (src && src.type) { - this.originalEvent = src; - this.type = src.type; - - // Events bubbling up the document may have been - // marked as prevented - // by a handler lower down the tree; reflect the - // correct value. - this.isDefaultPrevented = src.defaultPrevented - || src.defaultPrevented === undefined && - - // Support: IE < 9, Android < 4.0 - src.returnValue === false ? returnTrue - : returnFalse; - - // Event type - } else { - this.type = src; - } - - // Put explicitly provided properties onto the event - // object - if (props) { - jQuery.extend(this, props); - } - - // Create a timestamp if incoming event doesn't have one - this.timeStamp = src && src.timeStamp || jQuery.now(); - - // Mark it as fixed - this[jQuery.expando] = true; - }; - - // jQuery.Event is based on DOM3 Events as specified by the - // ECMAScript Language Binding - // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html - jQuery.Event.prototype = { - constructor : jQuery.Event, - isDefaultPrevented : returnFalse, - isPropagationStopped : returnFalse, - isImmediatePropagationStopped : returnFalse, - - preventDefault : function() { - var e = this.originalEvent; - - this.isDefaultPrevented = returnTrue; - if (!e) { - return; - } - - // If preventDefault exists, run it on the original - // event - if (e.preventDefault) { - e.preventDefault(); - - // Support: IE - // Otherwise set the returnValue property of the - // original event to false - } else { - e.returnValue = false; - } - }, - stopPropagation : function() { - var e = this.originalEvent; - - this.isPropagationStopped = returnTrue; - - if (!e || this.isSimulated) { - return; - } - - // If stopPropagation exists, run it on the original - // event - if (e.stopPropagation) { - e.stopPropagation(); - } - - // Support: IE - // Set the cancelBubble property of the original - // event to true - e.cancelBubble = true; - }, - stopImmediatePropagation : function() { - var e = this.originalEvent; - - this.isImmediatePropagationStopped = returnTrue; - - if (e && e.stopImmediatePropagation) { - e.stopImmediatePropagation(); - } - - this.stopPropagation(); - } - }; - - // Create mouseenter/leave events using mouseover/out and - // event-time checks - // so that event delegation works in jQuery. - // Do the same for pointerenter/pointerleave and - // pointerover/pointerout - // - // Support: Safari 7 only - // Safari sends mouseenter too often; see: - // https://code.google.com/p/chromium/issues/detail?id=470258 - // for the description of the bug (it existed in older - // Chrome versions as well). - jQuery - .each( - { - mouseenter : "mouseover", - mouseleave : "mouseout", - pointerenter : "pointerover", - pointerleave : "pointerout" - }, - function(orig, fix) { - jQuery.event.special[orig] = { - delegateType : fix, - bindType : fix, - - handle : function(event) { - var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; - - // For mouseenter/leave call the - // handler if related is outside - // the target. - // NB: No relatedTarget if the - // mouse left/entered the - // browser window - if (!related - || (related !== target && !jQuery - .contains( - target, - related))) { - event.type = handleObj.origType; - ret = handleObj.handler - .apply(this, - arguments); - event.type = fix; - } - return ret; - } - }; - }); - - // IE submit delegation - if (!support.submit) { - - jQuery.event.special.submit = { - setup : function() { - - // Only need this for delegated form submit - // events - if (jQuery.nodeName(this, "form")) { - return false; - } - - // Lazy-add a submit handler when a descendant - // form may potentially be submitted - jQuery.event - .add( - this, - "click._submit keypress._submit", - function(e) { - - // Node name check avoids a - // VML-related crash in IE - // (#9807) - var elem = e.target, form = jQuery - .nodeName(elem, - "input") - || jQuery.nodeName( - elem, - "button") ? - - // Support: IE <=8 - // We use jQuery.prop - // instead of elem.form - // to allow fixing the IE8 - // delegated submit issue - // (gh-2332) - // by 3rd party - // polyfills/workarounds. - jQuery.prop(elem, "form") - : undefined; - - if (form - && !jQuery._data( - form, - "submit")) { - jQuery.event - .add( - form, - "submit._submit", - function( - event) { - event._submitBubble = true; - }); - jQuery._data(form, - "submit", true); - } - }); - - // return undefined since we don't need an event - // listener - }, - - postDispatch : function(event) { - - // If form was submitted by the user, bubble the - // event up the tree - if (event._submitBubble) { - delete event._submitBubble; - if (this.parentNode && !event.isTrigger) { - jQuery.event.simulate("submit", - this.parentNode, event); - } - } - }, - - teardown : function() { - - // Only need this for delegated form submit - // events - if (jQuery.nodeName(this, "form")) { - return false; - } - - // Remove delegated handlers; cleanData - // eventually reaps submit handlers attached - // above - jQuery.event.remove(this, "._submit"); - } - }; - } - - // IE change delegation and checkbox/radio fix - if (!support.change) { - - jQuery.event.special.change = { - - setup : function() { - - if (rformElems.test(this.nodeName)) { - - // IE doesn't fire change on a check/radio - // until blur; trigger it on click - // after a propertychange. Eat the - // blur-change in special.change.handle. - // This still fires onchange a second time - // for check/radio after blur. - if (this.type === "checkbox" - || this.type === "radio") { - jQuery.event - .add( - this, - "propertychange._change", - function(event) { - if (event.originalEvent.propertyName === "checked") { - this._justChanged = true; - } - }); - jQuery.event - .add( - this, - "click._change", - function(event) { - if (this._justChanged - && !event.isTrigger) { - this._justChanged = false; - } - - // Allow triggered, - // simulated change - // events (#11500) - jQuery.event - .simulate( - "change", - this, - event); - }); - } - return false; - } - - // Delegated event; lazy-add a change handler on - // descendant inputs - jQuery.event - .add( - this, - "beforeactivate._change", - function(e) { - var elem = e.target; - - if (rformElems - .test(elem.nodeName) - && !jQuery._data( - elem, - "change")) { - jQuery.event - .add( - elem, - "change._change", - function( - event) { - if (this.parentNode - && !event.isSimulated - && !event.isTrigger) { - jQuery.event - .simulate( - "change", - this.parentNode, - event); - } - }); - jQuery._data(elem, - "change", true); - } - }); - }, - - handle : function(event) { - var elem = event.target; - - // Swallow native change events from - // checkbox/radio, we already triggered them - // above - if (this !== elem - || event.isSimulated - || event.isTrigger - || (elem.type !== "radio" && elem.type !== "checkbox")) { - - return event.handleObj.handler.apply(this, - arguments); - } - }, - - teardown : function() { - jQuery.event.remove(this, "._change"); - - return !rformElems.test(this.nodeName); - } - }; - } - - // Support: Firefox - // Firefox doesn't have focus(in | out) events - // Related ticket - - // https://bugzilla.mozilla.org/show_bug.cgi?id=687787 - // - // Support: Chrome, Safari - // focus(in | out) events fire after focus & blur events, - // which is spec violation - - // http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order - // Related ticket - - // https://code.google.com/p/chromium/issues/detail?id=449857 - if (!support.focusin) { - jQuery.each({ - focus : "focusin", - blur : "focusout" - }, - function(orig, fix) { - - // Attach a single capturing handler on the - // document while someone wants - // focusin/focusout - var handler = function(event) { - jQuery.event.simulate(fix, - event.target, jQuery.event - .fix(event)); - }; - - jQuery.event.special[fix] = { - setup : function() { - var doc = this.ownerDocument - || this, attaches = jQuery - ._data(doc, fix); - - if (!attaches) { - doc.addEventListener(orig, - handler, true); - } - jQuery._data(doc, fix, - (attaches || 0) + 1); - }, - teardown : function() { - var doc = this.ownerDocument - || this, attaches = jQuery - ._data(doc, fix) - 1; - - if (!attaches) { - doc.removeEventListener(orig, - handler, true); - jQuery._removeData(doc, fix); - } else { - jQuery - ._data(doc, fix, - attaches); - } - } - }; - }); - } - - jQuery.fn - .extend({ - - on : function(types, selector, data, fn) { - return on(this, types, selector, data, fn); - }, - one : function(types, selector, data, fn) { - return on(this, types, selector, data, fn, - 1); - }, - off : function(types, selector, fn) { - var handleObj, type; - if (types && types.preventDefault - && types.handleObj) { - - // ( event ) dispatched jQuery.Event - handleObj = types.handleObj; - jQuery(types.delegateTarget) - .off( - handleObj.namespace ? handleObj.origType - + "." - + handleObj.namespace - : handleObj.origType, - handleObj.selector, - handleObj.handler); - return this; - } - if (typeof types === "object") { - - // ( types-object [, selector] ) - for (type in types) { - this.off(type, selector, - types[type]); - } - return this; - } - if (selector === false - || typeof selector === "function") { - - // ( types [, fn] ) - fn = selector; - selector = undefined; - } - if (fn === false) { - fn = returnFalse; - } - return this.each(function() { - jQuery.event.remove(this, types, fn, - selector); - }); - }, - - trigger : function(type, data) { - return this.each(function() { - jQuery.event.trigger(type, data, this); - }); - }, - triggerHandler : function(type, data) { - var elem = this[0]; - if (elem) { - return jQuery.event.trigger(type, data, - elem, true); - } - } - }); - - var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, rnoshimcache = new RegExp( - "<(?:" + nodeNames + ")[\\s/>]", "i"), rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi, - - // Support: IE 10-11, Edge 10240+ - // In IE/Edge using regex groups here causes severe - // slowdowns. - // See - // https://connect.microsoft.com/IE/feedback/details/1736512/ - rnoInnerhtml = /<script|<style|<link/i, - - // checked="checked" or checked - rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, safeFragment = createSafeFragment(document), fragmentDiv = safeFragment - .appendChild(document.createElement("div")); - - // Support: IE<8 - // Manipulating tables requires a tbody - function manipulationTarget(elem, content) { - return jQuery.nodeName(elem, "table") - && jQuery.nodeName( - content.nodeType !== 11 ? content - : content.firstChild, "tr") ? - - elem.getElementsByTagName("tbody")[0] - || elem.appendChild(elem.ownerDocument - .createElement("tbody")) : elem; - } - - // Replace/restore the type attribute of script elements for - // safe DOM manipulation - function disableScript(elem) { - elem.type = (jQuery.find.attr(elem, "type") !== null) - + "/" + elem.type; - return elem; - } - function restoreScript(elem) { - var match = rscriptTypeMasked.exec(elem.type); - if (match) { - elem.type = match[1]; - } else { - elem.removeAttribute("type"); - } - return elem; - } - - function cloneCopyEvent(src, dest) { - if (dest.nodeType !== 1 || !jQuery.hasData(src)) { - return; - } - - var type, i, l, oldData = jQuery._data(src), curData = jQuery - ._data(dest, oldData), events = oldData.events; - - if (events) { - delete curData.handle; - curData.events = {}; - - for (type in events) { - for (i = 0, l = events[type].length; i < l; i++) { - jQuery.event.add(dest, type, - events[type][i]); - } - } - } - - // make the cloned public data object a copy from the - // original - if (curData.data) { - curData.data = jQuery.extend({}, curData.data); - } - } - - function fixCloneNodeIssues(src, dest) { - var nodeName, e, data; - - // We do not need to do anything for non-Elements - if (dest.nodeType !== 1) { - return; - } - - nodeName = dest.nodeName.toLowerCase(); - - // IE6-8 copies events bound via attachEvent when using - // cloneNode. - if (!support.noCloneEvent && dest[jQuery.expando]) { - data = jQuery._data(dest); - - for (e in data.events) { - jQuery.removeEvent(dest, e, data.handle); - } - - // Event data gets referenced instead of copied if - // the expando gets copied too - dest.removeAttribute(jQuery.expando); - } - - // IE blanks contents when cloning scripts, and tries to - // evaluate newly-set text - if (nodeName === "script" && dest.text !== src.text) { - disableScript(dest).text = src.text; - restoreScript(dest); - - // IE6-10 improperly clones children of object - // elements using classid. - // IE10 throws NoModificationAllowedError if parent - // is null, #12132. - } else if (nodeName === "object") { - if (dest.parentNode) { - dest.outerHTML = src.outerHTML; - } - - // This path appears unavoidable for IE9. When - // cloning an object - // element in IE9, the outerHTML strategy above is - // not sufficient. - // If the src has innerHTML and the destination does - // not, - // copy the src.innerHTML into the dest.innerHTML. - // #10324 - if (support.html5Clone - && (src.innerHTML && !jQuery - .trim(dest.innerHTML))) { - dest.innerHTML = src.innerHTML; - } - - } else if (nodeName === "input" - && rcheckableType.test(src.type)) { - - // IE6-8 fails to persist the checked state of a - // cloned checkbox - // or radio button. Worse, IE6-7 fail to give the - // cloned element - // a checked appearance if the defaultChecked value - // isn't also set - - dest.defaultChecked = dest.checked = src.checked; - - // IE6-7 get confused and end up setting the value - // of a cloned - // checkbox/radio button to an empty string instead - // of "on" - if (dest.value !== src.value) { - dest.value = src.value; - } - - // IE6-8 fails to return the selected option to the - // default selected - // state when cloning options - } else if (nodeName === "option") { - dest.defaultSelected = dest.selected = src.defaultSelected; - - // IE6-8 fails to set the defaultValue to the - // correct value when - // cloning other types of input fields - } else if (nodeName === "input" - || nodeName === "textarea") { - dest.defaultValue = src.defaultValue; - } - } - - function domManip(collection, args, callback, ignored) { - - // Flatten any nested arrays - args = concat.apply([], args); - - var first, node, hasScripts, scripts, doc, fragment, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], isFunction = jQuery - .isFunction(value); - - // We can't cloneNode fragments that contain checked, in - // WebKit - if (isFunction - || (l > 1 && typeof value === "string" - && !support.checkClone && rchecked - .test(value))) { - return collection.each(function(index) { - var self = collection.eq(index); - if (isFunction) { - args[0] = value.call(this, index, self - .html()); - } - domManip(self, args, callback, ignored); - }); - } - - if (l) { - fragment = buildFragment(args, - collection[0].ownerDocument, false, - collection, ignored); - first = fragment.firstChild; - - if (fragment.childNodes.length === 1) { - fragment = first; - } - - // Require either new content or an interest in - // ignored elements to invoke the callback - if (first || ignored) { - scripts = jQuery.map( - getAll(fragment, "script"), - disableScript); - hasScripts = scripts.length; - - // Use the original fragment for the last item - // instead of the first because it can end up - // being emptied incorrectly in certain - // situations (#8070). - for (; i < l; i++) { - node = fragment; - - if (i !== iNoClone) { - node = jQuery.clone(node, true, true); - - // Keep references to cloned scripts for - // later restoration - if (hasScripts) { - - // Support: Android<4.1, PhantomJS<2 - // push.apply(_, arraylike) throws - // on ancient WebKit - jQuery.merge(scripts, getAll(node, - "script")); - } - } - - callback.call(collection[i], node, i); - } - - if (hasScripts) { - doc = scripts[scripts.length - 1].ownerDocument; - - // Reenable scripts - jQuery.map(scripts, restoreScript); - - // Evaluate executable scripts on first - // document insertion - for (i = 0; i < hasScripts; i++) { - node = scripts[i]; - if (rscriptType.test(node.type || "") - && !jQuery._data(node, - "globalEval") - && jQuery.contains(doc, node)) { - - if (node.src) { - - // Optional AJAX dependency, but - // won't run scripts if not - // present - if (jQuery._evalUrl) { - jQuery._evalUrl(node.src); - } - } else { - jQuery - .globalEval((node.text - || node.textContent - || node.innerHTML || "") - .replace( - rcleanScript, - "")); - } - } - } - } - - // Fix #11809: Avoid leaking memory - fragment = first = null; - } - } - - return collection; - } - - function remove(elem, selector, keepData) { - var node, elems = selector ? jQuery.filter(selector, - elem) : elem, i = 0; - - for (; (node = elems[i]) != null; i++) { - - if (!keepData && node.nodeType === 1) { - jQuery.cleanData(getAll(node)); - } - - if (node.parentNode) { - if (keepData - && jQuery.contains(node.ownerDocument, - node)) { - setGlobalEval(getAll(node, "script")); - } - node.parentNode.removeChild(node); - } - } - - return elem; - } - - jQuery - .extend({ - htmlPrefilter : function(html) { - return html.replace(rxhtmlTag, "<$1></$2>"); - }, - - clone : function(elem, dataAndEvents, - deepDataAndEvents) { - var destElements, node, clone, i, srcElements, inPage = jQuery - .contains(elem.ownerDocument, elem); - - if (support.html5Clone - || jQuery.isXMLDoc(elem) - || !rnoshimcache.test("<" - + elem.nodeName + ">")) { - - clone = elem.cloneNode(true); - - // IE<=8 does not properly clone - // detached, unknown element nodes - } else { - fragmentDiv.innerHTML = elem.outerHTML; - fragmentDiv - .removeChild(clone = fragmentDiv.firstChild); - } - - if ((!support.noCloneEvent || !support.noCloneChecked) - && (elem.nodeType === 1 || elem.nodeType === 11) - && !jQuery.isXMLDoc(elem)) { - - // We eschew Sizzle here for performance - // reasons: - // http://jsperf.com/getall-vs-sizzle/2 - destElements = getAll(clone); - srcElements = getAll(elem); - - // Fix all IE cloning issues - for (i = 0; (node = srcElements[i]) != null; ++i) { - - // Ensure that the destination node - // is not null; Fixes #9587 - if (destElements[i]) { - fixCloneNodeIssues(node, - destElements[i]); - } - } - } - - // Copy the events from the original to the - // clone - if (dataAndEvents) { - if (deepDataAndEvents) { - srcElements = srcElements - || getAll(elem); - destElements = destElements - || getAll(clone); - - for (i = 0; (node = srcElements[i]) != null; i++) { - cloneCopyEvent(node, - destElements[i]); - } - } else { - cloneCopyEvent(elem, clone); - } - } - - // Preserve script evaluation history - destElements = getAll(clone, "script"); - if (destElements.length > 0) { - setGlobalEval(destElements, !inPage - && getAll(elem, "script")); - } - - destElements = srcElements = node = null; - - // Return the cloned set - return clone; - }, - - cleanData : function(elems, /* internal */ - forceAcceptData) { - var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, attributes = support.attributes, special = jQuery.event.special; - - for (; (elem = elems[i]) != null; i++) { - if (forceAcceptData || acceptData(elem)) { - - id = elem[internalKey]; - data = id && cache[id]; - - if (data) { - if (data.events) { - for (type in data.events) { - if (special[type]) { - jQuery.event - .remove( - elem, - type); - - // This is a - // shortcut to avoid - // jQuery.event.remove's - // overhead - } else { - jQuery - .removeEvent( - elem, - type, - data.handle); - } - } - } - - // Remove cache only if it was - // not already removed by - // jQuery.event.remove - if (cache[id]) { - - delete cache[id]; - - // Support: IE<9 - // IE does not allow us to - // delete expando properties - // from nodes - // IE creates expando - // attributes along with the - // property - // IE does not have a - // removeAttribute function - // on Document nodes - if (!attributes - && typeof elem.removeAttribute !== "undefined") { - elem - .removeAttribute(internalKey); - - // Webkit & Blink - // performance suffers - // when deleting - // properties - // from DOM nodes, so - // set to undefined - // instead - // https://code.google.com/p/chromium/issues/detail?id=378607 - } else { - elem[internalKey] = undefined; - } - - deletedIds.push(id); - } - } - } - } - } - }); - - jQuery.fn - .extend({ - - // Keep domManip exposed until 3.0 (gh-2225) - domManip : domManip, - - detach : function(selector) { - return remove(this, selector, true); - }, - - remove : function(selector) { - return remove(this, selector); - }, - - text : function(value) { - return access( - this, - function(value) { - return value === undefined ? jQuery - .text(this) - : this - .empty() - .append( - (this[0] - && this[0].ownerDocument || document) - .createTextNode(value)); - }, null, value, arguments.length); - }, - - append : function() { - return domManip(this, arguments, function( - elem) { - if (this.nodeType === 1 - || this.nodeType === 11 - || this.nodeType === 9) { - var target = manipulationTarget( - this, elem); - target.appendChild(elem); - } - }); - }, - - prepend : function() { - return domManip(this, arguments, function( - elem) { - if (this.nodeType === 1 - || this.nodeType === 11 - || this.nodeType === 9) { - var target = manipulationTarget( - this, elem); - target.insertBefore(elem, - target.firstChild); - } - }); - }, - - before : function() { - return domManip(this, arguments, function( - elem) { - if (this.parentNode) { - this.parentNode.insertBefore(elem, - this); - } - }); - }, - - after : function() { - return domManip(this, arguments, function( - elem) { - if (this.parentNode) { - this.parentNode.insertBefore(elem, - this.nextSibling); - } - }); - }, - - empty : function() { - var elem, i = 0; - - for (; (elem = this[i]) != null; i++) { - - // Remove element nodes and prevent - // memory leaks - if (elem.nodeType === 1) { - jQuery - .cleanData(getAll(elem, - false)); - } - - // Remove any remaining nodes - while (elem.firstChild) { - elem.removeChild(elem.firstChild); - } - - // If this is a select, ensure that it - // displays empty (#12336) - // Support: IE<9 - if (elem.options - && jQuery.nodeName(elem, - "select")) { - elem.options.length = 0; - } - } - - return this; - }, - - clone : function(dataAndEvents, - deepDataAndEvents) { - dataAndEvents = dataAndEvents == null ? false - : dataAndEvents; - deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents - : deepDataAndEvents; - - return this.map(function() { - return jQuery.clone(this, - dataAndEvents, - deepDataAndEvents); - }); - }, - - html : function(value) { - return access( - this, - function(value) { - var elem = this[0] || {}, i = 0, l = this.length; - - if (value === undefined) { - return elem.nodeType === 1 ? elem.innerHTML - .replace( - rinlinejQuery, - "") - : undefined; - } - - // See if we can take a shortcut - // and just use innerHTML - if (typeof value === "string" - && !rnoInnerhtml - .test(value) - && (support.htmlSerialize || !rnoshimcache - .test(value)) - && (support.leadingWhitespace || !rleadingWhitespace - .test(value)) - && !wrapMap[(rtagName - .exec(value) || [ - "", "" ])[1] - .toLowerCase()]) { - - value = jQuery - .htmlPrefilter(value); - - try { - for (; i < l; i++) { - - // Remove element - // nodes and prevent - // memory leaks - elem = this[i] - || {}; - if (elem.nodeType === 1) { - jQuery - .cleanData(getAll( - elem, - false)); - elem.innerHTML = value; - } - } - - elem = 0; - - // If using innerHTML - // throws an exception, - // use the fallback - // method - } catch (e) { - } - } - - if (elem) { - this.empty().append(value); - } - }, null, value, arguments.length); - }, - - replaceWith : function() { - var ignored = []; - - // Make the changes, replacing each - // non-ignored context element with the new - // content - return domManip( - this, - arguments, - function(elem) { - var parent = this.parentNode; - - if (jQuery.inArray(this, - ignored) < 0) { - jQuery - .cleanData(getAll(this)); - if (parent) { - parent.replaceChild( - elem, this); - } - } - - // Force callback invocation - }, ignored); - } - }); - - jQuery - .each( - { - appendTo : "append", - prependTo : "prepend", - insertBefore : "before", - insertAfter : "after", - replaceAll : "replaceWith" - }, - function(name, original) { - jQuery.fn[name] = function(selector) { - var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; - - for (; i <= last; i++) { - elems = i === last ? this - : this.clone(true); - jQuery(insert[i])[original] - (elems); - - // Modern browsers can apply - // jQuery collections as arrays, - // but oldIE needs a .get() - push.apply(ret, elems.get()); - } - - return this.pushStack(ret); - }; - }); - - var iframe, elemdisplay = { - - // Support: Firefox - // We have to pre-define these values for FF (#10227) - HTML : "block", - BODY : "block" - }; - - /** - * Retrieve the actual display of a element - * - * @param {String} - * name nodeName of the element - * @param {Object} - * doc Document object - */ - - // Called only from within defaultDisplay - function actualDisplay(name, doc) { - var elem = jQuery(doc.createElement(name)).appendTo( - doc.body), - - display = jQuery.css(elem[0], "display"); - - // We don't have any data stored on the element, - // so use "detach" method as fast way to get rid of the - // element - elem.detach(); - - return display; - } - - /** - * Try to determine the default display value of an element - * - * @param {String} - * nodeName - */ - function defaultDisplay(nodeName) { - var doc = document, display = elemdisplay[nodeName]; - - if (!display) { - display = actualDisplay(nodeName, doc); - - // If the simple way fails, read from inside an - // iframe - if (display === "none" || !display) { - - // Use the already-created iframe if possible - iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")) - .appendTo(doc.documentElement); - - // Always write a new HTML skeleton so Webkit - // and Firefox don't choke on reuse - doc = (iframe[0].contentWindow || iframe[0].contentDocument).document; - - // Support: IE - doc.write(); - doc.close(); - - display = actualDisplay(nodeName, doc); - iframe.detach(); - } - - // Store the correct default display - elemdisplay[nodeName] = display; - } - - return display; - } - var rmargin = (/^margin/); - - var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", - "i"); - - var swap = function(elem, options, callback, args) { - var ret, name, old = {}; - - // Remember the old values, and insert the new ones - for (name in options) { - old[name] = elem.style[name]; - elem.style[name] = options[name]; - } - - ret = callback.apply(elem, args || []); - - // Revert the old values - for (name in options) { - elem.style[name] = old[name]; - } - - return ret; - }; - - var documentElement = document.documentElement; - - (function() { - var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal, reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal, container = document - .createElement("div"), div = document - .createElement("div"); - - // Finish early in limited (non-browser) environments - if (!div.style) { - return; - } - - div.style.cssText = "float:left;opacity:.5"; - - // Support: IE<9 - // Make sure that element opacity exists (as opposed to - // filter) - support.opacity = div.style.opacity === "0.5"; - - // Verify style float existence - // (IE uses styleFloat instead of cssFloat) - support.cssFloat = !!div.style.cssFloat; - - div.style.backgroundClip = "content-box"; - div.cloneNode(true).style.backgroundClip = ""; - support.clearCloneStyle = div.style.backgroundClip === "content-box"; - - container = document.createElement("div"); - container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" - + "padding:0;margin-top:1px;position:absolute"; - div.innerHTML = ""; - container.appendChild(div); - - // Support: Firefox<29, Android 2.3 - // Vendor-prefix box-sizing - support.boxSizing = div.style.boxSizing === "" - || div.style.MozBoxSizing === "" - || div.style.WebkitBoxSizing === ""; - - jQuery.extend(support, { - reliableHiddenOffsets : function() { - if (pixelPositionVal == null) { - computeStyleTests(); - } - return reliableHiddenOffsetsVal; - }, - - boxSizingReliable : function() { - - // We're checking for pixelPositionVal here - // instead of boxSizingReliableVal - // since that compresses better and they're - // computed together anyway. - if (pixelPositionVal == null) { - computeStyleTests(); - } - return boxSizingReliableVal; - }, - - pixelMarginRight : function() { - - // Support: Android 4.0-4.3 - if (pixelPositionVal == null) { - computeStyleTests(); - } - return pixelMarginRightVal; - }, - - pixelPosition : function() { - if (pixelPositionVal == null) { - computeStyleTests(); - } - return pixelPositionVal; - }, - - reliableMarginRight : function() { - - // Support: Android 2.3 - if (pixelPositionVal == null) { - computeStyleTests(); - } - return reliableMarginRightVal; - }, - - reliableMarginLeft : function() { - - // Support: IE <=8 only, Android 4.0 - 4.3 only, - // Firefox <=3 - 37 - if (pixelPositionVal == null) { - computeStyleTests(); - } - return reliableMarginLeftVal; - } - }); - - function computeStyleTests() { - var contents, divStyle, documentElement = document.documentElement; - - // Setup - documentElement.appendChild(container); - - div.style.cssText = - - // Support: Android 2.3 - // Vendor-prefix box-sizing - "-webkit-box-sizing:border-box;box-sizing:border-box;" - + "position:relative;display:block;" - + "margin:auto;border:1px;padding:1px;" - + "top:1%;width:50%"; - - // Support: IE<9 - // Assume reasonable values in the absence of - // getComputedStyle - pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false; - pixelMarginRightVal = reliableMarginRightVal = true; - - // Check for getComputedStyle so that this code is - // not run in IE<9. - if (window.getComputedStyle) { - divStyle = window.getComputedStyle(div); - pixelPositionVal = (divStyle || {}).top !== "1%"; - reliableMarginLeftVal = (divStyle || {}).marginLeft === "2px"; - boxSizingReliableVal = (divStyle || { - width : "4px" - }).width === "4px"; - - // Support: Android 4.0 - 4.3 only - // Some styles come back with percentage values, - // even though they shouldn't - div.style.marginRight = "50%"; - pixelMarginRightVal = (divStyle || { - marginRight : "4px" - }).marginRight === "4px"; - - // Support: Android 2.3 only - // Div with explicit width and no margin-right - // incorrectly - // gets computed margin-right based on width of - // container (#3333) - // WebKit Bug 13343 - getComputedStyle returns - // wrong value for margin-right - contents = div.appendChild(document - .createElement("div")); - - // Reset CSS: box-sizing; display; margin; - // border; padding - contents.style.cssText = div.style.cssText = - - // Support: Android 2.3 - // Vendor-prefix box-sizing - "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" - + "box-sizing:content-box;display:block;margin:0;border:0;padding:0"; - contents.style.marginRight = contents.style.width = "0"; - div.style.width = "1px"; - - reliableMarginRightVal = !parseFloat((window - .getComputedStyle(contents) || {}).marginRight); - - div.removeChild(contents); - } - - // Support: IE6-8 - // First check that getClientRects works as expected - // Check if table cells still have - // offsetWidth/Height when they are set - // to display:none and there are still other visible - // table cells in a - // table row; if so, offsetWidth/Height are not - // reliable for use when - // determining if an element has been hidden - // directly using - // display:none (it is still safe to use offsets if - // a parent element is - // hidden; don safety goggles and see bug #4512 for - // more information). - div.style.display = "none"; - reliableHiddenOffsetsVal = div.getClientRects().length === 0; - if (reliableHiddenOffsetsVal) { - div.style.display = ""; - div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; - div.childNodes[0].style.borderCollapse = "separate"; - contents = div.getElementsByTagName("td"); - contents[0].style.cssText = "margin:0;border:0;padding:0;display:none"; - reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; - if (reliableHiddenOffsetsVal) { - contents[0].style.display = ""; - contents[1].style.display = "none"; - reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; - } - } - - // Teardown - documentElement.removeChild(container); - } - - })(); - - var getStyles, curCSS, rposition = /^(top|right|bottom|left)$/; - - if (window.getComputedStyle) { - getStyles = function(elem) { - - // Support: IE<=11+, Firefox<=30+ (#15098, #14150) - // IE throws on elements created in popups - // FF meanwhile throws on frame elements through - // "defaultView.getComputedStyle" - var view = elem.ownerDocument.defaultView; - - if (!view || !view.opener) { - view = window; - } - - return view.getComputedStyle(elem); - }; - - curCSS = function(elem, name, computed) { - var width, minWidth, maxWidth, ret, style = elem.style; - - computed = computed || getStyles(elem); - - // getPropertyValue is only needed for - // .css('filter') in IE9, see #12537 - ret = computed ? computed.getPropertyValue(name) - || computed[name] : undefined; - - // Support: Opera 12.1x only - // Fall back to style even without computed - // computed is undefined for elems on document - // fragments - if ((ret === "" || ret === undefined) - && !jQuery.contains(elem.ownerDocument, - elem)) { - ret = jQuery.style(elem, name); - } - - if (computed) { - - // A tribute to the "awesome hack by Dean - // Edwards" - // Chrome < 17 and Safari 5.0 uses "computed - // value" - // instead of "used value" for margin-right - // Safari 5.1.7 (at least) returns percentage - // for a larger set of values, - // but width seems to be reliably pixels - // this is against the CSSOM draft spec: - // http://dev.w3.org/csswg/cssom/#resolved-values - if (!support.pixelMarginRight() - && rnumnonpx.test(ret) - && rmargin.test(name)) { - - // Remember the original values - width = style.width; - minWidth = style.minWidth; - maxWidth = style.maxWidth; - - // Put in the new values to get a computed - // value out - style.minWidth = style.maxWidth = style.width = ret; - ret = computed.width; - - // Revert the changed values - style.width = width; - style.minWidth = minWidth; - style.maxWidth = maxWidth; - } - } - - // Support: IE - // IE returns zIndex value as an integer. - return ret === undefined ? ret : ret + ""; - }; - } else if (documentElement.currentStyle) { - getStyles = function(elem) { - return elem.currentStyle; - }; - - curCSS = function(elem, name, computed) { - var left, rs, rsLeft, ret, style = elem.style; - - computed = computed || getStyles(elem); - ret = computed ? computed[name] : undefined; - - // Avoid setting ret to empty string here - // so we don't default to auto - if (ret == null && style && style[name]) { - ret = style[name]; - } - - // From the awesome hack by Dean Edwards - // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 - - // If we're not dealing with a regular pixel number - // but a number that has a weird ending, we need to - // convert it to pixels - // but not position css attributes, as those are - // proportional to the parent element instead - // and we can't measure the parent instead because - // it - // might trigger a "stacking dolls" problem - if (rnumnonpx.test(ret) && !rposition.test(name)) { - - // Remember the original values - left = style.left; - rs = elem.runtimeStyle; - rsLeft = rs && rs.left; - - // Put in the new values to get a computed value - // out - if (rsLeft) { - rs.left = elem.currentStyle.left; - } - style.left = name === "fontSize" ? "1em" : ret; - ret = style.pixelLeft + "px"; - - // Revert the changed values - style.left = left; - if (rsLeft) { - rs.left = rsLeft; - } - } - - // Support: IE - // IE returns zIndex value as an integer. - return ret === undefined ? ret : ret + "" || "auto"; - }; - } - - function addGetHookIf(conditionFn, hookFn) { - - // Define the hook, we'll check on the first run if it's - // really needed. - return { - get : function() { - if (conditionFn()) { - - // Hook not needed (or it's not possible to - // use it due - // to missing dependency), remove it. - delete this.get; - return; - } - - // Hook needed; redefine it so that the support - // test is not executed again. - return (this.get = hookFn).apply(this, - arguments); - } - }; - } - - var - - ralpha = /alpha\([^)]*\)/i, ropacity = /opacity\s*=\s*([^)]*)/i, - - // swappable if display is none or starts with table except - // "table", "table-cell", or "table-caption" - // see here for display values: - // https://developer.mozilla.org/en-US/docs/CSS/display - rdisplayswap = /^(none|table(?!-c[ea]).+)/, rnumsplit = new RegExp( - "^(" + pnum + ")(.*)$", "i"), - - cssShow = { - position : "absolute", - visibility : "hidden", - display : "block" - }, cssNormalTransform = { - letterSpacing : "0", - fontWeight : "400" - }, - - cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], emptyStyle = document - .createElement("div").style; - - // return a css property mapped to a potentially vendor - // prefixed property - function vendorPropName(name) { - - // shortcut for names that are not vendor prefixed - if (name in emptyStyle) { - return name; - } - - // check for vendor prefixed names - var capName = name.charAt(0).toUpperCase() - + name.slice(1), i = cssPrefixes.length; - - while (i--) { - name = cssPrefixes[i] + capName; - if (name in emptyStyle) { - return name; - } - } - } - - function showHide(elements, show) { - var display, elem, hidden, values = [], index = 0, length = elements.length; - - for (; index < length; index++) { - elem = elements[index]; - if (!elem.style) { - continue; - } - - values[index] = jQuery._data(elem, "olddisplay"); - display = elem.style.display; - if (show) { - - // Reset the inline display of this element to - // learn if it is - // being hidden by cascaded rules or not - if (!values[index] && display === "none") { - elem.style.display = ""; - } - - // Set elements which have been overridden with - // display: none - // in a stylesheet to whatever the default - // browser style is - // for such an element - if (elem.style.display === "" && isHidden(elem)) { - values[index] = jQuery._data(elem, - "olddisplay", - defaultDisplay(elem.nodeName)); - } - } else { - hidden = isHidden(elem); - - if (display && display !== "none" || !hidden) { - jQuery._data(elem, "olddisplay", - hidden ? display : jQuery.css(elem, - "display")); - } - } - } - - // Set the display of most of the elements in a second - // loop - // to avoid the constant reflow - for (index = 0; index < length; index++) { - elem = elements[index]; - if (!elem.style) { - continue; - } - if (!show || elem.style.display === "none" - || elem.style.display === "") { - elem.style.display = show ? values[index] || "" - : "none"; - } - } - - return elements; - } - - function setPositiveNumber(elem, value, subtract) { - var matches = rnumsplit.exec(value); - return matches ? - - // Guard against undefined "subtract", e.g., when used - // as in cssHooks - Math.max(0, matches[1] - (subtract || 0)) - + (matches[2] || "px") : value; - } - - function augmentWidthOrHeight(elem, name, extra, - isBorderBox, styles) { - var i = extra === (isBorderBox ? "border" : "content") ? - - // If we already have the right measurement, avoid - // augmentation - 4 : - - // Otherwise initialize for horizontal or vertical - // properties - name === "width" ? 1 : 0, - - val = 0; - - for (; i < 4; i += 2) { - - // both box models exclude margin, so add it if we - // want it - if (extra === "margin") { - val += jQuery.css(elem, extra + cssExpand[i], - true, styles); - } - - if (isBorderBox) { - - // border-box includes padding, so remove it if - // we want content - if (extra === "content") { - val -= jQuery.css(elem, "padding" - + cssExpand[i], true, styles); - } - - // at this point, extra isn't border nor margin, - // so remove border - if (extra !== "margin") { - val -= jQuery.css(elem, "border" - + cssExpand[i] + "Width", true, - styles); - } - } else { - - // at this point, extra isn't content, so add - // padding - val += jQuery.css(elem, "padding" - + cssExpand[i], true, styles); - - // at this point, extra isn't content nor - // padding, so add border - if (extra !== "padding") { - val += jQuery.css(elem, "border" - + cssExpand[i] + "Width", true, - styles); - } - } - } - - return val; - } - - function getWidthOrHeight(elem, name, extra) { - - // Start with offset property, which is equivalent to - // the border-box value - var valueIsBorderBox = true, val = name === "width" ? elem.offsetWidth - : elem.offsetHeight, styles = getStyles(elem), isBorderBox = support.boxSizing - && jQuery.css(elem, "boxSizing", false, styles) === "border-box"; - - // some non-html elements return undefined for - // offsetWidth, so check for null/undefined - // svg - - // https://bugzilla.mozilla.org/show_bug.cgi?id=649285 - // MathML - - // https://bugzilla.mozilla.org/show_bug.cgi?id=491668 - if (val <= 0 || val == null) { - - // Fall back to computed then uncomputed css if - // necessary - val = curCSS(elem, name, styles); - if (val < 0 || val == null) { - val = elem.style[name]; - } - - // Computed unit is not pixels. Stop here and - // return. - if (rnumnonpx.test(val)) { - return val; - } - - // we need the check for style in case a browser - // which returns unreliable values - // for getComputedStyle silently falls back to the - // reliable elem.style - valueIsBorderBox = isBorderBox - && (support.boxSizingReliable() || val === elem.style[name]); - - // Normalize "", auto, and prepare for extra - val = parseFloat(val) || 0; - } - - // use the active box-sizing model to add/subtract - // irrelevant styles - return (val + augmentWidthOrHeight(elem, name, extra - || (isBorderBox ? "border" : "content"), - valueIsBorderBox, styles)) - + "px"; - } - - jQuery - .extend({ - - // Add in style property hooks for overriding - // the default - // behavior of getting and setting a style - // property - cssHooks : { - opacity : { - get : function(elem, computed) { - if (computed) { - - // We should always get a number - // back from opacity - var ret = curCSS(elem, - "opacity"); - return ret === "" ? "1" : ret; - } - } - } - }, - - // Don't automatically add "px" to these - // possibly-unitless properties - cssNumber : { - "animationIterationCount" : true, - "columnCount" : true, - "fillOpacity" : true, - "flexGrow" : true, - "flexShrink" : true, - "fontWeight" : true, - "lineHeight" : true, - "opacity" : true, - "order" : true, - "orphans" : true, - "widows" : true, - "zIndex" : true, - "zoom" : true - }, - - // Add in properties whose names you wish to fix - // before - // setting or getting the value - cssProps : { - - // normalize float css property - "float" : support.cssFloat ? "cssFloat" - : "styleFloat" - }, - - // Get and set the style property on a DOM Node - style : function(elem, name, value, extra) { - - // Don't set styles on text and comment - // nodes - if (!elem || elem.nodeType === 3 - || elem.nodeType === 8 - || !elem.style) { - return; - } - - // Make sure that we're working with the - // right name - var ret, type, hooks, origName = jQuery - .camelCase(name), style = elem.style; - - name = jQuery.cssProps[origName] - || (jQuery.cssProps[origName] = vendorPropName(origName) - || origName); - - // gets hook for the prefixed version - // followed by the unprefixed version - hooks = jQuery.cssHooks[name] - || jQuery.cssHooks[origName]; - - // Check if we're setting a value - if (value !== undefined) { - type = typeof value; - - // Convert "+=" or "-=" to relative - // numbers (#7345) - if (type === "string" - && (ret = rcssNum.exec(value)) - && ret[1]) { - value = adjustCSS(elem, name, ret); - - // Fixes bug #9237 - type = "number"; - } - - // Make sure that null and NaN values - // aren't set. See: #7116 - if (value == null || value !== value) { - return; - } - - // If a number was passed in, add the - // unit (except for certain CSS - // properties) - if (type === "number") { - value += ret - && ret[3] - || (jQuery.cssNumber[origName] ? "" - : "px"); - } - - // Fixes #8908, it can be done more - // correctly by specifing setters in - // cssHooks, - // but it would mean to define eight - // (for every problematic property) - // identical functions - if (!support.clearCloneStyle - && value === "" - && name.indexOf("background") === 0) { - style[name] = "inherit"; - } - - // If a hook was provided, use that - // value, otherwise just set the - // specified value - if (!hooks - || !("set" in hooks) - || (value = hooks.set(elem, - value, extra)) !== undefined) { - - // Support: IE - // Swallow errors from 'invalid' CSS - // values (#5509) - try { - style[name] = value; - } catch (e) { - } - } - - } else { - - // If a hook was provided get the - // non-computed value from there - if (hooks - && "get" in hooks - && (ret = hooks.get(elem, - false, extra)) !== undefined) { - - return ret; - } - - // Otherwise just get the value from the - // style object - return style[name]; - } - }, - - css : function(elem, name, extra, styles) { - var num, val, hooks, origName = jQuery - .camelCase(name); - - // Make sure that we're working with the - // right name - name = jQuery.cssProps[origName] - || (jQuery.cssProps[origName] = vendorPropName(origName) - || origName); - - // gets hook for the prefixed version - // followed by the unprefixed version - hooks = jQuery.cssHooks[name] - || jQuery.cssHooks[origName]; - - // If a hook was provided get the computed - // value from there - if (hooks && "get" in hooks) { - val = hooks.get(elem, true, extra); - } - - // Otherwise, if a way to get the computed - // value exists, use that - if (val === undefined) { - val = curCSS(elem, name, styles); - } - - // convert "normal" to computed value - if (val === "normal" - && name in cssNormalTransform) { - val = cssNormalTransform[name]; - } - - // Return, converting to number if forced or - // a qualifier was provided and val looks - // numeric - if (extra === "" || extra) { - num = parseFloat(val); - return extra === true || isFinite(num) ? num || 0 - : val; - } - return val; - } - }); - - jQuery - .each( - [ "height", "width" ], - function(i, name) { - jQuery.cssHooks[name] = { - get : function(elem, computed, - extra) { - if (computed) { - - // certain elements can have - // dimension info if we - // invisibly show them - // however, it must have a - // current display style - // that would benefit from - // this - return rdisplayswap - .test(jQuery.css( - elem, - "display")) - && elem.offsetWidth === 0 ? swap( - elem, - cssShow, - function() { - return getWidthOrHeight( - elem, - name, - extra); - }) - : getWidthOrHeight( - elem, name, - extra); - } - }, - - set : function(elem, value, extra) { - var styles = extra - && getStyles(elem); - return setPositiveNumber( - elem, - value, - extra ? augmentWidthOrHeight( - elem, - name, - extra, - support.boxSizing - && jQuery - .css( - elem, - "boxSizing", - false, - styles) === "border-box", - styles) - : 0); - } - }; - }); - - if (!support.opacity) { - jQuery.cssHooks.opacity = { - get : function(elem, computed) { - - // IE uses filters for opacity - return ropacity - .test((computed && elem.currentStyle ? elem.currentStyle.filter - : elem.style.filter) - || "") ? (0.01 * parseFloat(RegExp.$1)) - + "" - : computed ? "1" : ""; - }, - - set : function(elem, value) { - var style = elem.style, currentStyle = elem.currentStyle, opacity = jQuery - .isNumeric(value) ? "alpha(opacity=" - + value * 100 + ")" : "", filter = currentStyle - && currentStyle.filter - || style.filter - || ""; - - // IE has trouble with opacity if it does not - // have layout - // Force it by setting the zoom level - style.zoom = 1; - - // if setting opacity to 1, and no other filters - // exist - - // attempt to remove filter attribute #6652 - // if value === "", then remove inline opacity - // #12685 - if ((value >= 1 || value === "") - && jQuery.trim(filter.replace(ralpha, - "")) === "" - && style.removeAttribute) { - - // Setting style.filter to null, "" & " " - // still leave "filter:" in the cssText - // if "filter:" is present at all, clearType - // is disabled, we want to avoid this - // style.removeAttribute is IE Only, but so - // apparently is this code path... - style.removeAttribute("filter"); - - // if there is no filter style applied in a - // css rule - // or unset inline opacity, we are done - if (value === "" || currentStyle - && !currentStyle.filter) { - return; - } - } - - // otherwise, set new filter values - style.filter = ralpha.test(filter) ? filter - .replace(ralpha, opacity) : filter - + " " + opacity; - } - }; - } - - jQuery.cssHooks.marginRight = addGetHookIf( - support.reliableMarginRight, function(elem, - computed) { - if (computed) { - return swap(elem, { - "display" : "inline-block" - }, curCSS, [ elem, "marginRight" ]); - } - }); - - jQuery.cssHooks.marginLeft = addGetHookIf( - support.reliableMarginLeft, - function(elem, computed) { - if (computed) { - return (parseFloat(curCSS(elem, - "marginLeft")) || - - // Support: IE<=11+ - // Running getBoundingClientRect on a - // disconnected node in IE throws an error - // Support: IE8 only - // getClientRects() errors on disconnected - // elems - (jQuery.contains(elem.ownerDocument, elem) ? elem - .getBoundingClientRect().left - - swap( - elem, - { - marginLeft : 0 - }, - function() { - return elem - .getBoundingClientRect().left; - }) - : 0)) - + "px"; - } - }); - - // These hooks are used by animate to expand properties - jQuery - .each( - { - margin : "", - padding : "", - border : "Width" - }, - function(prefix, suffix) { - jQuery.cssHooks[prefix + suffix] = { - expand : function(value) { - var i = 0, expanded = {}, - - // assumes a single number if - // not a string - parts = typeof value === "string" ? value - .split(" ") - : [ value ]; - - for (; i < 4; i++) { - expanded[prefix - + cssExpand[i] - + suffix] = parts[i] - || parts[i - 2] - || parts[0]; - } - - return expanded; - } - }; - - if (!rmargin.test(prefix)) { - jQuery.cssHooks[prefix + suffix].set = setPositiveNumber; - } - }); - - jQuery.fn.extend({ - css : function(name, value) { - return access(this, function(elem, name, value) { - var styles, len, map = {}, i = 0; - - if (jQuery.isArray(name)) { - styles = getStyles(elem); - len = name.length; - - for (; i < len; i++) { - map[name[i]] = jQuery.css(elem, - name[i], false, styles); - } - - return map; - } - - return value !== undefined ? jQuery.style(elem, - name, value) : jQuery.css(elem, name); - }, name, value, arguments.length > 1); - }, - show : function() { - return showHide(this, true); - }, - hide : function() { - return showHide(this); - }, - toggle : function(state) { - if (typeof state === "boolean") { - return state ? this.show() : this.hide(); - } - - return this.each(function() { - if (isHidden(this)) { - jQuery(this).show(); - } else { - jQuery(this).hide(); - } - }); - } - }); - - function Tween(elem, options, prop, end, easing) { - return new Tween.prototype.init(elem, options, prop, - end, easing); - } - jQuery.Tween = Tween; - - Tween.prototype = { - constructor : Tween, - init : function(elem, options, prop, end, easing, unit) { - this.elem = elem; - this.prop = prop; - this.easing = easing || jQuery.easing._default; - this.options = options; - this.start = this.now = this.cur(); - this.end = end; - this.unit = unit - || (jQuery.cssNumber[prop] ? "" : "px"); - }, - cur : function() { - var hooks = Tween.propHooks[this.prop]; - - return hooks && hooks.get ? hooks.get(this) - : Tween.propHooks._default.get(this); - }, - run : function(percent) { - var eased, hooks = Tween.propHooks[this.prop]; - - if (this.options.duration) { - this.pos = eased = jQuery.easing[this.easing]( - percent, this.options.duration - * percent, 0, 1, - this.options.duration); - } else { - this.pos = eased = percent; - } - this.now = (this.end - this.start) * eased - + this.start; - - if (this.options.step) { - this.options.step.call(this.elem, this.now, - this); - } - - if (hooks && hooks.set) { - hooks.set(this); - } else { - Tween.propHooks._default.set(this); - } - return this; - } - }; - - Tween.prototype.init.prototype = Tween.prototype; - - Tween.propHooks = { - _default : { - get : function(tween) { - var result; - - // Use a property on the element directly when - // it is not a DOM element, - // or when there is no matching style property - // that exists. - if (tween.elem.nodeType !== 1 - || tween.elem[tween.prop] != null - && tween.elem.style[tween.prop] == null) { - return tween.elem[tween.prop]; - } - - // passing an empty string as a 3rd parameter to - // .css will automatically - // attempt a parseFloat and fallback to a string - // if the parse fails - // so, simple values such as "10px" are parsed - // to Float. - // complex values such as "rotate(1rad)" are - // returned as is. - result = jQuery.css(tween.elem, tween.prop, ""); - - // Empty strings, null, undefined and "auto" are - // converted to 0. - return !result || result === "auto" ? 0 - : result; - }, - set : function(tween) { - - // use step hook for back compat - use cssHook - // if its there - use .style if its - // available and use plain properties where - // available - if (jQuery.fx.step[tween.prop]) { - jQuery.fx.step[tween.prop](tween); - } else if (tween.elem.nodeType === 1 - && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) { - jQuery.style(tween.elem, tween.prop, - tween.now + tween.unit); - } else { - tween.elem[tween.prop] = tween.now; - } - } - } - }; - - // Support: IE <=9 - // Panic based approach to setting things on disconnected - // nodes - - Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { - set : function(tween) { - if (tween.elem.nodeType && tween.elem.parentNode) { - tween.elem[tween.prop] = tween.now; - } - } - }; - - jQuery.easing = { - linear : function(p) { - return p; - }, - swing : function(p) { - return 0.5 - Math.cos(p * Math.PI) / 2; - }, - _default : "swing" - }; - - jQuery.fx = Tween.prototype.init; - - // Back Compat <1.8 extension point - jQuery.fx.step = {}; - - var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; - - // Animations created synchronously will run synchronously - function createFxNow() { - window.setTimeout(function() { - fxNow = undefined; - }); - return (fxNow = jQuery.now()); - } - - // Generate parameters to create a standard animation - function genFx(type, includeWidth) { - var which, attrs = { - height : type - }, i = 0; - - // if we include width, step value is 1 to do all - // cssExpand values, - // if we don't include width, step value is 2 to skip - // over Left and Right - includeWidth = includeWidth ? 1 : 0; - for (; i < 4; i += 2 - includeWidth) { - which = cssExpand[i]; - attrs["margin" + which] = attrs["padding" + which] = type; - } - - if (includeWidth) { - attrs.opacity = attrs.width = type; - } - - return attrs; - } - - function createTween(value, prop, animation) { - var tween, collection = (Animation.tweeners[prop] || []) - .concat(Animation.tweeners["*"]), index = 0, length = collection.length; - for (; index < length; index++) { - if ((tween = collection[index].call(animation, - prop, value))) { - - // we're done with this property - return tween; - } - } - } - - function defaultPrefilter(elem, props, opts) { - /* jshint validthis: true */ - var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType - && isHidden(elem), dataShow = jQuery._data( - elem, "fxshow"); - - // handle queue: false promises - if (!opts.queue) { - hooks = jQuery._queueHooks(elem, "fx"); - if (hooks.unqueued == null) { - hooks.unqueued = 0; - oldfire = hooks.empty.fire; - hooks.empty.fire = function() { - if (!hooks.unqueued) { - oldfire(); - } - }; - } - hooks.unqueued++; - - anim.always(function() { - - // doing this makes sure that the complete - // handler will be called - // before this completes - anim.always(function() { - hooks.unqueued--; - if (!jQuery.queue(elem, "fx").length) { - hooks.empty.fire(); - } - }); - }); - } - - // height/width overflow pass - if (elem.nodeType === 1 - && ("height" in props || "width" in props)) { - - // Make sure that nothing sneaks out - // Record all 3 overflow attributes because IE does - // not - // change the overflow attribute when overflowX and - // overflowY are set to the same value - opts.overflow = [ style.overflow, style.overflowX, - style.overflowY ]; - - // Set display property to inline-block for - // height/width - // animations on inline elements that are having - // width/height animated - display = jQuery.css(elem, "display"); - - // Test default display if display is currently - // "none" - checkDisplay = display === "none" ? jQuery._data( - elem, "olddisplay") - || defaultDisplay(elem.nodeName) : display; - - if (checkDisplay === "inline" - && jQuery.css(elem, "float") === "none") { - - // inline-level elements accept inline-block; - // block-level elements need to be inline with - // layout - if (!support.inlineBlockNeedsLayout - || defaultDisplay(elem.nodeName) === "inline") { - style.display = "inline-block"; - } else { - style.zoom = 1; - } - } - } - - if (opts.overflow) { - style.overflow = "hidden"; - if (!support.shrinkWrapBlocks()) { - anim.always(function() { - style.overflow = opts.overflow[0]; - style.overflowX = opts.overflow[1]; - style.overflowY = opts.overflow[2]; - }); - } - } - - // show/hide pass - for (prop in props) { - value = props[prop]; - if (rfxtypes.exec(value)) { - delete props[prop]; - toggle = toggle || value === "toggle"; - if (value === (hidden ? "hide" : "show")) { - - // If there is dataShow left over from a - // stopped hide or show - // and we are going to proceed with show, we - // should pretend to be hidden - if (value === "show" && dataShow - && dataShow[prop] !== undefined) { - hidden = true; - } else { - continue; - } - } - orig[prop] = dataShow && dataShow[prop] - || jQuery.style(elem, prop); - - // Any non-fx value stops us from restoring the - // original display value - } else { - display = undefined; - } - } - - if (!jQuery.isEmptyObject(orig)) { - if (dataShow) { - if ("hidden" in dataShow) { - hidden = dataShow.hidden; - } - } else { - dataShow = jQuery._data(elem, "fxshow", {}); - } - - // store state if its toggle - enables - // .stop().toggle() to "reverse" - if (toggle) { - dataShow.hidden = !hidden; - } - if (hidden) { - jQuery(elem).show(); - } else { - anim.done(function() { - jQuery(elem).hide(); - }); - } - anim.done(function() { - var prop; - jQuery._removeData(elem, "fxshow"); - for (prop in orig) { - jQuery.style(elem, prop, orig[prop]); - } - }); - for (prop in orig) { - tween = createTween( - hidden ? dataShow[prop] : 0, prop, anim); - - if (!(prop in dataShow)) { - dataShow[prop] = tween.start; - if (hidden) { - tween.end = tween.start; - tween.start = prop === "width" - || prop === "height" ? 1 : 0; - } - } - } - - // If this is a noop like .hide().hide(), restore an - // overwritten display value - } else if ((display === "none" ? defaultDisplay(elem.nodeName) - : display) === "inline") { - style.display = display; - } - } - - function propFilter(props, specialEasing) { - var index, name, easing, value, hooks; - - // camelCase, specialEasing and expand cssHook pass - for (index in props) { - name = jQuery.camelCase(index); - easing = specialEasing[name]; - value = props[index]; - if (jQuery.isArray(value)) { - easing = value[1]; - value = props[index] = value[0]; - } - - if (index !== name) { - props[name] = value; - delete props[index]; - } - - hooks = jQuery.cssHooks[name]; - if (hooks && "expand" in hooks) { - value = hooks.expand(value); - delete props[name]; - - // not quite $.extend, this wont overwrite keys - // already present. - // also - reusing 'index' from above because we - // have the correct "name" - for (index in value) { - if (!(index in props)) { - props[index] = value[index]; - specialEasing[index] = easing; - } - } - } else { - specialEasing[name] = easing; - } - } - } - - function Animation(elem, properties, options) { - var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery - .Deferred().always(function() { - - // don't match elem in the :animated - // selector - delete tick.elem; - }), tick = function() { - if (stopped) { - return false; - } - var currentTime = fxNow || createFxNow(), remaining = Math - .max(0, animation.startTime - + animation.duration - currentTime), - - // Support: Android 2.3 - // Archaic crash bug won't allow us to use `1 - ( - // 0.5 || 0 )` (#12497) - temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; - - for (; index < length; index++) { - animation.tweens[index].run(percent); - } - - deferred.notifyWith(elem, [ animation, percent, - remaining ]); - - if (percent < 1 && length) { - return remaining; - } else { - deferred.resolveWith(elem, [ animation ]); - return false; - } - }, animation = deferred.promise({ - elem : elem, - props : jQuery.extend({}, properties), - opts : jQuery.extend(true, { - specialEasing : {}, - easing : jQuery.easing._default - }, options), - originalProperties : properties, - originalOptions : options, - startTime : fxNow || createFxNow(), - duration : options.duration, - tweens : [], - createTween : function(prop, end) { - var tween = jQuery.Tween(elem, animation.opts, - prop, end, - animation.opts.specialEasing[prop] - || animation.opts.easing); - animation.tweens.push(tween); - return tween; - }, - stop : function(gotoEnd) { - var index = 0, - - // if we are going to the end, we want to run - // all the tweens - // otherwise we skip this part - length = gotoEnd ? animation.tweens.length : 0; - if (stopped) { - return this; - } - stopped = true; - for (; index < length; index++) { - animation.tweens[index].run(1); - } - - // resolve when we played the last frame - // otherwise, reject - if (gotoEnd) { - deferred.notifyWith(elem, - [ animation, 1, 0 ]); - deferred.resolveWith(elem, [ animation, - gotoEnd ]); - } else { - deferred.rejectWith(elem, [ animation, - gotoEnd ]); - } - return this; - } - }), props = animation.props; - - propFilter(props, animation.opts.specialEasing); - - for (; index < length; index++) { - result = Animation.prefilters[index].call( - animation, elem, props, animation.opts); - if (result) { - if (jQuery.isFunction(result.stop)) { - jQuery._queueHooks(animation.elem, - animation.opts.queue).stop = jQuery - .proxy(result.stop, result); - } - return result; - } - } - - jQuery.map(props, createTween, animation); - - if (jQuery.isFunction(animation.opts.start)) { - animation.opts.start.call(elem, animation); - } - - jQuery.fx.timer(jQuery.extend(tick, { - elem : elem, - anim : animation, - queue : animation.opts.queue - })); - - // attach callbacks from options - return animation.progress(animation.opts.progress) - .done(animation.opts.done, - animation.opts.complete).fail( - animation.opts.fail).always( - animation.opts.always); - } - - jQuery.Animation = jQuery - .extend( - Animation, - { - - tweeners : { - "*" : [ function(prop, value) { - var tween = this.createTween( - prop, value); - adjustCSS(tween.elem, prop, - rcssNum.exec(value), - tween); - return tween; - } ] - }, - - tweener : function(props, callback) { - if (jQuery.isFunction(props)) { - callback = props; - props = [ "*" ]; - } else { - props = props.match(rnotwhite); - } - - var prop, index = 0, length = props.length; - - for (; index < length; index++) { - prop = props[index]; - Animation.tweeners[prop] = Animation.tweeners[prop] - || []; - Animation.tweeners[prop] - .unshift(callback); - } - }, - - prefilters : [ defaultPrefilter ], - - prefilter : function(callback, prepend) { - if (prepend) { - Animation.prefilters - .unshift(callback); - } else { - Animation.prefilters - .push(callback); - } - } - }); - - jQuery.speed = function(speed, easing, fn) { - var opt = speed && typeof speed === "object" ? jQuery - .extend({}, speed) : { - complete : fn || !fn && easing - || jQuery.isFunction(speed) && speed, - duration : speed, - easing : fn && easing || easing - && !jQuery.isFunction(easing) && easing - }; - - opt.duration = jQuery.fx.off ? 0 - : typeof opt.duration === "number" ? opt.duration - : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] - : jQuery.fx.speeds._default; - - // normalize opt.queue - true/undefined/null -> "fx" - if (opt.queue == null || opt.queue === true) { - opt.queue = "fx"; - } - - // Queueing - opt.old = opt.complete; - - opt.complete = function() { - if (jQuery.isFunction(opt.old)) { - opt.old.call(this); - } - - if (opt.queue) { - jQuery.dequeue(this, opt.queue); - } - }; - - return opt; - }; - - jQuery.fn - .extend({ - fadeTo : function(speed, to, easing, callback) { - - // show any hidden elements after setting - // opacity to 0 - return this.filter(isHidden).css("opacity", - 0).show() - - // animate to the value specified - .end().animate({ - opacity : to - }, speed, easing, callback); - }, - animate : function(prop, speed, easing, - callback) { - var empty = jQuery.isEmptyObject(prop), optall = jQuery - .speed(speed, easing, callback), doAnimation = function() { - - // Operate on a copy of prop so - // per-property easing won't be lost - var anim = Animation(this, jQuery - .extend({}, prop), optall); - - // Empty animations, or finishing - // resolves immediately - if (empty - || jQuery._data(this, "finish")) { - anim.stop(true); - } - }; - doAnimation.finish = doAnimation; - - return empty || optall.queue === false ? this - .each(doAnimation) - : this.queue(optall.queue, - doAnimation); - }, - stop : function(type, clearQueue, gotoEnd) { - var stopQueue = function(hooks) { - var stop = hooks.stop; - delete hooks.stop; - stop(gotoEnd); - }; - - if (typeof type !== "string") { - gotoEnd = clearQueue; - clearQueue = type; - type = undefined; - } - if (clearQueue && type !== false) { - this.queue(type || "fx", []); - } - - return this - .each(function() { - var dequeue = true, index = type != null - && type + "queueHooks", timers = jQuery.timers, data = jQuery - ._data(this); - - if (index) { - if (data[index] - && data[index].stop) { - stopQueue(data[index]); - } - } else { - for (index in data) { - if (data[index] - && data[index].stop - && rrun - .test(index)) { - stopQueue(data[index]); - } - } - } - - for (index = timers.length; index--;) { - if (timers[index].elem === this - && (type == null || timers[index].queue === type)) { - - timers[index].anim - .stop(gotoEnd); - dequeue = false; - timers.splice(index, 1); - } - } - - // start the next in the queue - // if the last step wasn't - // forced - // timers currently will call - // their complete callbacks, - // which will dequeue - // but only if they were gotoEnd - if (dequeue || !gotoEnd) { - jQuery.dequeue(this, type); - } - }); - }, - finish : function(type) { - if (type !== false) { - type = type || "fx"; - } - return this - .each(function() { - var index, data = jQuery - ._data(this), queue = data[type - + "queue"], hooks = data[type - + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length - : 0; - - // enable finishing flag on - // private data - data.finish = true; - - // empty the queue first - jQuery.queue(this, type, []); - - if (hooks && hooks.stop) { - hooks.stop.call(this, true); - } - - // look for any active - // animations, and finish them - for (index = timers.length; index--;) { - if (timers[index].elem === this - && timers[index].queue === type) { - timers[index].anim - .stop(true); - timers.splice(index, 1); - } - } - - // look for any animations in - // the old queue and finish them - for (index = 0; index < length; index++) { - if (queue[index] - && queue[index].finish) { - queue[index].finish - .call(this); - } - } - - // turn off finishing flag - delete data.finish; - }); - } - }); - - jQuery - .each( - [ "toggle", "show", "hide" ], - function(i, name) { - var cssFn = jQuery.fn[name]; - jQuery.fn[name] = function(speed, - easing, callback) { - return speed == null - || typeof speed === "boolean" ? cssFn - .apply(this, arguments) - : this.animate(genFx(name, - true), speed, - easing, callback); - }; - }); - - // Generate shortcuts for custom animations - jQuery.each({ - slideDown : genFx("show"), - slideUp : genFx("hide"), - slideToggle : genFx("toggle"), - fadeIn : { - opacity : "show" - }, - fadeOut : { - opacity : "hide" - }, - fadeToggle : { - opacity : "toggle" - } - }, - function(name, props) { - jQuery.fn[name] = function(speed, easing, - callback) { - return this.animate(props, speed, easing, - callback); - }; - }); - - jQuery.timers = []; - jQuery.fx.tick = function() { - var timer, timers = jQuery.timers, i = 0; - - fxNow = jQuery.now(); - - for (; i < timers.length; i++) { - timer = timers[i]; - - // Checks the timer has not already been removed - if (!timer() && timers[i] === timer) { - timers.splice(i--, 1); - } - } - - if (!timers.length) { - jQuery.fx.stop(); - } - fxNow = undefined; - }; - - jQuery.fx.timer = function(timer) { - jQuery.timers.push(timer); - if (timer()) { - jQuery.fx.start(); - } else { - jQuery.timers.pop(); - } - }; - - jQuery.fx.interval = 13; - - jQuery.fx.start = function() { - if (!timerId) { - timerId = window.setInterval(jQuery.fx.tick, - jQuery.fx.interval); - } - }; - - jQuery.fx.stop = function() { - window.clearInterval(timerId); - timerId = null; - }; - - jQuery.fx.speeds = { - slow : 600, - fast : 200, - - // Default speed - _default : 400 - }; - - // Based off of the plugin by Clint Helfers, with - // permission. - // http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ - jQuery.fn.delay = function(time, type) { - time = jQuery.fx ? jQuery.fx.speeds[time] || time - : time; - type = type || "fx"; - - return this.queue(type, function(next, hooks) { - var timeout = window.setTimeout(next, time); - hooks.stop = function() { - window.clearTimeout(timeout); - }; - }); - }; - - (function() { - var a, input = document.createElement("input"), div = document - .createElement("div"), select = document - .createElement("select"), opt = select - .appendChild(document.createElement("option")); - - // Setup - div = document.createElement("div"); - div.setAttribute("className", "t"); - div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; - a = div.getElementsByTagName("a")[0]; - - // Support: Windows Web Apps (WWA) - // `type` must use .setAttribute for WWA (#14901) - input.setAttribute("type", "checkbox"); - div.appendChild(input); - - a = div.getElementsByTagName("a")[0]; - - // First batch of tests. - a.style.cssText = "top:1px"; - - // Test setAttribute on camelCase class. - // If it works, we need attrFixes when doing - // get/setAttribute (ie6/7) - support.getSetAttribute = div.className !== "t"; - - // Get the style information from getAttribute - // (IE uses .cssText instead) - support.style = /top/.test(a.getAttribute("style")); - - // Make sure that URLs aren't manipulated - // (IE normalizes it by default) - support.hrefNormalized = a.getAttribute("href") === "/a"; - - // Check the default checkbox/radio value ("" on WebKit; - // "on" elsewhere) - support.checkOn = !!input.value; - - // Make sure that a selected-by-default option has a - // working selected property. - // (WebKit defaults to false instead of true, IE too, if - // it's in an optgroup) - support.optSelected = opt.selected; - - // Tests for enctype support on a form (#6743) - support.enctype = !!document.createElement("form").enctype; - - // Make sure that the options inside disabled selects - // aren't marked as disabled - // (WebKit marks them as disabled) - select.disabled = true; - support.optDisabled = !opt.disabled; - - // Support: IE8 only - // Check if we can trust getAttribute("value") - input = document.createElement("input"); - input.setAttribute("value", ""); - support.input = input.getAttribute("value") === ""; - - // Check if an input maintains its value after becoming - // a radio - input.value = "t"; - input.setAttribute("type", "radio"); - support.radioValue = input.value === "t"; - })(); - - var rreturn = /\r/g, rspaces = /[\x20\t\r\n\f]+/g; - - jQuery.fn - .extend({ - val : function(value) { - var hooks, ret, isFunction, elem = this[0]; - - if (!arguments.length) { - if (elem) { - hooks = jQuery.valHooks[elem.type] - || jQuery.valHooks[elem.nodeName - .toLowerCase()]; - - if (hooks - && "get" in hooks - && (ret = hooks.get(elem, - "value")) !== undefined) { - return ret; - } - - ret = elem.value; - - return typeof ret === "string" ? - - // handle most common string cases - ret.replace(rreturn, "") : - - // handle cases where value is - // null/undef or number - ret == null ? "" : ret; - } - - return; - } - - isFunction = jQuery.isFunction(value); - - return this - .each(function(i) { - var val; - - if (this.nodeType !== 1) { - return; - } - - if (isFunction) { - val = value.call(this, i, - jQuery(this).val()); - } else { - val = value; - } - - // Treat null/undefined as ""; - // convert numbers to string - if (val == null) { - val = ""; - } else if (typeof val === "number") { - val += ""; - } else if (jQuery.isArray(val)) { - val = jQuery - .map( - val, - function( - value) { - return value == null ? "" - : value - + ""; - }); - } - - hooks = jQuery.valHooks[this.type] - || jQuery.valHooks[this.nodeName - .toLowerCase()]; - - // If set returns undefined, - // fall back to normal setting - if (!hooks - || !("set" in hooks) - || hooks.set(this, val, - "value") === undefined) { - this.value = val; - } - }); - } - }); - - jQuery - .extend({ - valHooks : { - option : { - get : function(elem) { - var val = jQuery.find.attr(elem, - "value"); - return val != null ? val : - - // Support: IE10-11+ - // option.text throws exceptions - // (#14686, #14858) - // Strip and collapse whitespace - // https://html.spec.whatwg.org/#strip-and-collapse-whitespace - jQuery.trim(jQuery.text(elem)) - .replace(rspaces, " "); - } - }, - select : { - get : function(elem) { - var value, option, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one" - || index < 0, values = one ? null - : [], max = one ? index + 1 - : options.length, i = index < 0 ? max - : one ? index : 0; - - // Loop through all the selected - // options - for (; i < max; i++) { - option = options[i]; - - // oldIE doesn't update selected - // after form reset (#2551) - if ((option.selected || i === index) - && - - // Don't return options - // that are disabled or - // in a disabled - // optgroup - (support.optDisabled ? !option.disabled - : option - .getAttribute("disabled") === null) - && (!option.parentNode.disabled || !jQuery - .nodeName( - option.parentNode, - "optgroup"))) { - - // Get the specific value - // for the option - value = jQuery(option) - .val(); - - // We don't need an array - // for one selects - if (one) { - return value; - } - - // Multi-Selects return an - // array - values.push(value); - } - } - - return values; - }, - - set : function(elem, value) { - var optionSet, option, options = elem.options, values = jQuery - .makeArray(value), i = options.length; - - while (i--) { - option = options[i]; - - if (jQuery.inArray( - jQuery.valHooks.option - .get(option), - values) > -1) { - - // Support: IE6 - // When new option element - // is added to select box we - // need to - // force reflow of newly - // added node in order to - // workaround delay - // of initialization - // properties - try { - option.selected = optionSet = true; - - } catch (_) { - - // Will be executed only - // in IE6 - option.scrollHeight; - } - - } else { - option.selected = false; - } - } - - // Force browsers to behave - // consistently when non-matching - // value is set - if (!optionSet) { - elem.selectedIndex = -1; - } - - return options; - } - } - } - }); - - // Radios and checkboxes getter/setter - jQuery - .each( - [ "radio", "checkbox" ], - function() { - jQuery.valHooks[this] = { - set : function(elem, value) { - if (jQuery.isArray(value)) { - return (elem.checked = jQuery - .inArray( - jQuery(elem) - .val(), - value) > -1); - } - } - }; - if (!support.checkOn) { - jQuery.valHooks[this].get = function( - elem) { - return elem - .getAttribute("value") === null ? "on" - : elem.value; - }; - } - }); - - var nodeHook, boolHook, attrHandle = jQuery.expr.attrHandle, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = support.getSetAttribute, getSetInput = support.input; - - jQuery.fn.extend({ - attr : function(name, value) { - return access(this, jQuery.attr, name, value, - arguments.length > 1); - }, - - removeAttr : function(name) { - return this.each(function() { - jQuery.removeAttr(this, name); - }); - } - }); - - jQuery - .extend({ - attr : function(elem, name, value) { - var ret, hooks, nType = elem.nodeType; - - // Don't get/set attributes on text, comment - // and attribute nodes - if (nType === 3 || nType === 8 - || nType === 2) { - return; - } - - // Fallback to prop when attributes are not - // supported - if (typeof elem.getAttribute === "undefined") { - return jQuery.prop(elem, name, value); - } - - // All attributes are lowercase - // Grab necessary hook if one is defined - if (nType !== 1 || !jQuery.isXMLDoc(elem)) { - name = name.toLowerCase(); - hooks = jQuery.attrHooks[name] - || (jQuery.expr.match.bool - .test(name) ? boolHook - : nodeHook); - } - - if (value !== undefined) { - if (value === null) { - jQuery.removeAttr(elem, name); - return; - } - - if (hooks - && "set" in hooks - && (ret = hooks.set(elem, - value, name)) !== undefined) { - return ret; - } - - elem.setAttribute(name, value + ""); - return value; - } - - if (hooks - && "get" in hooks - && (ret = hooks.get(elem, name)) !== null) { - return ret; - } - - ret = jQuery.find.attr(elem, name); - - // Non-existent attributes return null, we - // normalize to undefined - return ret == null ? undefined : ret; - }, - - attrHooks : { - type : { - set : function(elem, value) { - if (!support.radioValue - && value === "radio" - && jQuery.nodeName(elem, - "input")) { - - // Setting the type on a radio - // button after the value resets - // the value in IE8-9 - // Reset value to default in - // case type is set after value - // during creation - var val = elem.value; - elem - .setAttribute("type", - value); - if (val) { - elem.value = val; - } - return value; - } - } - } - }, - - removeAttr : function(elem, value) { - var name, propName, i = 0, attrNames = value - && value.match(rnotwhite); - - if (attrNames && elem.nodeType === 1) { - while ((name = attrNames[i++])) { - propName = jQuery.propFix[name] - || name; - - // Boolean attributes get special - // treatment (#10870) - if (jQuery.expr.match.bool - .test(name)) { - - // Set corresponding property to - // false - if (getSetInput - && getSetAttribute - || !ruseDefault - .test(name)) { - elem[propName] = false; - - // Support: IE<9 - // Also clear - // defaultChecked/defaultSelected - // (if appropriate) - } else { - elem[jQuery - .camelCase("default-" - + name)] = elem[propName] = false; - } - - // See #9699 for explanation of - // this approach (setting first, - // then removal) - } else { - jQuery.attr(elem, name, ""); - } - - elem - .removeAttribute(getSetAttribute ? name - : propName); - } - } - } - }); - - // Hooks for boolean attributes - boolHook = { - set : function(elem, value, name) { - if (value === false) { - - // Remove boolean attributes when set to false - jQuery.removeAttr(elem, name); - } else if (getSetInput && getSetAttribute - || !ruseDefault.test(name)) { - - // IE<8 needs the *property* name - elem.setAttribute(!getSetAttribute - && jQuery.propFix[name] || name, name); - - } else { - - // Support: IE<9 - // Use defaultChecked and defaultSelected for - // oldIE - elem[jQuery.camelCase("default-" + name)] = elem[name] = true; - } - return name; - } - }; - - jQuery - .each( - jQuery.expr.match.bool.source.match(/\w+/g), - function(i, name) { - var getter = attrHandle[name] - || jQuery.find.attr; - - if (getSetInput && getSetAttribute - || !ruseDefault.test(name)) { - attrHandle[name] = function(elem, - name, isXML) { - var ret, handle; - if (!isXML) { - - // Avoid an infinite loop by - // temporarily removing this - // function from the getter - handle = attrHandle[name]; - attrHandle[name] = ret; - ret = getter(elem, name, - isXML) != null ? name - .toLowerCase() - : null; - attrHandle[name] = handle; - } - return ret; - }; - } else { - attrHandle[name] = function(elem, - name, isXML) { - if (!isXML) { - return elem[jQuery - .camelCase("default-" - + name)] ? name - .toLowerCase() - : null; - } - }; - } - }); - - // fix oldIE attroperties - if (!getSetInput || !getSetAttribute) { - jQuery.attrHooks.value = { - set : function(elem, value, name) { - if (jQuery.nodeName(elem, "input")) { - - // Does not return so that setAttribute is - // also used - elem.defaultValue = value; - } else { - - // Use nodeHook if defined (#1954); - // otherwise setAttribute is fine - return nodeHook - && nodeHook.set(elem, value, name); - } - } - }; - } - - // IE6/7 do not support getting/setting some attributes with - // get/setAttribute - if (!getSetAttribute) { - - // Use this for any attribute in IE6/7 - // This fixes almost every IE6/7 issue - nodeHook = { - set : function(elem, value, name) { - - // Set the existing or create a new attribute - // node - var ret = elem.getAttributeNode(name); - if (!ret) { - elem - .setAttributeNode((ret = elem.ownerDocument - .createAttribute(name))); - } - - ret.value = value += ""; - - // Break association with cloned elements by - // also using setAttribute (#9646) - if (name === "value" - || value === elem.getAttribute(name)) { - return value; - } - } - }; - - // Some attributes are constructed with empty-string - // values when not defined - attrHandle.id = attrHandle.name = attrHandle.coords = function( - elem, name, isXML) { - var ret; - if (!isXML) { - return (ret = elem.getAttributeNode(name)) - && ret.value !== "" ? ret.value : null; - } - }; - - // Fixing value retrieval on a button requires this - // module - jQuery.valHooks.button = { - get : function(elem, name) { - var ret = elem.getAttributeNode(name); - if (ret && ret.specified) { - return ret.value; - } - }, - set : nodeHook.set - }; - - // Set contenteditable to false on removals(#10429) - // Setting to empty string throws an error as an invalid - // value - jQuery.attrHooks.contenteditable = { - set : function(elem, value, name) { - nodeHook.set(elem, - value === "" ? false : value, name); - } - }; - - // Set width and height to auto instead of 0 on empty - // string( Bug #8150 ) - // This is for removals - jQuery.each([ "width", "height" ], function(i, name) { - jQuery.attrHooks[name] = { - set : function(elem, value) { - if (value === "") { - elem.setAttribute(name, "auto"); - return value; - } - } - }; - }); - } - - if (!support.style) { - jQuery.attrHooks.style = { - get : function(elem) { - - // Return undefined in the case of empty string - // Note: IE uppercases css property names, but - // if we were to .toLowerCase() - // .cssText, that would destroy case sensitivity - // in URL's, like in "background" - return elem.style.cssText || undefined; - }, - set : function(elem, value) { - return (elem.style.cssText = value + ""); - } - }; - } - - var rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i; - - jQuery.fn.extend({ - prop : function(name, value) { - return access(this, jQuery.prop, name, value, - arguments.length > 1); - }, - - removeProp : function(name) { - name = jQuery.propFix[name] || name; - return this.each(function() { - - // try/catch handles cases where IE balks (such - // as removing a property on window) - try { - this[name] = undefined; - delete this[name]; - } catch (e) { - } - }); - } - }); - - jQuery - .extend({ - prop : function(elem, name, value) { - var ret, hooks, nType = elem.nodeType; - - // Don't get/set properties on text, comment - // and attribute nodes - if (nType === 3 || nType === 8 - || nType === 2) { - return; - } - - if (nType !== 1 || !jQuery.isXMLDoc(elem)) { - - // Fix name and attach hooks - name = jQuery.propFix[name] || name; - hooks = jQuery.propHooks[name]; - } - - if (value !== undefined) { - if (hooks - && "set" in hooks - && (ret = hooks.set(elem, - value, name)) !== undefined) { - return ret; - } - - return (elem[name] = value); - } - - if (hooks - && "get" in hooks - && (ret = hooks.get(elem, name)) !== null) { - return ret; - } - - return elem[name]; - }, - - propHooks : { - tabIndex : { - get : function(elem) { - - // elem.tabIndex doesn't always - // return the - // correct value when it hasn't been - // explicitly set - // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ - // Use proper attribute - // retrieval(#12072) - var tabindex = jQuery.find.attr( - elem, "tabindex"); - - return tabindex ? parseInt( - tabindex, 10) - : rfocusable - .test(elem.nodeName) - || rclickable - .test(elem.nodeName) - && elem.href ? 0 - : -1; - } - } - }, - - propFix : { - "for" : "htmlFor", - "class" : "className" - } - }); - - // Some attributes require a special call on IE - // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx - if (!support.hrefNormalized) { - - // href/src property should get the full normalized URL - // (#10299/#12915) - jQuery.each([ "href", "src" ], function(i, name) { - jQuery.propHooks[name] = { - get : function(elem) { - return elem.getAttribute(name, 4); - } - }; - }); - } - - // Support: Safari, IE9+ - // Accessing the selectedIndex property - // forces the browser to respect setting selected - // on the option - // The getter ensures a default option is selected - // when in an optgroup - if (!support.optSelected) { - jQuery.propHooks.selected = { - get : function(elem) { - var parent = elem.parentNode; - - if (parent) { - parent.selectedIndex; - - // Make sure that it also works with - // optgroups, see #5701 - if (parent.parentNode) { - parent.parentNode.selectedIndex; - } - } - return null; - }, - set : function(elem) { - var parent = elem.parentNode; - if (parent) { - parent.selectedIndex; - - if (parent.parentNode) { - parent.parentNode.selectedIndex; - } - } - } - }; - } - - jQuery.each([ "tabIndex", "readOnly", "maxLength", - "cellSpacing", "cellPadding", "rowSpan", "colSpan", - "useMap", "frameBorder", "contentEditable" ], - function() { - jQuery.propFix[this.toLowerCase()] = this; - }); - - // IE6/7 call enctype encoding - if (!support.enctype) { - jQuery.propFix.enctype = "encoding"; - } - - var rclass = /[\t\r\n\f]/g; - - function getClass(elem) { - return jQuery.attr(elem, "class") || ""; - } - - jQuery.fn - .extend({ - addClass : function(value) { - var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; - - if (jQuery.isFunction(value)) { - return this.each(function(j) { - jQuery(this).addClass( - value.call(this, j, - getClass(this))); - }); - } - - if (typeof value === "string" && value) { - classes = value.match(rnotwhite) || []; - - while ((elem = this[i++])) { - curValue = getClass(elem); - cur = elem.nodeType === 1 - && (" " + curValue + " ") - .replace(rclass, - " "); - - if (cur) { - j = 0; - while ((clazz = classes[j++])) { - if (cur.indexOf(" " + clazz - + " ") < 0) { - cur += clazz + " "; - } - } - - // only assign if different to - // avoid unneeded rendering. - finalValue = jQuery.trim(cur); - if (curValue !== finalValue) { - jQuery.attr(elem, "class", - finalValue); - } - } - } - } - - return this; - }, - - removeClass : function(value) { - var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; - - if (jQuery.isFunction(value)) { - return this.each(function(j) { - jQuery(this).removeClass( - value.call(this, j, - getClass(this))); - }); - } - - if (!arguments.length) { - return this.attr("class", ""); - } - - if (typeof value === "string" && value) { - classes = value.match(rnotwhite) || []; - - while ((elem = this[i++])) { - curValue = getClass(elem); - - // This expression is here for - // better compressibility (see - // addClass) - cur = elem.nodeType === 1 - && (" " + curValue + " ") - .replace(rclass, - " "); - - if (cur) { - j = 0; - while ((clazz = classes[j++])) { - - // Remove *all* instances - while (cur.indexOf(" " - + clazz + " ") > -1) { - cur = cur.replace(" " - + clazz + " ", - " "); - } - } - - // Only assign if different to - // avoid unneeded rendering. - finalValue = jQuery.trim(cur); - if (curValue !== finalValue) { - jQuery.attr(elem, "class", - finalValue); - } - } - } - } - - return this; - }, - - toggleClass : function(value, stateVal) { - var type = typeof value; - - if (typeof stateVal === "boolean" - && type === "string") { - return stateVal ? this.addClass(value) - : this.removeClass(value); - } - - if (jQuery.isFunction(value)) { - return this - .each(function(i) { - jQuery(this) - .toggleClass( - value - .call( - this, - i, - getClass(this), - stateVal), - stateVal); - }); - } - - return this - .each(function() { - var className, i, self, classNames; - - if (type === "string") { - - // Toggle individual class - // names - i = 0; - self = jQuery(this); - classNames = value - .match(rnotwhite) - || []; - - while ((className = classNames[i++])) { - - // Check each className - // given, space - // separated list - if (self - .hasClass(className)) { - self - .removeClass(className); - } else { - self - .addClass(className); - } - } - - // Toggle whole class name - } else if (value === undefined - || type === "boolean") { - className = getClass(this); - if (className) { - - // store className if - // set - jQuery - ._data( - this, - "__className__", - className); - } - - // If the element has a - // class name or if we're - // passed "false", - // then remove the whole - // classname (if there was - // one, the above saved it). - // Otherwise bring back - // whatever was previously - // saved (if anything), - // falling back to the empty - // string if nothing was - // stored. - jQuery - .attr( - this, - "class", - className - || value === false ? "" - : jQuery - ._data( - this, - "__className__") - || ""); - } - }); - }, - - hasClass : function(selector) { - var className, elem, i = 0; - - className = " " + selector + " "; - while ((elem = this[i++])) { - if (elem.nodeType === 1 - && (" " + getClass(elem) + " ") - .replace(rclass, " ") - .indexOf(className) > -1) { - return true; - } - } - - return false; - } - }); - - // Return jQuery for attributes-only inclusion - - jQuery - .each( - ("blur focus focusin focusout load resize scroll unload click dblclick " - + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " - + "change select submit keydown keypress keyup error contextmenu") - .split(" "), function(i, name) { - - // Handle event binding - jQuery.fn[name] = function(data, fn) { - return arguments.length > 0 ? this - .on(name, null, data, fn) - : this.trigger(name); - }; - }); - - jQuery.fn.extend({ - hover : function(fnOver, fnOut) { - return this.mouseenter(fnOver).mouseleave( - fnOut || fnOver); - } - }); - - var location = window.location; - - var nonce = jQuery.now(); - - var rquery = (/\?/); - - var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g; - - jQuery.parseJSON = function(data) { - - // Attempt to parse using the native JSON parser first - if (window.JSON && window.JSON.parse) { - - // Support: Android 2.3 - // Workaround failure to string-cast null input - return window.JSON.parse(data + ""); - } - - var requireNonComma, depth = null, str = jQuery - .trim(data + ""); - - // Guard against invalid (and possibly dangerous) input - // by ensuring that nothing remains - // after removing valid tokens - return str - && !jQuery.trim(str.replace(rvalidtokens, - function(token, comma, open, close) { - - // Force termination if we see a - // misplaced comma - if (requireNonComma && comma) { - depth = 0; - } - - // Perform no more replacements - // after returning to outermost - // depth - if (depth === 0) { - return token; - } - - // Commas must not follow "[", "{", - // or "," - requireNonComma = open || comma; - - // Determine new depth - // array/object open ("[" or "{"): - // depth += true - false (increment) - // array/object close ("]" or "}"): - // depth += false - true (decrement) - // other cases ("," or primitive): - // depth += true - true (numeric - // cast) - depth += !close - !open; - - // Remove this token - return ""; - })) ? (Function("return " + str))() - : jQuery.error("Invalid JSON: " + data); - }; - - // Cross-browser xml parsing - jQuery.parseXML = function(data) { - var xml, tmp; - if (!data || typeof data !== "string") { - return null; - } - try { - if (window.DOMParser) { // Standard - tmp = new window.DOMParser(); - xml = tmp.parseFromString(data, "text/xml"); - } else { // IE - xml = new window.ActiveXObject( - "Microsoft.XMLDOM"); - xml.async = "false"; - xml.loadXML(data); - } - } catch (e) { - xml = undefined; - } - if (!xml - || !xml.documentElement - || xml.getElementsByTagName("parsererror").length) { - jQuery.error("Invalid XML: " + data); - } - return xml; - }; - - var rhash = /#.*$/, rts = /([?&])_=[^&]*/, - - // IE leaves an \r character at EOL - rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, - - // #7653, #8125, #8152: local protocol detection - rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, - - /* - * Prefilters 1) They are useful to introduce custom - * dataTypes (see ajax/jsonp.js for an example) 2) These are - * called: - BEFORE asking for a transport - AFTER param - * serialization (s.data is a string if s.processData is - * true) 3) key is the dataType 4) the catchall symbol "*" - * can be used 5) execution will start with transport - * dataType and THEN continue down to "*" if needed - */ - prefilters = {}, - - /* - * Transports bindings 1) key is the dataType 2) the - * catchall symbol "*" can be used 3) selection will start - * with transport dataType and THEN go to "*" if needed - */ - transports = {}, - - // Avoid comment-prolog char sequence (#10098); must appease - // lint and evade compression - allTypes = "*/".concat("*"), - - // Document location - ajaxLocation = location.href, - - // Segment location into parts - ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || []; - - // Base "constructor" for jQuery.ajaxPrefilter and - // jQuery.ajaxTransport - function addToPrefiltersOrTransports(structure) { - - // dataTypeExpression is optional and defaults to "*" - return function(dataTypeExpression, func) { - - if (typeof dataTypeExpression !== "string") { - func = dataTypeExpression; - dataTypeExpression = "*"; - } - - var dataType, i = 0, dataTypes = dataTypeExpression - .toLowerCase().match(rnotwhite) - || []; - - if (jQuery.isFunction(func)) { - - // For each dataType in the dataTypeExpression - while ((dataType = dataTypes[i++])) { - - // Prepend if requested - if (dataType.charAt(0) === "+") { - dataType = dataType.slice(1) || "*"; - (structure[dataType] = structure[dataType] - || []).unshift(func); - - // Otherwise append - } else { - (structure[dataType] = structure[dataType] - || []).push(func); - } - } - } - }; - } - - // Base inspection function for prefilters and transports - function inspectPrefiltersOrTransports(structure, options, - originalOptions, jqXHR) { - - var inspected = {}, seekingTransport = (structure === transports); - - function inspect(dataType) { - var selected; - inspected[dataType] = true; - jQuery.each(structure[dataType] || [], function(_, - prefilterOrFactory) { - var dataTypeOrTransport = prefilterOrFactory( - options, originalOptions, jqXHR); - if (typeof dataTypeOrTransport === "string" - && !seekingTransport - && !inspected[dataTypeOrTransport]) { - - options.dataTypes - .unshift(dataTypeOrTransport); - inspect(dataTypeOrTransport); - return false; - } else if (seekingTransport) { - return !(selected = dataTypeOrTransport); - } - }); - return selected; - } - - return inspect(options.dataTypes[0]) || !inspected["*"] - && inspect("*"); - } - - // A special extend for ajax options - // that takes "flat" options (not to be deep extended) - // Fixes #9887 - function ajaxExtend(target, src) { - var deep, key, flatOptions = jQuery.ajaxSettings.flatOptions - || {}; - - for (key in src) { - if (src[key] !== undefined) { - (flatOptions[key] ? target - : (deep || (deep = {})))[key] = src[key]; - } - } - if (deep) { - jQuery.extend(true, target, deep); - } - - return target; - } - - /* - * Handles responses to an ajax request: - finds the right - * dataType (mediates between content-type and expected - * dataType) - returns the corresponding response - */ - function ajaxHandleResponses(s, jqXHR, responses) { - var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes; - - // Remove auto dataType and get content-type in the - // process - while (dataTypes[0] === "*") { - dataTypes.shift(); - if (ct === undefined) { - ct = s.mimeType - || jqXHR - .getResponseHeader("Content-Type"); - } - } - - // Check if we're dealing with a known content-type - if (ct) { - for (type in contents) { - if (contents[type] && contents[type].test(ct)) { - dataTypes.unshift(type); - break; - } - } - } - - // Check to see if we have a response for the expected - // dataType - if (dataTypes[0] in responses) { - finalDataType = dataTypes[0]; - } else { - - // Try convertible dataTypes - for (type in responses) { - if (!dataTypes[0] - || s.converters[type + " " - + dataTypes[0]]) { - finalDataType = type; - break; - } - if (!firstDataType) { - firstDataType = type; - } - } - - // Or just use first one - finalDataType = finalDataType || firstDataType; - } - - // If we found a dataType - // We add the dataType to the list if needed - // and return the corresponding response - if (finalDataType) { - if (finalDataType !== dataTypes[0]) { - dataTypes.unshift(finalDataType); - } - return responses[finalDataType]; - } - } - - /* - * Chain conversions given the request and the original - * response Also sets the responseXXX fields on the jqXHR - * instance - */ - function ajaxConvert(s, response, jqXHR, isSuccess) { - var conv2, current, conv, tmp, prev, converters = {}, - - // Work with a copy of dataTypes in case we need to - // modify it for conversion - dataTypes = s.dataTypes.slice(); - - // Create converters map with lowercased keys - if (dataTypes[1]) { - for (conv in s.converters) { - converters[conv.toLowerCase()] = s.converters[conv]; - } - } - - current = dataTypes.shift(); - - // Convert to each sequential dataType - while (current) { - - if (s.responseFields[current]) { - jqXHR[s.responseFields[current]] = response; - } - - // Apply the dataFilter if provided - if (!prev && isSuccess && s.dataFilter) { - response = s.dataFilter(response, s.dataType); - } - - prev = current; - current = dataTypes.shift(); - - if (current) { - - // There's only work to do if current dataType - // is non-auto - if (current === "*") { - - current = prev; - - // Convert response if prev dataType is - // non-auto and differs from current - } else if (prev !== "*" && prev !== current) { - - // Seek a direct converter - conv = converters[prev + " " + current] - || converters["* " + current]; - - // If none found, seek a pair - if (!conv) { - for (conv2 in converters) { - - // If conv2 outputs current - tmp = conv2.split(" "); - if (tmp[1] === current) { - - // If prev can be converted to - // accepted input - conv = converters[prev + " " - + tmp[0]] - || converters["* " - + tmp[0]]; - if (conv) { - - // Condense equivalence - // converters - if (conv === true) { - conv = converters[conv2]; - - // Otherwise, insert the - // intermediate dataType - } else if (converters[conv2] !== true) { - current = tmp[0]; - dataTypes - .unshift(tmp[1]); - } - break; - } - } - } - } - - // Apply converter (if not an equivalence) - if (conv !== true) { - - // Unless errors are allowed to bubble, - // catch and return them - if (conv && s["throws"]) { // jscs:ignore - // requireDotNotation - response = conv(response); - } else { - try { - response = conv(response); - } catch (e) { - return { - state : "parsererror", - error : conv ? e - : "No conversion from " - + prev - + " to " - + current - }; - } - } - } - } - } - } - - return { - state : "success", - data : response - }; - } - - jQuery - .extend({ - - // Counter for holding the number of active - // queries - active : 0, - - // Last-Modified header cache for next request - lastModified : {}, - etag : {}, - - ajaxSettings : { - url : ajaxLocation, - type : "GET", - isLocal : rlocalProtocol - .test(ajaxLocParts[1]), - global : true, - processData : true, - async : true, - contentType : "application/x-www-form-urlencoded; charset=UTF-8", - /* - * timeout: 0, data: null, dataType: null, - * username: null, password: null, cache: - * null, throws: false, traditional: false, - * headers: {}, - */ - - accepts : { - "*" : allTypes, - text : "text/plain", - html : "text/html", - xml : "application/xml, text/xml", - json : "application/json, text/javascript" - }, - - contents : { - xml : /\bxml\b/, - html : /\bhtml/, - json : /\bjson\b/ - }, - - responseFields : { - xml : "responseXML", - text : "responseText", - json : "responseJSON" - }, - - // Data converters - // Keys separate source (or catchall "*") - // and destination types with a single space - converters : { - - // Convert anything to text - "* text" : String, - - // Text to html (true = no - // transformation) - "text html" : true, - - // Evaluate text as a json expression - "text json" : jQuery.parseJSON, - - // Parse text as xml - "text xml" : jQuery.parseXML - }, - - // For options that shouldn't be deep - // extended: - // you can add your own custom options here - // if - // and when you create one that shouldn't be - // deep extended (see ajaxExtend) - flatOptions : { - url : true, - context : true - } - }, - - // Creates a full fledged settings object into - // target - // with both ajaxSettings and settings fields. - // If target is omitted, writes into - // ajaxSettings. - ajaxSetup : function(target, settings) { - return settings ? - - // Building a settings object - ajaxExtend(ajaxExtend(target, - jQuery.ajaxSettings), settings) : - - // Extending ajaxSettings - ajaxExtend(jQuery.ajaxSettings, target); - }, - - ajaxPrefilter : addToPrefiltersOrTransports(prefilters), - ajaxTransport : addToPrefiltersOrTransports(transports), - - // Main method - ajax : function(url, options) { - - // If url is an object, simulate pre-1.5 - // signature - if (typeof url === "object") { - options = url; - url = undefined; - } - - // Force options to be an object - options = options || {}; - - var - - // Cross-domain detection vars - parts, - - // Loop variable - i, - - // URL without anti-cache param - cacheURL, - - // Response headers as string - responseHeadersString, - - // timeout handle - timeoutTimer, - - // To know if global events are to be - // dispatched - fireGlobals, - - transport, - - // Response headers - responseHeaders, - - // Create the final options object - s = jQuery.ajaxSetup({}, options), - - // Callbacks context - callbackContext = s.context || s, - - // Context for global events is - // callbackContext if it is a DOM node or - // jQuery collection - globalEventContext = s.context - && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) - : jQuery.event, - - // Deferreds - deferred = jQuery.Deferred(), completeDeferred = jQuery - .Callbacks("once memory"), - - // Status-dependent callbacks - statusCode = s.statusCode || {}, - - // Headers (they are sent all at once) - requestHeaders = {}, requestHeadersNames = {}, - - // The jqXHR state - state = 0, - - // Default abort message - strAbort = "canceled", - - // Fake xhr - jqXHR = { - readyState : 0, - - // Builds headers hashtable if needed - getResponseHeader : function(key) { - var match; - if (state === 2) { - if (!responseHeaders) { - responseHeaders = {}; - while ((match = rheaders - .exec(responseHeadersString))) { - responseHeaders[match[1] - .toLowerCase()] = match[2]; - } - } - match = responseHeaders[key - .toLowerCase()]; - } - return match == null ? null : match; - }, - - // Raw string - getAllResponseHeaders : function() { - return state === 2 ? responseHeadersString - : null; - }, - - // Caches the header - setRequestHeader : function(name, value) { - var lname = name.toLowerCase(); - if (!state) { - name = requestHeadersNames[lname] = requestHeadersNames[lname] - || name; - requestHeaders[name] = value; - } - return this; - }, - - // Overrides response content-type - // header - overrideMimeType : function(type) { - if (!state) { - s.mimeType = type; - } - return this; - }, - - // Status-dependent callbacks - statusCode : function(map) { - var code; - if (map) { - if (state < 2) { - for (code in map) { - - // Lazy-add the new - // callback in a way - // that preserves old - // ones - statusCode[code] = [ - statusCode[code], - map[code] ]; - } - } else { - - // Execute the appropriate - // callbacks - jqXHR - .always(map[jqXHR.status]); - } - } - return this; - }, - - // Cancel the request - abort : function(statusText) { - var finalText = statusText - || strAbort; - if (transport) { - transport.abort(finalText); - } - done(0, finalText); - return this; - } - }; - - // Attach deferreds - deferred.promise(jqXHR).complete = completeDeferred.add; - jqXHR.success = jqXHR.done; - jqXHR.error = jqXHR.fail; - - // Remove hash character (#7531: and string - // promotion) - // Add protocol if not provided (#5866: IE7 - // issue with protocol-less urls) - // Handle falsy url in the settings object - // (#10093: consistency with old signature) - // We also use the url parameter if - // available - s.url = ((url || s.url || ajaxLocation) + "") - .replace(rhash, "").replace( - rprotocol, - ajaxLocParts[1] + "//"); - - // Alias method option to type as per ticket - // #12004 - s.type = options.method || options.type - || s.method || s.type; - - // Extract dataTypes list - s.dataTypes = jQuery - .trim(s.dataType || "*") - .toLowerCase().match(rnotwhite) - || [ "" ]; - - // A cross-domain request is in order when - // we have a protocol:host:port mismatch - if (s.crossDomain == null) { - parts = rurl.exec(s.url.toLowerCase()); - s.crossDomain = !!(parts && (parts[1] !== ajaxLocParts[1] - || parts[2] !== ajaxLocParts[2] || (parts[3] || (parts[1] === "http:" ? "80" - : "443")) !== (ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? "80" - : "443")))); - } - - // Convert data if not already a string - if (s.data && s.processData - && typeof s.data !== "string") { - s.data = jQuery.param(s.data, - s.traditional); - } - - // Apply prefilters - inspectPrefiltersOrTransports(prefilters, - s, options, jqXHR); - - // If request was aborted inside a - // prefilter, stop there - if (state === 2) { - return jqXHR; - } - - // We can fire global events as of now if - // asked to - // Don't fire events if jQuery.event is - // undefined in an AMD-usage scenario - // (#15118) - fireGlobals = jQuery.event && s.global; - - // Watch for a new set of requests - if (fireGlobals && jQuery.active++ === 0) { - jQuery.event.trigger("ajaxStart"); - } - - // Uppercase the type - s.type = s.type.toUpperCase(); - - // Determine if request has content - s.hasContent = !rnoContent.test(s.type); - - // Save the URL in case we're toying with - // the If-Modified-Since - // and/or If-None-Match header later on - cacheURL = s.url; - - // More options handling for requests with - // no content - if (!s.hasContent) { - - // If data is available, append data to - // url - if (s.data) { - cacheURL = (s.url += (rquery - .test(cacheURL) ? "&" : "?") - + s.data); - - // #9682: remove data so that it's - // not used in an eventual retry - delete s.data; - } - - // Add anti-cache in url if needed - if (s.cache === false) { - s.url = rts.test(cacheURL) ? - - // If there is already a '_' - // parameter, set its value - cacheURL.replace(rts, "$1_=" - + nonce++) - : - - // Otherwise add one to the - // end - cacheURL - + (rquery - .test(cacheURL) ? "&" - : "?") - + "_=" + nonce++; - } - } - - // Set the If-Modified-Since and/or - // If-None-Match header, if in ifModified - // mode. - if (s.ifModified) { - if (jQuery.lastModified[cacheURL]) { - jqXHR - .setRequestHeader( - "If-Modified-Since", - jQuery.lastModified[cacheURL]); - } - if (jQuery.etag[cacheURL]) { - jqXHR.setRequestHeader( - "If-None-Match", - jQuery.etag[cacheURL]); - } - } - - // Set the correct header, if data is being - // sent - if (s.data && s.hasContent - && s.contentType !== false - || options.contentType) { - jqXHR.setRequestHeader("Content-Type", - s.contentType); - } - - // Set the Accepts header for the server, - // depending on the dataType - jqXHR - .setRequestHeader( - "Accept", - s.dataTypes[0] - && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] - + (s.dataTypes[0] !== "*" ? ", " - + allTypes - + "; q=0.01" - : "") - : s.accepts["*"]); - - // Check for headers option - for (i in s.headers) { - jqXHR.setRequestHeader(i, s.headers[i]); - } - - // Allow custom headers/mimetypes and early - // abort - if (s.beforeSend - && (s.beforeSend.call( - callbackContext, jqXHR, s) === false || state === 2)) { - - // Abort if not done already and return - return jqXHR.abort(); - } - - // aborting is no longer a cancellation - strAbort = "abort"; - - // Install callbacks on deferreds - for (i in { - success : 1, - error : 1, - complete : 1 - }) { - jqXHR[i](s[i]); - } - - // Get transport - transport = inspectPrefiltersOrTransports( - transports, s, options, jqXHR); - - // If no transport, we auto-abort - if (!transport) { - done(-1, "No Transport"); - } else { - jqXHR.readyState = 1; - - // Send global event - if (fireGlobals) { - globalEventContext.trigger( - "ajaxSend", [ jqXHR, s ]); - } - - // If request was aborted inside - // ajaxSend, stop there - if (state === 2) { - return jqXHR; - } - - // Timeout - if (s.async && s.timeout > 0) { - timeoutTimer = window.setTimeout( - function() { - jqXHR.abort("timeout"); - }, s.timeout); - } - - try { - state = 1; - transport - .send(requestHeaders, done); - } catch (e) { - - // Propagate exception as error if - // not done - if (state < 2) { - done(-1, e); - - // Simply rethrow otherwise - } else { - throw e; - } - } - } - - // Callback for when everything is done - function done(status, nativeStatusText, - responses, headers) { - var isSuccess, success, error, response, modified, statusText = nativeStatusText; - - // Called once - if (state === 2) { - return; - } - - // State is "done" now - state = 2; - - // Clear timeout if it exists - if (timeoutTimer) { - window.clearTimeout(timeoutTimer); - } - - // Dereference transport for early - // garbage collection - // (no matter how long the jqXHR object - // will be used) - transport = undefined; - - // Cache response headers - responseHeadersString = headers || ""; - - // Set readyState - jqXHR.readyState = status > 0 ? 4 : 0; - - // Determine if successful - isSuccess = status >= 200 - && status < 300 - || status === 304; - - // Get response data - if (responses) { - response = ajaxHandleResponses(s, - jqXHR, responses); - } - - // Convert no matter what (that way - // responseXXX fields are always set) - response = ajaxConvert(s, response, - jqXHR, isSuccess); - - // If successful, handle type chaining - if (isSuccess) { - - // Set the If-Modified-Since and/or - // If-None-Match header, if in - // ifModified mode. - if (s.ifModified) { - modified = jqXHR - .getResponseHeader("Last-Modified"); - if (modified) { - jQuery.lastModified[cacheURL] = modified; - } - modified = jqXHR - .getResponseHeader("etag"); - if (modified) { - jQuery.etag[cacheURL] = modified; - } - } - - // if no content - if (status === 204 - || s.type === "HEAD") { - statusText = "nocontent"; - - // if not modified - } else if (status === 304) { - statusText = "notmodified"; - - // If we have data, let's - // convert it - } else { - statusText = response.state; - success = response.data; - error = response.error; - isSuccess = !error; - } - } else { - - // We extract error from statusText - // then normalize statusText and - // status for non-aborts - error = statusText; - if (status || !statusText) { - statusText = "error"; - if (status < 0) { - status = 0; - } - } - } - - // Set data for the fake xhr object - jqXHR.status = status; - jqXHR.statusText = (nativeStatusText || statusText) - + ""; - - // Success/Error - if (isSuccess) { - deferred - .resolveWith( - callbackContext, [ - success, - statusText, - jqXHR ]); - } else { - deferred - .rejectWith( - callbackContext, [ - jqXHR, - statusText, - error ]); - } - - // Status-dependent callbacks - jqXHR.statusCode(statusCode); - statusCode = undefined; - - if (fireGlobals) { - globalEventContext.trigger( - isSuccess ? "ajaxSuccess" - : "ajaxError", [ - jqXHR, - s, - isSuccess ? success - : error ]); - } - - // Complete - completeDeferred.fireWith( - callbackContext, [ jqXHR, - statusText ]); - - if (fireGlobals) { - globalEventContext.trigger( - "ajaxComplete", - [ jqXHR, s ]); - - // Handle the global AJAX counter - if (!(--jQuery.active)) { - jQuery.event - .trigger("ajaxStop"); - } - } - } - - return jqXHR; - }, - - getJSON : function(url, data, callback) { - return jQuery.get(url, data, callback, - "json"); - }, - - getScript : function(url, callback) { - return jQuery.get(url, undefined, callback, - "script"); - } - }); - - jQuery.each([ "get", "post" ], function(i, method) { - jQuery[method] = function(url, data, callback, type) { - - // shift arguments if data argument was omitted - if (jQuery.isFunction(data)) { - type = type || callback; - callback = data; - data = undefined; - } - - // The url can be an options object (which then must - // have .url) - return jQuery.ajax(jQuery.extend({ - url : url, - type : method, - dataType : type, - data : data, - success : callback - }, jQuery.isPlainObject(url) && url)); - }; - }); - - jQuery._evalUrl = function(url) { - return jQuery.ajax({ - url : url, - - // Make this explicit, since user can override this - // through ajaxSetup (#11264) - type : "GET", - dataType : "script", - cache : true, - async : false, - global : false, - "throws" : true - }); - }; - - jQuery.fn - .extend({ - wrapAll : function(html) { - if (jQuery.isFunction(html)) { - return this.each(function(i) { - jQuery(this).wrapAll( - html.call(this, i)); - }); - } - - if (this[0]) { - - // The elements to wrap the target - // around - var wrap = jQuery(html, - this[0].ownerDocument).eq(0) - .clone(true); - - if (this[0].parentNode) { - wrap.insertBefore(this[0]); - } - - wrap - .map( - function() { - var elem = this; - - while (elem.firstChild - && elem.firstChild.nodeType === 1) { - elem = elem.firstChild; - } - - return elem; - }).append(this); - } - - return this; - }, - - wrapInner : function(html) { - if (jQuery.isFunction(html)) { - return this.each(function(i) { - jQuery(this).wrapInner( - html.call(this, i)); - }); - } - - return this - .each(function() { - var self = jQuery(this), contents = self - .contents(); - - if (contents.length) { - contents.wrapAll(html); - - } else { - self.append(html); - } - }); - }, - - wrap : function(html) { - var isFunction = jQuery.isFunction(html); - - return this.each(function(i) { - jQuery(this).wrapAll( - isFunction ? html.call(this, i) - : html); - }); - }, - - unwrap : function() { - return this.parent().each( - function() { - if (!jQuery.nodeName(this, - "body")) { - jQuery(this).replaceWith( - this.childNodes); - } - }).end(); - } - }); - - function getDisplay(elem) { - return elem.style && elem.style.display - || jQuery.css(elem, "display"); - } - - function filterHidden(elem) { - - // Disconnected elements are considered hidden - if (!jQuery.contains(elem.ownerDocument || document, - elem)) { - return true; - } - while (elem && elem.nodeType === 1) { - if (getDisplay(elem) === "none" - || elem.type === "hidden") { - return true; - } - elem = elem.parentNode; - } - return false; - } - - jQuery.expr.filters.hidden = function(elem) { - - // Support: Opera <= 12.12 - // Opera reports offsetWidths and offsetHeights less - // than zero on some elements - return support.reliableHiddenOffsets() ? (elem.offsetWidth <= 0 - && elem.offsetHeight <= 0 && !elem - .getClientRects().length) - : filterHidden(elem); - }; - - jQuery.expr.filters.visible = function(elem) { - return !jQuery.expr.filters.hidden(elem); - }; - - var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; - - function buildParams(prefix, obj, traditional, add) { - var name; - - if (jQuery.isArray(obj)) { - - // Serialize array item. - jQuery.each(obj, function(i, v) { - if (traditional || rbracket.test(prefix)) { - - // Treat each array item as a scalar. - add(prefix, v); - - } else { - - // Item is non-scalar (array or object), - // encode its numeric index. - buildParams(prefix - + "[" - + (typeof v === "object" - && v != null ? i : "") - + "]", v, traditional, add); - } - }); - - } else if (!traditional - && jQuery.type(obj) === "object") { - - // Serialize object item. - for (name in obj) { - buildParams(prefix + "[" + name + "]", - obj[name], traditional, add); - } - - } else { - - // Serialize scalar item. - add(prefix, obj); - } - } - - // Serialize an array of form elements or a set of - // key/values into a query string - jQuery.param = function(a, traditional) { - var prefix, s = [], add = function(key, value) { - - // If value is a function, invoke it and return its - // value - value = jQuery.isFunction(value) ? value() - : (value == null ? "" : value); - s[s.length] = encodeURIComponent(key) + "=" - + encodeURIComponent(value); - }; - - // Set traditional to true for jQuery <= 1.3.2 behavior. - if (traditional === undefined) { - traditional = jQuery.ajaxSettings - && jQuery.ajaxSettings.traditional; - } - - // If an array was passed in, assume that it is an array - // of form elements. - if (jQuery.isArray(a) - || (a.jquery && !jQuery.isPlainObject(a))) { - - // Serialize the form elements - jQuery.each(a, function() { - add(this.name, this.value); - }); - - } else { - - // If traditional, encode the "old" way (the way - // 1.3.2 or older - // did it), otherwise encode params recursively. - for (prefix in a) { - buildParams(prefix, a[prefix], traditional, add); - } - } - - // Return the resulting serialization - return s.join("&").replace(r20, "+"); - }; - - jQuery.fn - .extend({ - serialize : function() { - return jQuery.param(this.serializeArray()); - }, - serializeArray : function() { - return this - .map( - function() { - - // Can add propHook for - // "elements" to filter - // or add form elements - var elements = jQuery - .prop(this, - "elements"); - return elements ? jQuery - .makeArray(elements) - : this; - }) - .filter( - function() { - var type = this.type; - - // Use .is(":disabled") - // so that - // fieldset[disabled] - // works - return this.name - && !jQuery(this) - .is( - ":disabled") - && rsubmittable - .test(this.nodeName) - && !rsubmitterTypes - .test(type) - && (this.checked || !rcheckableType - .test(type)); - }) - .map( - function(i, elem) { - var val = jQuery(this) - .val(); - - return val == null ? null - : jQuery - .isArray(val) ? jQuery - .map( - val, - function( - val) { - return { - name : elem.name, - value : val - .replace( - rCRLF, - "\r\n") - }; - }) - : { - name : elem.name, - value : val - .replace( - rCRLF, - "\r\n") - }; - }).get(); - } - }); - - // Create the request object - // (This is still attached to ajaxSettings for backward - // compatibility) - jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ? - - // Support: IE6-IE8 - function() { - - // XHR cannot access local files, always use ActiveX for - // that case - if (this.isLocal) { - return createActiveXHR(); - } - - // Support: IE 9-11 - // IE seems to error on cross-domain PATCH requests when - // ActiveX XHR - // is used. In IE 9+ always use the native XHR. - // Note: this condition won't catch Edge as it doesn't - // define - // document.documentMode but it also doesn't support - // ActiveX so it won't - // reach this code. - if (document.documentMode > 8) { - return createStandardXHR(); - } - - // Support: IE<9 - // oldIE XHR does not support non-RFC2616 methods - // (#13240) - // See - // http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx - // and - // http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 - // Although this check for six methods instead of eight - // since IE also does not support "trace" and "connect" - return /^(get|post|head|put|delete|options)$/i - .test(this.type) - && createStandardXHR() || createActiveXHR(); - } - : - - // For all other browsers, use the standard - // XMLHttpRequest object - createStandardXHR; - - var xhrId = 0, xhrCallbacks = {}, xhrSupported = jQuery.ajaxSettings - .xhr(); - - // Support: IE<10 - // Open requests must be manually aborted on unload (#5280) - // See https://support.microsoft.com/kb/2856746 for more - // info - if (window.attachEvent) { - window.attachEvent("onunload", function() { - for ( var key in xhrCallbacks) { - xhrCallbacks[key](undefined, true); - } - }); - } - - // Determine support properties - support.cors = !!xhrSupported - && ("withCredentials" in xhrSupported); - xhrSupported = support.ajax = !!xhrSupported; - - // Create transport if the browser can provide an xhr - if (xhrSupported) { - - jQuery - .ajaxTransport(function(options) { - - // Cross domain only allowed if supported - // through XMLHttpRequest - if (!options.crossDomain || support.cors) { - - var callback; - - return { - send : function(headers, complete) { - var i, xhr = options.xhr(), id = ++xhrId; - - // Open the socket - xhr.open(options.type, - options.url, - options.async, - options.username, - options.password); - - // Apply custom fields if - // provided - if (options.xhrFields) { - for (i in options.xhrFields) { - xhr[i] = options.xhrFields[i]; - } - } - - // Override mime type if needed - if (options.mimeType - && xhr.overrideMimeType) { - xhr - .overrideMimeType(options.mimeType); - } - - // X-Requested-With header - // For cross-domain requests, - // seeing as conditions for a - // preflight are - // akin to a jigsaw puzzle, we - // simply never set it to be - // sure. - // (it can always be set on a - // per-request basis or even - // using ajaxSetup) - // For same-domain requests, - // won't change header if - // already provided. - if (!options.crossDomain - && !headers["X-Requested-With"]) { - headers["X-Requested-With"] = "XMLHttpRequest"; - } - - // Set headers - for (i in headers) { - - // Support: IE<9 - // IE's ActiveXObject throws - // a 'Type Mismatch' - // exception when setting - // request header to a - // null-value. - // - // To keep consistent with - // other XHR - // implementations, cast the - // value - // to string and ignore - // `undefined`. - if (headers[i] !== undefined) { - xhr - .setRequestHeader( - i, - headers[i] - + ""); - } - } - - // Do send the request - // This may raise an exception - // which is actually - // handled in jQuery.ajax (so no - // try/catch here) - xhr - .send((options.hasContent && options.data) - || null); - - // Listener - callback = function(_, isAbort) { - var status, statusText, responses; - - // Was never called and is - // aborted or complete - if (callback - && (isAbort || xhr.readyState === 4)) { - - // Clean up - delete xhrCallbacks[id]; - callback = undefined; - xhr.onreadystatechange = jQuery.noop; - - // Abort manually if - // needed - if (isAbort) { - if (xhr.readyState !== 4) { - xhr.abort(); - } - } else { - responses = {}; - status = xhr.status; - - // Support: IE<10 - // Accessing - // binary-data - // responseText - // throws an - // exception - // (#11426) - if (typeof xhr.responseText === "string") { - responses.text = xhr.responseText; - } - - // Firefox throws an - // exception when - // accessing - // statusText for - // faulty - // cross-domain - // requests - try { - statusText = xhr.statusText; - } catch (e) { - - // We normalize - // with Webkit - // giving an - // empty - // statusText - statusText = ""; - } - - // Filter status for - // non standard - // behaviors - - // If the request is - // local and we have - // data: assume a - // success - // (success with no - // data won't get - // notified, that's - // the best we - // can do given - // current - // implementations) - if (!status - && options.isLocal - && !options.crossDomain) { - status = responses.text ? 200 - : 404; - - // IE - #1450: - // sometimes - // returns 1223 - // when it - // should be 204 - } else if (status === 1223) { - status = 204; - } - } - } - - // Call complete if needed - if (responses) { - complete( - status, - statusText, - responses, - xhr - .getAllResponseHeaders()); - } - }; - - // Do send the request - // `xhr.send` may raise an - // exception, but it will be - // handled in jQuery.ajax (so no - // try/catch here) - if (!options.async) { - - // If we're in sync mode we - // fire the callback - callback(); - } else if (xhr.readyState === 4) { - - // (IE6 & IE7) if it's in - // cache and has been - // retrieved directly we - // need to fire the callback - window.setTimeout(callback); - } else { - - // Register the callback, - // but delay it in case - // `xhr.send` throws - // Add to the list of active - // xhr callbacks - xhr.onreadystatechange = xhrCallbacks[id] = callback; - } - }, - - abort : function() { - if (callback) { - callback(undefined, true); - } - } - }; - } - }); - } - - // Functions to create xhrs - function createStandardXHR() { - try { - return new window.XMLHttpRequest(); - } catch (e) { - } - } - - function createActiveXHR() { - try { - return new window.ActiveXObject("Microsoft.XMLHTTP"); - } catch (e) { - } - } - - // Install script dataType - jQuery - .ajaxSetup({ - accepts : { - script : "text/javascript, application/javascript, " - + "application/ecmascript, application/x-ecmascript" - }, - contents : { - script : /\b(?:java|ecma)script\b/ - }, - converters : { - "text script" : function(text) { - jQuery.globalEval(text); - return text; - } - } - }); - - // Handle cache's special case and global - jQuery.ajaxPrefilter("script", function(s) { - if (s.cache === undefined) { - s.cache = false; - } - if (s.crossDomain) { - s.type = "GET"; - s.global = false; - } - }); - - // Bind script tag hack transport - jQuery - .ajaxTransport( - "script", - function(s) { - - // This transport only deals with cross - // domain requests - if (s.crossDomain) { - - var script, head = document.head - || jQuery("head")[0] - || document.documentElement; - - return { - - send : function(_, callback) { - - script = document - .createElement("script"); - - script.async = true; - - if (s.scriptCharset) { - script.charset = s.scriptCharset; - } - - script.src = s.url; - - // Attach handlers for all - // browsers - script.onload = script.onreadystatechange = function( - _, isAbort) { - - if (isAbort - || !script.readyState - || /loaded|complete/ - .test(script.readyState)) { - - // Handle memory - // leak in IE - script.onload = script.onreadystatechange = null; - - // Remove the script - if (script.parentNode) { - script.parentNode - .removeChild(script); - } - - // Dereference the - // script - script = null; - - // Callback if not - // abort - if (!isAbort) { - callback(200, - "success"); - } - } - }; - - // Circumvent IE6 bugs with - // base elements (#2709 and - // #4378) by prepending - // Use native DOM - // manipulation to avoid our - // domManip AJAX trickery - head.insertBefore(script, - head.firstChild); - }, - - abort : function() { - if (script) { - script - .onload( - undefined, - true); - } - } - }; - } - }); - - var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/; - - // Default jsonp settings - jQuery.ajaxSetup({ - jsonp : "callback", - jsonpCallback : function() { - var callback = oldCallbacks.pop() - || (jQuery.expando + "_" + (nonce++)); - this[callback] = true; - return callback; - } - }); - - // Detect, normalize options and install callbacks for jsonp - // requests - jQuery - .ajaxPrefilter( - "json jsonp", - function(s, originalSettings, jqXHR) { - - var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false - && (rjsonp.test(s.url) ? "url" - : typeof s.data === "string" - && (s.contentType || "") - .indexOf("application/x-www-form-urlencoded") === 0 - && rjsonp - .test(s.data) - && "data"); - - // Handle iff the expected data type is - // "jsonp" or we have a parameter to set - if (jsonProp - || s.dataTypes[0] === "jsonp") { - - // Get callback name, remembering - // preexisting value associated with - // it - callbackName = s.jsonpCallback = jQuery - .isFunction(s.jsonpCallback) ? s - .jsonpCallback() - : s.jsonpCallback; - - // Insert callback into url or form - // data - if (jsonProp) { - s[jsonProp] = s[jsonProp] - .replace(rjsonp, "$1" - + callbackName); - } else if (s.jsonp !== false) { - s.url += (rquery.test(s.url) ? "&" - : "?") - + s.jsonp - + "=" - + callbackName; - } - - // Use data converter to retrieve - // json after script execution - s.converters["script json"] = function() { - if (!responseContainer) { - jQuery - .error(callbackName - + " was not called"); - } - return responseContainer[0]; - }; - - // force json dataType - s.dataTypes[0] = "json"; - - // Install callback - overwritten = window[callbackName]; - window[callbackName] = function() { - responseContainer = arguments; - }; - - // Clean-up function (fires after - // converters) - jqXHR - .always(function() { - - // If previous value - // didn't exist - remove - // it - if (overwritten === undefined) { - jQuery(window) - .removeProp( - callbackName); - - // Otherwise restore - // preexisting value - } else { - window[callbackName] = overwritten; - } - - // Save back as free - if (s[callbackName]) { - - // make sure that - // re-using the - // options doesn't - // screw things - // around - s.jsonpCallback = originalSettings.jsonpCallback; - - // save the callback - // name for future - // use - oldCallbacks - .push(callbackName); - } - - // Call if it was a - // function and we have - // a response - if (responseContainer - && jQuery - .isFunction(overwritten)) { - overwritten(responseContainer[0]); - } - - responseContainer = overwritten = undefined; - }); - - // Delegate to script - return "script"; - } - }); - - // data: string of html - // context (optional): If specified, the fragment will be - // created in this context, - // defaults to document - // keepScripts (optional): If true, will include scripts - // passed in the html string - jQuery.parseHTML = function(data, context, keepScripts) { - if (!data || typeof data !== "string") { - return null; - } - if (typeof context === "boolean") { - keepScripts = context; - context = false; - } - context = context || document; - - var parsed = rsingleTag.exec(data), scripts = !keepScripts - && []; - - // Single tag - if (parsed) { - return [ context.createElement(parsed[1]) ]; - } - - parsed = buildFragment([ data ], context, scripts); - - if (scripts && scripts.length) { - jQuery(scripts).remove(); - } - - return jQuery.merge([], parsed.childNodes); - }; - - // Keep a copy of the old load method - var _load = jQuery.fn.load; - - /** - * Load a url into a page - */ - jQuery.fn.load = function(url, params, callback) { - if (typeof url !== "string" && _load) { - return _load.apply(this, arguments); - } - - var selector, type, response, self = this, off = url - .indexOf(" "); - - if (off > -1) { - selector = jQuery.trim(url.slice(off, url.length)); - url = url.slice(0, off); - } - - // If it's a function - if (jQuery.isFunction(params)) { - - // We assume that it's the callback - callback = params; - params = undefined; - - // Otherwise, build a param string - } else if (params && typeof params === "object") { - type = "POST"; - } - - // If we have elements to modify, make the request - if (self.length > 0) { - jQuery - .ajax({ - url : url, - - // If "type" variable is undefined, then - // "GET" method will be used. - // Make value of this field explicit - // since - // user can override it through - // ajaxSetup method - type : type || "GET", - dataType : "html", - data : params - }) - .done( - function(responseText) { - - // Save response for use in - // complete callback - response = arguments; - - self - .html(selector ? - - // If a selector was - // specified, locate the - // right elements in a - // dummy div - // Exclude scripts to - // avoid IE 'Permission - // Denied' errors - jQuery("<div>") - .append( - jQuery - .parseHTML(responseText)) - .find(selector) - : - - // Otherwise use - // the full - // result - responseText); - - // If the request succeeds, this - // function gets "data", - // "status", "jqXHR" - // but they are ignored because - // response was set above. - // If it fails, this function - // gets "jqXHR", "status", - // "error" - }) - .always( - callback - && function(jqXHR, status) { - self - .each(function() { - callback - .apply( - this, - response - || [ - jqXHR.responseText, - status, - jqXHR ]); - }); - }); - } - - return this; - }; - - // Attach a bunch of functions for handling common AJAX - // events - jQuery.each([ "ajaxStart", "ajaxStop", "ajaxComplete", - "ajaxError", "ajaxSuccess", "ajaxSend" ], function( - i, type) { - jQuery.fn[type] = function(fn) { - return this.on(type, fn); - }; - }); - - jQuery.expr.filters.animated = function(elem) { - return jQuery.grep(jQuery.timers, function(fn) { - return elem === fn.elem; - }).length; - }; - - /** - * Gets a window from an element - */ - function getWindow(elem) { - return jQuery.isWindow(elem) ? elem - : elem.nodeType === 9 ? elem.defaultView - || elem.parentWindow : false; - } - - jQuery.offset = { - setOffset : function(elem, options, i) { - var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery - .css(elem, "position"), curElem = jQuery(elem), props = {}; - - // set position first, in-case top/left are set even - // on static elem - if (position === "static") { - elem.style.position = "relative"; - } - - curOffset = curElem.offset(); - curCSSTop = jQuery.css(elem, "top"); - curCSSLeft = jQuery.css(elem, "left"); - calculatePosition = (position === "absolute" || position === "fixed") - && jQuery.inArray("auto", [ curCSSTop, - curCSSLeft ]) > -1; - - // need to be able to calculate position if either - // top or left - // is auto and position is either absolute or fixed - if (calculatePosition) { - curPosition = curElem.position(); - curTop = curPosition.top; - curLeft = curPosition.left; - } else { - curTop = parseFloat(curCSSTop) || 0; - curLeft = parseFloat(curCSSLeft) || 0; - } - - if (jQuery.isFunction(options)) { - - // Use jQuery.extend here to allow modification - // of coordinates argument (gh-1848) - options = options.call(elem, i, jQuery.extend( - {}, curOffset)); - } - - if (options.top != null) { - props.top = (options.top - curOffset.top) - + curTop; - } - if (options.left != null) { - props.left = (options.left - curOffset.left) - + curLeft; - } - - if ("using" in options) { - options.using.call(elem, props); - } else { - curElem.css(props); - } - } - }; - - jQuery.fn - .extend({ - offset : function(options) { - if (arguments.length) { - return options === undefined ? this - : this.each(function(i) { - jQuery.offset.setOffset( - this, options, i); - }); - } - - var docElem, win, box = { - top : 0, - left : 0 - }, elem = this[0], doc = elem - && elem.ownerDocument; - - if (!doc) { - return; - } - - docElem = doc.documentElement; - - // Make sure it's not a disconnected DOM - // node - if (!jQuery.contains(docElem, elem)) { - return box; - } - - // If we don't have gBCR, just use 0,0 - // rather than error - // BlackBerry 5, iOS 3 (original iPhone) - if (typeof elem.getBoundingClientRect !== "undefined") { - box = elem.getBoundingClientRect(); - } - win = getWindow(doc); - return { - top : box.top - + (win.pageYOffset || docElem.scrollTop) - - (docElem.clientTop || 0), - left : box.left - + (win.pageXOffset || docElem.scrollLeft) - - (docElem.clientLeft || 0) - }; - }, - - position : function() { - if (!this[0]) { - return; - } - - var offsetParent, offset, parentOffset = { - top : 0, - left : 0 - }, elem = this[0]; - - // Fixed elements are offset from window - // (parentOffset = {top:0, left: 0}, - // because it is its only offset parent - if (jQuery.css(elem, "position") === "fixed") { - - // we assume that getBoundingClientRect - // is available when computed position - // is fixed - offset = elem.getBoundingClientRect(); - } else { - - // Get *real* offsetParent - offsetParent = this.offsetParent(); - - // Get correct offsets - offset = this.offset(); - if (!jQuery.nodeName(offsetParent[0], - "html")) { - parentOffset = offsetParent - .offset(); - } - - // Add offsetParent borders - parentOffset.top += jQuery.css( - offsetParent[0], - "borderTopWidth", true); - parentOffset.left += jQuery.css( - offsetParent[0], - "borderLeftWidth", true); - } - - // Subtract parent offsets and element - // margins - // note: when an element has margin: auto - // the offsetLeft and marginLeft - // are the same in Safari causing - // offset.left to incorrectly be 0 - return { - top : offset.top - - parentOffset.top - - jQuery.css(elem, "marginTop", - true), - left : offset.left - - parentOffset.left - - jQuery.css(elem, - "marginLeft", true) - }; - }, - - offsetParent : function() { - return this - .map(function() { - var offsetParent = this.offsetParent; - - while (offsetParent - && (!jQuery.nodeName( - offsetParent, - "html") && jQuery - .css( - offsetParent, - "position") === "static")) { - offsetParent = offsetParent.offsetParent; - } - return offsetParent - || documentElement; - }); - } - }); - - // Create scrollLeft and scrollTop methods - jQuery - .each( - { - scrollLeft : "pageXOffset", - scrollTop : "pageYOffset" - }, - function(method, prop) { - var top = /Y/.test(prop); - - jQuery.fn[method] = function(val) { - return access( - this, - function(elem, method, val) { - var win = getWindow(elem); - - if (val === undefined) { - return win ? (prop in win) ? win[prop] - : win.document.documentElement[method] - : elem[method]; - } - - if (win) { - win - .scrollTo( - !top ? val - : jQuery( - win) - .scrollLeft(), - top ? val - : jQuery( - win) - .scrollTop()); - - } else { - elem[method] = val; - } - }, method, val, - arguments.length, null); - }; - }); - - // Support: Safari<7-8+, Chrome<37-44+ - // Add the top/left cssHooks using jQuery.fn.position - // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 - // getComputedStyle returns percent when specified for - // top/left/bottom/right - // rather than make the css module depend on the offset - // module, we just check for it here - jQuery - .each( - [ "top", "left" ], - function(i, prop) { - jQuery.cssHooks[prop] = addGetHookIf( - support.pixelPosition, - function(elem, computed) { - if (computed) { - computed = curCSS(elem, - prop); - - // if curCSS returns - // percentage, fallback - // to offset - return rnumnonpx - .test(computed) ? jQuery( - elem) - .position()[prop] - + "px" - : computed; - } - }); - }); - - // Create innerHeight, innerWidth, height, width, - // outerHeight and outerWidth methods - jQuery - .each( - { - Height : "height", - Width : "width" - }, - function(name, type) { - jQuery - .each( - { - padding : "inner" - + name, - content : type, - "" : "outer" + name - }, - function(defaultExtra, - funcName) { - - // margin is only - // for outerHeight, - // outerWidth - jQuery.fn[funcName] = function( - margin, - value) { - var chainable = arguments.length - && (defaultExtra || typeof margin !== "boolean"), extra = defaultExtra - || (margin === true - || value === true ? "margin" - : "border"); - - return access( - this, - function( - elem, - type, - value) { - var doc; - - if (jQuery - .isWindow(elem)) { - - // As - // of - // 5/8/2012 - // this - // will - // yield - // incorrect - // results - // for - // Mobile - // Safari, - // but - // there - // isn't - // a - // whole - // lot - // we - // can - // do. - // See - // pull - // request - // at - // this - // URL - // for - // discussion: - // https://github.com/jquery/jquery/pull/764 - return elem.document.documentElement["client" - + name]; - } - - // Get - // document - // width - // or - // height - if (elem.nodeType === 9) { - doc = elem.documentElement; - - // Either - // scroll[Width/Height] - // or - // offset[Width/Height] - // or - // client[Width/Height], - // whichever - // is - // greatest - // unfortunately, - // this - // causes - // bug - // #3838 - // in - // IE6/8 - // only, - // but - // there - // is - // currently - // no - // good, - // small - // way - // to - // fix - // it. - return Math - .max( - elem.body["scroll" - + name], - doc["scroll" - + name], - elem.body["offset" - + name], - doc["offset" - + name], - doc["client" - + name]); - } - - return value === undefined ? - - // Get - // width - // or - // height - // on - // the - // element, - // requesting - // but - // not - // forcing - // parseFloat - jQuery - .css( - elem, - type, - extra) - : - - // Set - // width - // or - // height - // on - // the - // element - jQuery - .style( - elem, - type, - value, - extra); - }, - type, - chainable ? margin - : undefined, - chainable, - null); - }; - }); - }); - - jQuery.fn.extend({ - - bind : function(types, data, fn) { - return this.on(types, null, data, fn); - }, - unbind : function(types, fn) { - return this.off(types, null, fn); - }, - - delegate : function(selector, types, data, fn) { - return this.on(types, selector, data, fn); - }, - undelegate : function(selector, types, fn) { - - // ( namespace ) or ( selector, types [, fn] ) - return arguments.length === 1 ? this.off(selector, - "**") : this.off(types, selector || "**", - fn); - } - }); - - // The number of elements contained in the matched element - // set - jQuery.fn.size = function() { - return this.length; - }; - - jQuery.fn.andSelf = jQuery.fn.addBack; - - // Register as a named AMD module, since jQuery can be - // concatenated with other - // files that may use define, but not via a proper - // concatenation script that - // understands anonymous AMD modules. A named AMD is safest - // and most robust - // way to register. Lowercase jquery is used because AMD - // module names are - // derived from file names, and jQuery is normally delivered - // in a lowercase - // file name. Do this after creating the global so that if - // an AMD module wants - // to call noConflict to hide this version of jQuery, it - // will work. - - // Note that for maximum portability, libraries that are not - // jQuery should - // declare themselves as anonymous modules, and avoid - // setting a global if an - // AMD loader is present. jQuery is a special case. For more - // information, see - // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon - - if (typeof define === "function" && define.amd) { - define("jquery", [], function() { - return jQuery; - }); - } - - var - - // Map over jQuery in case of overwrite - _jQuery = window.jQuery, - - // Map over the $ in case of overwrite - _$ = window.$; - - jQuery.noConflict = function(deep) { - if (window.$ === jQuery) { - window.$ = _$; - } - - if (deep && window.jQuery === jQuery) { - window.jQuery = _jQuery; - } - - return jQuery; - }; - - // Expose jQuery and $ identifiers, even in - // AMD (#7102#comment:10, - // https://github.com/jquery/jquery/pull/557) - // and CommonJS for browser emulators (#13566) - if (!noGlobal) { - window.jQuery = window.$ = jQuery; - } - - return jQuery; - })); diff --git a/client/pom.xml b/client/pom.xml index 7702b63d3..0999c6a3c 100644 --- a/client/pom.xml +++ b/client/pom.xml @@ -33,6 +33,8 @@ <name>${project.artifactId}</name> <description>Web client for managing Apex engines</description> <modules> + <module>client-common</module> <module>client-monitoring</module> + <module>client-deployment</module> </modules> </project>
\ No newline at end of file @@ -125,6 +125,19 @@ <execute /> </action> </pluginExecution> + <pluginExecution> + <pluginExecutionFilter> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-dependency-plugin</artifactId> + <versionRange>[3.0,)</versionRange> + <goals> + <goal>unpack-dependencies</goal> + </goals> + </pluginExecutionFilter> + <action> + <execute /> + </action> + </pluginExecution> </pluginExecutions> </lifecycleMappingMetadata> </configuration> |
