https://www.aslogliastra.it/wp-content/themes/asl/static/js/angular-material.min.js

1/*!
2 * AngularJS Material Design
3 * https://github.com/angular/material
4 * @license MIT
5 * v1.1.4-master-baa869a
6 */
7(function( window, angular, undefined ){
8"use strict";
9
10(function(){
11"use strict";
12
13angular.module('ngMaterial', ["ng","ngAnimate","ngAria","material.core","material.core.gestures","material.core.interaction","material.core.layout","material.core.meta","material.core.theming.palette","material.core.theming","material.core.animate","material.components.autocomplete","material.components.backdrop","material.components.bottomSheet","material.components.button","material.components.card","material.components.checkbox","material.components.chips","material.components.colors","material.components.content","material.components.datepicker","material.components.dialog","material.components.divider","material.components.fabActions","material.components.fabShared","material.components.fabSpeedDial","material.components.fabToolbar","material.components.gridList","material.components.icon","material.components.input","material.components.list","material.components.menu","material.components.menuBar","material.components.navBar","material.components.panel","material.components.progressCircular","material.components.progressLinear","material.components.radioButton","material.components.select","material.components.showHide","material.components.sidenav","material.components.slider","material.components.sticky","material.components.subheader","material.components.swipe","material.components.switch","material.components.tabs","material.components.toast","material.components.toolbar","material.components.tooltip","material.components.truncate","material.components.virtualRepeat","material.components.whiteframe"]);
14})();
15(function(){
16"use strict";
17
18/**
19 * Initialization function that validates environment
20 * requirements.
21 */
22DetectNgTouch.$inject = ["$log", "$injector"];
23MdCoreConfigure.$inject = ["$provide", "$mdThemingProvider"];
24rAFDecorator.$inject = ["$delegate"];
25qDecorator.$inject = ["$delegate"];
26angular
27  .module('material.core', [
28    'ngAnimate',
29    'material.core.animate',
30    'material.core.layout',
31    'material.core.interaction',
32    'material.core.gestures',
33    'material.core.theming'
34  ])
35  .config(MdCoreConfigure)
36  .run(DetectNgTouch);
37
38
39/**
40 * Detect if the ng-Touch module is also being used.
41 * Warn if detected.
42 * @ngInject
43 */
44function DetectNgTouch($log, $injector) {
45  if ( $injector.has('$swipe') ) {
46    var msg = "" +
47      "You are using the ngTouch module. \n" +
48      "AngularJS Material already has mobile click, tap, and swipe support... \n" +
49      "ngTouch is not supported with AngularJS Material!";
50    $log.warn(msg);
51  }
52}
53
54/**
55 * @ngInject
56 */
57function MdCoreConfigure($provide, $mdThemingProvider) {
58
59  $provide.decorator('$$rAF', ['$delegate', rAFDecorator]);
60  $provide.decorator('$q', ['$delegate', qDecorator]);
61
62  $mdThemingProvider.theme('default')
63    .primaryPalette('indigo')
64    .accentPalette('pink')
65    .warnPalette('deep-orange')
66    .backgroundPalette('grey');
67}
68
69/**
70 * @ngInject
71 */
72function rAFDecorator($delegate) {
73  /**
74   * Use this to throttle events that come in often.
75   * The throttled function will always use the *last* invocation before the
76   * coming frame.
77   *
78   * For example, window resize events that fire many times a second:
79   * If we set to use an raf-throttled callback on window resize, then
80   * our callback will only be fired once per frame, with the last resize
81   * event that happened before that frame.
82   *
83   * @param {function} callback function to debounce
84   */
85  $delegate.throttle = function(cb) {
86    var queuedArgs, alreadyQueued, queueCb, context;
87    return function debounced() {
88      queuedArgs = arguments;
89      context = this;
90      queueCb = cb;
91      if (!alreadyQueued) {
92        alreadyQueued = true;
93        $delegate(function() {
94          queueCb.apply(context, Array.prototype.slice.call(queuedArgs));
95          alreadyQueued = false;
96        });
97      }
98    };
99  };
100  return $delegate;
101}
102
103/**
104 * @ngInject
105 */
106function qDecorator($delegate) {
107  /**
108   * Adds a shim for $q.resolve for AngularJS version that don't have it,
109   * so we don't have to think about it.
110   *
111   * via https://github.com/angular/angular.js/pull/11987
112   */
113
114  // TODO(crisbeto): this won't be necessary once we drop AngularJS 1.3
115  if (!$delegate.resolve) {
116    $delegate.resolve = $delegate.when;
117  }
118  return $delegate;
119}
120
121})();
122(function(){
123"use strict";
124
125
126MdAutofocusDirective.$inject = ["$parse"];angular.module('material.core')
127  .directive('mdAutofocus', MdAutofocusDirective)
128
129  // Support the deprecated md-auto-focus and md-sidenav-focus as well
130  .directive('mdAutoFocus', MdAutofocusDirective)
131  .directive('mdSidenavFocus', MdAutofocusDirective);
132
133/**
134 * @ngdoc directive
135 * @name mdAutofocus
136 * @module material.core.util
137 *
138 * @description
139 *
140 * `[md-autofocus]` provides an optional way to identify the focused element when a `$mdDialog`,
141 * `$mdBottomSheet`, `$mdMenu` or `$mdSidenav` opens or upon page load for input-like elements.
142 *
143 * When one of these opens, it will find the first nested element with the `[md-autofocus]`
144 * attribute directive and optional expression. An expression may be specified as the directive
145 * value to enable conditional activation of the autofocus.
146 *
147 * @usage
148 *
149 * ### Dialog
150 * <hljs lang="html">
151 * <md-dialog>
152 *   <form>
153 *     <md-input-container>
154 *       <label for="testInput">Label</label>
155 *       <input id="testInput" type="text" md-autofocus>
156 *     </md-input-container>
157 *   </form>
158 * </md-dialog>
159 * </hljs>
160 *
161 * ### Bottomsheet
162 * <hljs lang="html">
163 * <md-bottom-sheet class="md-list md-has-header">
164 *  <md-subheader>Comment Actions</md-subheader>
165 *  <md-list>
166 *    <md-list-item ng-repeat="item in items">
167 *
168 *      <md-button md-autofocus="$index == 2">
169 *        <md-icon md-svg-src="{{item.icon}}"></md-icon>
170 *        <span class="md-inline-list-icon-label">{{ item.name }}</span>
171 *      </md-button>
172 *
173 *    </md-list-item>
174 *  </md-list>
175 * </md-bottom-sheet>
176 * </hljs>
177 *
178 * ### Autocomplete
179 * <hljs lang="html">
180 *   <md-autocomplete
181 *       md-autofocus
182 *       md-selected-item="selectedItem"
183 *       md-search-text="searchText"
184 *       md-items="item in getMatches(searchText)"
185 *       md-item-text="item.display">
186 *     <span md-highlight-text="searchText">{{item.display}}</span>
187 *   </md-autocomplete>
188 * </hljs>
189 *
190 * ### Sidenav
191 * <hljs lang="html">
192 * <div layout="row" ng-controller="MyController">
193 *   <md-sidenav md-component-id="left" class="md-sidenav-left">
194 *     Left Nav!
195 *   </md-sidenav>
196 *
197 *   <md-content>
198 *     Center Content
199 *     <md-button ng-click="openLeftMenu()">
200 *       Open Left Menu
201 *     </md-button>
202 *   </md-content>
203 *
204 *   <md-sidenav md-component-id="right"
205 *     md-is-locked-open="$mdMedia('min-width: 333px')"
206 *     class="md-sidenav-right">
207 *     <form>
208 *       <md-input-container>
209 *         <label for="testInput">Test input</label>
210 *         <input id="testInput" type="text"
211 *                ng-model="data" md-autofocus>
212 *       </md-input-container>
213 *     </form>
214 *   </md-sidenav>
215 * </div>
216 * </hljs>
217 **/
218function MdAutofocusDirective($parse) {
219  return {
220    restrict: 'A',
221    link: {
222      pre: preLink
223    }
224  };
225
226  function preLink(scope, element, attr) {
227    var attrExp = attr.mdAutoFocus || attr.mdAutofocus || attr.mdSidenavFocus;
228
229    // Initially update the expression by manually parsing the expression as per $watch source.
230    updateExpression($parse(attrExp)(scope));
231
232    // Only watch the expression if it is not empty.
233    if (attrExp) {
234      scope.$watch(attrExp, updateExpression);
235    }
236
237    /**
238     * Updates the autofocus class which is used to determine whether the attribute
239     * expression evaluates to true or false.
240     * @param {string|boolean} value Attribute Value
241     */
242    function updateExpression(value) {
243
244      // Rather than passing undefined to the jqLite toggle class function we explicitly set the
245      // value to true. Otherwise the class will be just toggled instead of being forced.
246      if (angular.isUndefined(value)) {
247        value = true;
248      }
249
250      element.toggleClass('md-autofocus', !!value);
251    }
252  }
253
254}
255
256})();
257(function(){
258"use strict";
259
260/**
261 * @ngdoc module
262 * @name material.core.colorUtil
263 * @description
264 * Color Util
265 */
266angular
267  .module('material.core')
268  .factory('$mdColorUtil', ColorUtilFactory);
269
270function ColorUtilFactory() {
271  /**
272   * Converts hex value to RGBA string
273   * @param color {string}
274   * @returns {string}
275   */
276  function hexToRgba (color) {
277    var hex   = color[ 0 ] === '#' ? color.substr(1) : color,
278      dig   = hex.length / 3,
279      red   = hex.substr(0, dig),
280      green = hex.substr(dig, dig),
281      blue  = hex.substr(dig * 2);
282    if (dig === 1) {
283      red += red;
284      green += green;
285      blue += blue;
286    }
287    return 'rgba(' + parseInt(red, 16) + ',' + parseInt(green, 16) + ',' + parseInt(blue, 16) + ',0.1)';
288  }
289
290  /**
291   * Converts rgba value to hex string
292   * @param color {string}
293   * @returns {string}
294   */
295  function rgbaToHex(color) {
296    color = color.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
297
298    var hex = (color && color.length === 4) ? "#" +
299    ("0" + parseInt(color[1],10).toString(16)).slice(-2) +
300    ("0" + parseInt(color[2],10).toString(16)).slice(-2) +
301    ("0" + parseInt(color[3],10).toString(16)).slice(-2) : '';
302
303    return hex.toUpperCase();
304  }
305
306  /**
307   * Converts an RGB color to RGBA
308   * @param color {string}
309   * @returns {string}
310   */
311  function rgbToRgba (color) {
312    return color.replace(')', ', 0.1)').replace('(', 'a(');
313  }
314
315  /**
316   * Converts an RGBA color to RGB
317   * @param color {string}
318   * @returns {string}
319   */
320  function rgbaToRgb (color) {
321    return color
322      ? color.replace('rgba', 'rgb').replace(/,[^\),]+\)/, ')')
323      : 'rgb(0,0,0)';
324  }
325
326  return {
327    rgbaToHex: rgbaToHex,
328    hexToRgba: hexToRgba,
329    rgbToRgba: rgbToRgba,
330    rgbaToRgb: rgbaToRgb
331  };
332}
333
334})();
335(function(){
336"use strict";
337
338angular.module('material.core')
339.factory('$mdConstant', MdConstantFactory);
340
341/**
342 * Factory function that creates the grab-bag $mdConstant service.
343 * @ngInject
344 */
345function MdConstantFactory() {
346
347  var prefixTestEl = document.createElement('div');
348  var vendorPrefix = getVendorPrefix(prefixTestEl);
349  var isWebkit = /webkit/i.test(vendorPrefix);
350  var SPECIAL_CHARS_REGEXP = /([:\-_]+(.))/g;
351
352  function vendorProperty(name) {
353    // Add a dash between the prefix and name, to be able to transform the string into camelcase.
354    var prefixedName = vendorPrefix + '-' + name;
355    var ucPrefix = camelCase(prefixedName);
356    var lcPrefix = ucPrefix.charAt(0).toLowerCase() + ucPrefix.substring(1);
357
358    return hasStyleProperty(prefixTestEl, name)     ? name     :       // The current browser supports the un-prefixed property
359           hasStyleProperty(prefixTestEl, ucPrefix) ? ucPrefix :       // The current browser only supports the prefixed property.
360           hasStyleProperty(prefixTestEl, lcPrefix) ? lcPrefix : name; // Some browsers are only supporting the prefix in lowercase.
361  }
362
363  function hasStyleProperty(testElement, property) {
364    return angular.isDefined(testElement.style[property]);
365  }
366
367  function camelCase(input) {
368    return input.replace(SPECIAL_CHARS_REGEXP, function(matches, separator, letter, offset) {
369      return offset ? letter.toUpperCase() : letter;
370    });
371  }
372
373  function getVendorPrefix(testElement) {
374    var prop, match;
375    var vendorRegex = /^(Moz|webkit|ms)(?=[A-Z])/;
376
377    for (prop in testElement.style) {
378      if (match = vendorRegex.exec(prop)) {
379        return match[0];
380      }
381    }
382  }
383
384  var self = {
385    isInputKey : function(e) { return (e.keyCode >= 31 && e.keyCode <= 90); },
386    isNumPadKey : function(e) { return (3 === e.location && e.keyCode >= 97 && e.keyCode <= 105); },
387    isMetaKey: function(e) { return (e.keyCode >= 91 && e.keyCode <= 93); },
388    isFnLockKey: function(e) { return (e.keyCode >= 112 && e.keyCode <= 145); },
389    isNavigationKey : function(e) {
390      var kc = self.KEY_CODE, NAVIGATION_KEYS =  [kc.SPACE, kc.ENTER, kc.UP_ARROW, kc.DOWN_ARROW];
391      return (NAVIGATION_KEYS.indexOf(e.keyCode) != -1);
392    },
393    hasModifierKey: function(e) {
394      return e.ctrlKey || e.metaKey || e.altKey;
395    },
396
397    /**
398     * Maximum size, in pixels, that can be explicitly set to an element. The actual value varies
399     * between browsers, but IE11 has the very lowest size at a mere 1,533,917px. Ideally we could
400     * compute this value, but Firefox always reports an element to have a size of zero if it
401     * goes over the max, meaning that we'd have to binary search for the value.
402     */
403    ELEMENT_MAX_PIXELS: 1533917,
404
405    /**
406     * Priority for a directive that should run before the directives from ngAria.
407     */
408    BEFORE_NG_ARIA: 210,
409
410    /**
411     * Common Keyboard actions and their associated keycode.
412     */
413    KEY_CODE: {
414      COMMA: 188,
415      SEMICOLON : 186,
416      ENTER: 13,
417      ESCAPE: 27,
418      SPACE: 32,
419      PAGE_UP: 33,
420      PAGE_DOWN: 34,
421      END: 35,
422      HOME: 36,
423      LEFT_ARROW : 37,
424      UP_ARROW : 38,
425      RIGHT_ARROW : 39,
426      DOWN_ARROW : 40,
427      TAB : 9,
428      BACKSPACE: 8,
429      DELETE: 46
430    },
431
432    /**
433     * Vendor prefixed CSS properties to be used to support the given functionality in older browsers
434     * as well.
435     */
436    CSS: {
437      /* Constants */
438      TRANSITIONEND: 'transitionend' + (isWebkit ? ' webkitTransitionEnd' : ''),
439      ANIMATIONEND: 'animationend' + (isWebkit ? ' webkitAnimationEnd' : ''),
440
441      TRANSFORM: vendorProperty('transform'),
442      TRANSFORM_ORIGIN: vendorProperty('transformOrigin'),
443      TRANSITION: vendorProperty('transition'),
444      TRANSITION_DURATION: vendorProperty('transitionDuration'),
445      ANIMATION_PLAY_STATE: vendorProperty('animationPlayState'),
446      ANIMATION_DURATION: vendorProperty('animationDuration'),
447      ANIMATION_NAME: vendorProperty('animationName'),
448      ANIMATION_TIMING: vendorProperty('animationTimingFunction'),
449      ANIMATION_DIRECTION: vendorProperty('animationDirection')
450    },
451
452    /**
453     * As defined in core/style/variables.scss
454     *
455     * $layout-breakpoint-xs:     600px !default;
456     * $layout-breakpoint-sm:     960px !default;
457     * $layout-breakpoint-md:     1280px !default;
458     * $layout-breakpoint-lg:     1920px !default;
459     *
460     */
461    MEDIA: {
462      'xs'        : '(max-width: 599px)'                         ,
463      'gt-xs'     : '(min-width: 600px)'                         ,
464      'sm'        : '(min-width: 600px) and (max-width: 959px)'  ,
465      'gt-sm'     : '(min-width: 960px)'                         ,
466      'md'        : '(min-width: 960px) and (max-width: 1279px)' ,
467      'gt-md'     : '(min-width: 1280px)'                        ,
468      'lg'        : '(min-width: 1280px) and (max-width: 1919px)',
469      'gt-lg'     : '(min-width: 1920px)'                        ,
470      'xl'        : '(min-width: 1920px)'                        ,
471      'landscape' : '(orientation: landscape)'                   ,
472      'portrait'  : '(orientation: portrait)'                    ,
473      'print' : 'print'
474    },
475
476    MEDIA_PRIORITY: [
477      'xl',
478      'gt-lg',
479      'lg',
480      'gt-md',
481      'md',
482      'gt-sm',
483      'sm',
484      'gt-xs',
485      'xs',
486      'landscape',
487      'portrait',
488      'print'
489    ]
490  };
491
492  return self;
493}
494
495})();
496(function(){
497"use strict";
498
499  angular
500    .module('material.core')
501    .config( ["$provide", function($provide){
502       $provide.decorator('$mdUtil', ['$delegate', function ($delegate){
503           /**
504            * Inject the iterator facade to easily support iteration and accessors
505            * @see iterator below
506            */
507           $delegate.iterator = MdIterator;
508
509           return $delegate;
510         }
511       ]);
512     }]);
513
514  /**
515   * iterator is a list facade to easily support iteration and accessors
516   *
517   * @param items Array list which this iterator will enumerate
518   * @param reloop Boolean enables iterator to consider the list as an endless reloop
519   */
520  function MdIterator(items, reloop) {
521    var trueFn = function() { return true; };
522
523    if (items && !angular.isArray(items)) {
524      items = Array.prototype.slice.call(items);
525    }
526
527    reloop = !!reloop;
528    var _items = items || [ ];
529
530    // Published API
531    return {
532      items: getItems,
533      count: count,
534
535      inRange: inRange,
536      contains: contains,
537      indexOf: indexOf,
538      itemAt: itemAt,
539
540      findBy: findBy,
541
542      add: add,
543      remove: remove,
544
545      first: first,
546      last: last,
547      next: angular.bind(null, findSubsequentItem, false),
548      previous: angular.bind(null, findSubsequentItem, true),
549
550      hasPrevious: hasPrevious,
551      hasNext: hasNext
552
553    };
554
555    /**
556     * Publish copy of the enumerable set
557     * @returns {Array|*}
558     */
559    function getItems() {
560      return [].concat(_items);
561    }
562
563    /**
564     * Determine length of the list
565     * @returns {Array.length|*|number}
566     */
567    function count() {
568      return _items.length;
569    }
570
571    /**
572     * Is the index specified valid
573     * @param index
574     * @returns {Array.length|*|number|boolean}
575     */
576    function inRange(index) {
577      return _items.length && ( index > -1 ) && (index < _items.length );
578    }
579
580    /**
581     * Can the iterator proceed to the next item in the list; relative to
582     * the specified item.
583     *
584     * @param item
585     * @returns {Array.length|*|number|boolean}
586     */
587    function hasNext(item) {
588      return item ? inRange(indexOf(item) + 1) : false;
589    }
590
591    /**
592     * Can the iterator proceed to the previous item in the list; relative to
593     * the specified item.
594     *
595     * @param item
596     * @returns {Array.length|*|number|boolean}
597     */
598    function hasPrevious(item) {
599      return item ? inRange(indexOf(item) - 1) : false;
600    }
601
602    /**
603     * Get item at specified index/position
604     * @param index
605     * @returns {*}
606     */
607    function itemAt(index) {
608      return inRange(index) ? _items[index] : null;
609    }
610
611    /**
612     * Find all elements matching the key/value pair
613     * otherwise return null
614     *
615     * @param val
616     * @param key
617     *
618     * @return array
619     */
620    function findBy(key, val) {
621      return _items.filter(function(item) {
622        return item[key] === val;
623      });
624    }
625
626    /**
627     * Add item to list
628     * @param item
629     * @param index
630     * @returns {*}
631     */
632    function add(item, index) {
633      if ( !item ) return -1;
634
635      if (!angular.isNumber(index)) {
636        index = _items.length;
637      }
638
639      _items.splice(index, 0, item);
640
641      return indexOf(item);
642    }
643
644    /**
645     * Remove item from list...
646     * @param item
647     */
648    function remove(item) {
649      if ( contains(item) ){
650        _items.splice(indexOf(item), 1);
651      }
652    }
653
654    /**
655     * Get the zero-based index of the target item
656     * @param item
657     * @returns {*}
658     */
659    function indexOf(item) {
660      return _items.indexOf(item);
661    }
662
663    /**
664     * Boolean existence check
665     * @param item
666     * @returns {boolean}
667     */
668    function contains(item) {
669      return item && (indexOf(item) > -1);
670    }
671
672    /**
673     * Return first item in the list
674     * @returns {*}
675     */
676    function first() {
677      return _items.length ? _items[0] : null;
678    }
679
680    /**
681     * Return last item in the list...
682     * @returns {*}
683     */
684    function last() {
685      return _items.length ? _items[_items.length - 1] : null;
686    }
687
688    /**
689     * Find the next item. If reloop is true and at the end of the list, it will go back to the
690     * first item. If given, the `validate` callback will be used to determine whether the next item
691     * is valid. If not valid, it will try to find the next item again.
692     *
693     * @param {boolean} backwards Specifies the direction of searching (forwards/backwards)
694     * @param {*} item The item whose subsequent item we are looking for
695     * @param {Function=} validate The `validate` function
696     * @param {integer=} limit The recursion limit
697     *
698     * @returns {*} The subsequent item or null
699     */
700    function findSubsequentItem(backwards, item, validate, limit) {
701      validate = validate || trueFn;
702
703      var curIndex = indexOf(item);
704      while (true) {
705        if (!inRange(curIndex)) return null;
706
707        var nextIndex = curIndex + (backwards ? -1 : 1);
708        var foundItem = null;
709        if (inRange(nextIndex)) {
710          foundItem = _items[nextIndex];
711        } else if (reloop) {
712          foundItem = backwards ? last() : first();
713          nextIndex = indexOf(foundItem);
714        }
715
716        if ((foundItem === null) || (nextIndex === limit)) return null;
717        if (validate(foundItem)) return foundItem;
718
719        if (angular.isUndefined(limit)) limit = nextIndex;
720
721        curIndex = nextIndex;
722      }
723    }
724  }
725
726
727})();
728(function(){
729"use strict";
730
731
732mdMediaFactory.$inject = ["$mdConstant", "$rootScope", "$window"];angular.module('material.core')
733.factory('$mdMedia', mdMediaFactory);
734
735/**
736 * @ngdoc service
737 * @name $mdMedia
738 * @module material.core
739 *
740 * @description
741 * `$mdMedia` is used to evaluate whether a given media query is true or false given the
742 * current device's screen / window size. The media query will be re-evaluated on resize, allowing
743 * you to register a watch.
744 *
745 * `$mdMedia` also has pre-programmed support for media queries that match the layout breakpoints:
746 *
747 *  <table class="md-api-table">
748 *    <thead>
749 *    <tr>
750 *      <th>Breakpoint</th>
751 *      <th>mediaQuery</th>
752 *    </tr>
753 *    </thead>
754 *    <tbody>
755 *    <tr>
756 *      <td>xs</td>
757 *      <td>(max-width: 599px)</td>
758 *    </tr>
759 *    <tr>
760 *      <td>gt-xs</td>
761 *      <td>(min-width: 600px)</td>
762 *    </tr>
763 *    <tr>
764 *      <td>sm</td>
765 *      <td>(min-width: 600px) and (max-width: 959px)</td>
766 *    </tr>
767 *    <tr>
768 *      <td>gt-sm</td>
769 *      <td>(min-width: 960px)</td>
770 *    </tr>
771 *    <tr>
772 *      <td>md</td>
773 *      <td>(min-width: 960px) and (max-width: 1279px)</td>
774 *    </tr>
775 *    <tr>
776 *      <td>gt-md</td>
777 *      <td>(min-width: 1280px)</td>
778 *    </tr>
779 *    <tr>
780 *      <td>lg</td>
781 *      <td>(min-width: 1280px) and (max-width: 1919px)</td>
782 *    </tr>
783 *    <tr>
784 *      <td>gt-lg</td>
785 *      <td>(min-width: 1920px)</td>
786 *    </tr>
787 *    <tr>
788 *      <td>xl</td>
789 *      <td>(min-width: 1920px)</td>
790 *    </tr>
791 *    <tr>
792 *      <td>landscape</td>
793 *      <td>landscape</td>
794 *    </tr>
795 *    <tr>
796 *      <td>portrait</td>
797 *      <td>portrait</td>
798 *    </tr>
799 *    <tr>
800 *      <td>print</td>
801 *      <td>print</td>
802 *    </tr>
803 *    </tbody>
804 *  </table>
805 *
806 *  See Material Design's <a href="https://material.google.com/layout/responsive-ui.html">Layout - Adaptive UI</a> for more details.
807 *
808 *  <a href="https://www.google.com/design/spec/layout/adaptive-ui.html">
809 *  <img src="https://material-design.storage.googleapis.com/publish/material_v_4/material_ext_publish/0B8olV15J7abPSGFxemFiQVRtb1k/layout_adaptive_breakpoints_01.png" width="100%" height="100%"></img>
810 *  </a>
811 *
812 * @returns {boolean} a boolean representing whether or not the given media query is true or false.
813 *
814 * @usage
815 * <hljs lang="js">
816 * app.controller('MyController', function($mdMedia, $scope) {
817 *   $scope.$watch(function() { return $mdMedia('lg'); }, function(big) {
818 *     $scope.bigScreen = big;
819 *   });
820 *
821 *   $scope.screenIsSmall = $mdMedia('sm');
822 *   $scope.customQuery = $mdMedia('(min-width: 1234px)');
823 *   $scope.anotherCustom = $mdMedia('max-width: 300px');
824 * });
825 * </hljs>
826 */
827
828/* @ngInject */
829function mdMediaFactory($mdConstant, $rootScope, $window) {
830  var queries = {};
831  var mqls = {};
832  var results = {};
833  var normalizeCache = {};
834
835  $mdMedia.getResponsiveAttribute = getResponsiveAttribute;
836  $mdMedia.getQuery = getQuery;
837  $mdMedia.watchResponsiveAttributes = watchResponsiveAttributes;
838
839  return $mdMedia;
840
841  function $mdMedia(query) {
842    var validated = queries[query];
843    if (angular.isUndefined(validated)) {
844      validated = queries[query] = validate(query);
845    }
846
847    var result = results[validated];
848    if (angular.isUndefined(result)) {
849      result = add(validated);
850    }
851
852    return result;
853  }
854
855  function validate(query) {
856    return $mdConstant.MEDIA[query] ||
857           ((query.charAt(0) !== '(') ? ('(' + query + ')') : query);
858  }
859
860  function add(query) {
861    var result = mqls[query];
862    if ( !result ) {
863      result = mqls[query] = $window.matchMedia(query);
864    }
865
866    result.addListener(onQueryChange);
867    return (results[result.media] = !!result.matches);
868  }
869
870  function onQueryChange(query) {
871    $rootScope.$evalAsync(function() {
872      results[query.media] = !!query.matches;
873    });
874  }
875
876  function getQuery(name) {
877    return mqls[name];
878  }
879
880  function getResponsiveAttribute(attrs, attrName) {
881    for (var i = 0; i < $mdConstant.MEDIA_PRIORITY.length; i++) {
882      var mediaName = $mdConstant.MEDIA_PRIORITY[i];
883      if (!mqls[queries[mediaName]].matches) {
884        continue;
885      }
886
887      var normalizedName = getNormalizedName(attrs, attrName + '-' + mediaName);
888      if (attrs[normalizedName]) {
889        return attrs[normalizedName];
890      }
891    }
892
893    // fallback on unprefixed
894    return attrs[getNormalizedName(attrs, attrName)];
895  }
896
897  function watchResponsiveAttributes(attrNames, attrs, watchFn) {
898    var unwatchFns = [];
899    attrNames.forEach(function(attrName) {
900      var normalizedName = getNormalizedName(attrs, attrName);
901      if (angular.isDefined(attrs[normalizedName])) {
902        unwatchFns.push(
903            attrs.$observe(normalizedName, angular.bind(void 0, watchFn, null)));
904      }
905
906      for (var mediaName in $mdConstant.MEDIA) {
907        normalizedName = getNormalizedName(attrs, attrName + '-' + mediaName);
908        if (angular.isDefined(attrs[normalizedName])) {
909          unwatchFns.push(
910              attrs.$observe(normalizedName, angular.bind(void 0, watchFn, mediaName)));
911        }
912      }
913    });
914
915    return function unwatch() {
916      unwatchFns.forEach(function(fn) { fn(); });
917    };
918  }
919
920  // Improves performance dramatically
921  function getNormalizedName(attrs, attrName) {
922    return normalizeCache[attrName] ||
923        (normalizeCache[attrName] = attrs.$normalize(attrName));
924  }
925}
926
927})();
928(function(){
929"use strict";
930
931angular
932  .module('material.core')
933  .config( ["$provide", function($provide) {
934    $provide.decorator('$mdUtil', ['$delegate', function ($delegate) {
935
936      // Inject the prefixer into our original $mdUtil service.
937      $delegate.prefixer = MdPrefixer;
938
939      return $delegate;
940    }]);
941  }]);
942
943function MdPrefixer(initialAttributes, buildSelector) {
944  var PREFIXES = ['data', 'x'];
945
946  if (initialAttributes) {
947    // The prefixer also accepts attributes as a parameter, and immediately builds a list or selector for
948    // the specified attributes.
949    return buildSelector ? _buildSelector(initialAttributes) : _buildList(initialAttributes);
950  }
951
952  return {
953    buildList: _buildList,
954    buildSelector: _buildSelector,
955    hasAttribute: _hasAttribute,
956    removeAttribute: _removeAttribute
957  };
958
959  function _buildList(attributes) {
960    attributes = angular.isArray(attributes) ? attributes : [attributes];
961
962    attributes.forEach(function(item) {
963      PREFIXES.forEach(function(prefix) {
964        attributes.push(prefix + '-' + item);
965      });
966    });
967
968    return attributes;
969  }
970
971  function _buildSelector(attributes) {
972    attributes = angular.isArray(attributes) ? attributes : [attributes];
973
974    return _buildList(attributes)
975      .map(function(item) {
976        return '[' + item + ']';
977      })
978      .join(',');
979  }
980
981  function _hasAttribute(element, attribute) {
982    element = _getNativeElement(element);
983
984    if (!element) {
985      return false;
986    }
987
988    var prefixedAttrs = _buildList(attribute);
989
990    for (var i = 0; i < prefixedAttrs.length; i++) {
991      if (element.hasAttribute(prefixedAttrs[i])) {
992        return true;
993      }
994    }
995
996    return false;
997  }
998
999  function _removeAttribute(element, attribute) {
1000    element = _getNativeElement(element);
1001
1002    if (!element) {
1003      return;
1004    }
1005
1006    _buildList(attribute).forEach(function(prefixedAttribute) {
1007      element.removeAttribute(prefixedAttribute);
1008    });
1009  }
1010
1011  /**
1012   * Transforms a jqLite or DOM element into a HTML element.
1013   * This is useful when supporting jqLite elements and DOM elements at
1014   * same time.
1015   * @param element {JQLite|Element} Element to be parsed
1016   * @returns {HTMLElement} Parsed HTMLElement
1017   */
1018  function _getNativeElement(element) {
1019    element =  element[0] || element;
1020
1021    if (element.nodeType) {
1022      return element;
1023    }
1024  }
1025
1026}
1027
1028})();
1029(function(){
1030"use strict";
1031
1032/*
1033 * This var has to be outside the angular factory, otherwise when
1034 * there are multiple material apps on the same page, each app
1035 * will create its own instance of this array and the app's IDs
1036 * will not be unique.
1037 */
1038UtilFactory.$inject = ["$document", "$timeout", "$compile", "$rootScope", "$$mdAnimate", "$interpolate", "$log", "$rootElement", "$window", "$$rAF"];
1039var nextUniqueId = 0;
1040
1041/**
1042 * @ngdoc module
1043 * @name material.core.util
1044 * @description
1045 * Util
1046 */
1047angular
1048  .module('material.core')
1049  .factory('$mdUtil', UtilFactory);
1050
1051/**
1052 * @ngInject
1053 */
1054function UtilFactory($document, $timeout, $compile, $rootScope, $$mdAnimate, $interpolate, $log, $rootElement, $window, $$rAF) {
1055  // Setup some core variables for the processTemplate method
1056  var startSymbol = $interpolate.startSymbol(),
1057    endSymbol = $interpolate.endSymbol(),
1058    usesStandardSymbols = ((startSymbol === '{{') && (endSymbol === '}}'));
1059
1060  /**
1061   * Checks if the target element has the requested style by key
1062   * @param {DOMElement|JQLite} target Target element
1063   * @param {string} key Style key
1064   * @param {string=} expectedVal Optional expected value
1065   * @returns {boolean} Whether the target element has the style or not
1066   */
1067  var hasComputedStyle = function (target, key, expectedVal) {
1068    var hasValue = false;
1069
1070    if ( target && target.length  ) {
1071      var computedStyles = $window.getComputedStyle(target[0]);
1072      hasValue = angular.isDefined(computedStyles[key]) && (expectedVal ? computedStyles[key] == expectedVal : true);
1073    }
1074
1075    return hasValue;
1076  };
1077
1078  function validateCssValue(value) {
1079    return !value       ? '0'   :
1080      hasPx(value) || hasPercent(value) ? value : value + 'px';
1081  }
1082
1083  function hasPx(value) {
1084    return String(value).indexOf('px') > -1;
1085  }
1086
1087  function hasPercent(value) {
1088    return String(value).indexOf('%') > -1;
1089
1090  }
1091
1092  var $mdUtil = {
1093    dom: {},
1094    now: window.performance && window.performance.now ?
1095      angular.bind(window.performance, window.performance.now) : Date.now || function() {
1096      return new Date().getTime();
1097    },
1098
1099    /**
1100     * Cross-version compatibility method to retrieve an option of a ngModel controller,
1101     * which supports the breaking changes in the AngularJS snapshot (SHA 87a2ff76af5d0a9268d8eb84db5755077d27c84c).
1102     * @param {!angular.ngModelCtrl} ngModelCtrl
1103     * @param {!string} optionName
1104     * @returns {Object|undefined}
1105     */
1106    getModelOption: function (ngModelCtrl, optionName) {
1107      if (!ngModelCtrl.$options) {
1108        return;
1109      }
1110
1111      var $options = ngModelCtrl.$options;
1112
1113      // The newer versions of AngularJS introduced a `getOption function and made the option values no longer
1114      // visible on the $options object.
1115      return $options.getOption ? $options.getOption(optionName) : $options[optionName]
1116    },
1117
1118    /**
1119     * Bi-directional accessor/mutator used to easily update an element's
1120     * property based on the current 'dir'ectional value.
1121     */
1122    bidi : function(element, property, lValue, rValue) {
1123      var ltr = !($document[0].dir == 'rtl' || $document[0].body.dir == 'rtl');
1124
1125      // If accessor
1126      if ( arguments.length == 0 ) return ltr ? 'ltr' : 'rtl';
1127
1128      // If mutator
1129      var elem = angular.element(element);
1130
1131      if ( ltr && angular.isDefined(lValue)) {
1132        elem.css(property, validateCssValue(lValue));
1133      }
1134      else if ( !ltr && angular.isDefined(rValue)) {
1135        elem.css(property, validateCssValue(rValue) );
1136      }
1137    },
1138
1139    bidiProperty: function (element, lProperty, rProperty, value) {
1140      var ltr = !($document[0].dir == 'rtl' || $document[0].body.dir == 'rtl');
1141
1142      var elem = angular.element(element);
1143
1144      if ( ltr && angular.isDefined(lProperty)) {
1145        elem.css(lProperty, validateCssValue(value));
1146        elem.css(rProperty, '');
1147      }
1148      else if ( !ltr && angular.isDefined(rProperty)) {
1149        elem.css(rProperty, validateCssValue(value) );
1150        elem.css(lProperty, '');
1151      }
1152    },
1153
1154    clientRect: function(element, offsetParent, isOffsetRect) {
1155      var node = getNode(element);
1156      offsetParent = getNode(offsetParent || node.offsetParent || document.body);
1157      var nodeRect = node.getBoundingClientRect();
1158
1159      // The user can ask for an offsetRect: a rect relative to the offsetParent,
1160      // or a clientRect: a rect relative to the page
1161      var offsetRect = isOffsetRect ?
1162        offsetParent.getBoundingClientRect() :
1163      {left: 0, top: 0, width: 0, height: 0};
1164      return {
1165        left: nodeRect.left - offsetRect.left,
1166        top: nodeRect.top - offsetRect.top,
1167        width: nodeRect.width,
1168        height: nodeRect.height
1169      };
1170    },
1171    offsetRect: function(element, offsetParent) {
1172      return $mdUtil.clientRect(element, offsetParent, true);
1173    },
1174
1175    // Annoying method to copy nodes to an array, thanks to IE
1176    nodesToArray: function(nodes) {
1177      nodes = nodes || [];
1178
1179      var results = [];
1180      for (var i = 0; i < nodes.length; ++i) {
1181        results.push(nodes.item(i));
1182      }
1183      return results;
1184    },
1185
1186    /**
1187     * Determines the absolute position of the viewport.
1188     * Useful when making client rectangles absolute.
1189     * @returns {number}
1190     */
1191    getViewportTop: function() {
1192      return window.scrollY || window.pageYOffset || 0;
1193    },
1194
1195    /**
1196     * Finds the proper focus target by searching the DOM.
1197     *
1198     * @param containerEl
1199     * @param attributeVal
1200     * @returns {*}
1201     */
1202    findFocusTarget: function(containerEl, attributeVal) {
1203      var AUTO_FOCUS = this.prefixer('md-autofocus', true);
1204      var elToFocus;
1205
1206      elToFocus = scanForFocusable(containerEl, attributeVal || AUTO_FOCUS);
1207
1208      if ( !elToFocus && attributeVal != AUTO_FOCUS) {
1209        // Scan for deprecated attribute
1210        elToFocus = scanForFocusable(containerEl, this.prefixer('md-auto-focus', true));
1211
1212        if ( !elToFocus ) {
1213          // Scan for fallback to 'universal' API
1214          elToFocus = scanForFocusable(containerEl, AUTO_FOCUS);
1215        }
1216      }
1217
1218      return elToFocus;
1219
1220      /**
1221       * Can target and nested children for specified Selector (attribute)
1222       * whose value may be an expression that evaluates to True/False.
1223       */
1224      function scanForFocusable(target, selector) {
1225        var elFound, items = target[0].querySelectorAll(selector);
1226
1227        // Find the last child element with the focus attribute
1228        if ( items && items.length ){
1229          items.length && angular.forEach(items, function(it) {
1230            it = angular.element(it);
1231
1232            // Check the element for the md-autofocus class to ensure any associated expression
1233            // evaluated to true.
1234            var isFocusable = it.hasClass('md-autofocus');
1235            if (isFocusable) elFound = it;
1236          });
1237        }
1238        return elFound;
1239      }
1240    },
1241
1242    /**
1243     * Disables scroll around the passed parent element.
1244     * @param element Unused
1245     * @param {!Element|!angular.JQLite} parent Element to disable scrolling within.
1246     *   Defaults to body if none supplied.
1247     * @param options Object of options to modify functionality
1248     *   - disableScrollMask Boolean of whether or not to create a scroll mask element or
1249     *     use the passed parent element.
1250     */
1251    disableScrollAround: function(element, parent, options) {
1252      options = options || {};
1253
1254      $mdUtil.disableScrollAround._count = Math.max(0, $mdUtil.disableScrollAround._count || 0);
1255      $mdUtil.disableScrollAround._count++;
1256
1257      if ($mdUtil.disableScrollAround._restoreScroll) {
1258        return $mdUtil.disableScrollAround._restoreScroll;
1259      }
1260
1261      var body = $document[0].body;
1262      var restoreBody = disableBodyScroll();
1263      var restoreElement = disableElementScroll(parent);
1264
1265      return $mdUtil.disableScrollAround._restoreScroll = function() {
1266        if (--$mdUtil.disableScrollAround._count <= 0) {
1267          restoreBody();
1268          restoreElement();
1269          delete $mdUtil.disableScrollAround._restoreScroll;
1270        }
1271      };
1272
1273      /**
1274       * Creates a virtual scrolling mask to prevent touchmove, keyboard, scrollbar clicking,
1275       * and wheel events
1276       */
1277      function disableElementScroll(element) {
1278        element = angular.element(element || body);
1279
1280        var scrollMask;
1281
1282        if (options.disableScrollMask) {
1283          scrollMask = element;
1284        } else {
1285          scrollMask = angular.element(
1286            '<div class="md-scroll-mask">' +
1287            '  <div class="md-scroll-mask-bar"></div>' +
1288            '</div>');
1289          element.append(scrollMask);
1290        }
1291
1292        scrollMask.on('wheel', preventDefault);
1293        scrollMask.on('touchmove', preventDefault);
1294
1295        return function restoreElementScroll() {
1296          scrollMask.off('wheel');
1297          scrollMask.off('touchmove');
1298
1299          if (!options.disableScrollMask && scrollMask[0].parentNode ) {
1300            scrollMask[0].parentNode.removeChild(scrollMask[0]);
1301          }
1302        };
1303
1304        function preventDefault(e) {
1305          e.preventDefault();
1306        }
1307      }
1308
1309      // Converts the body to a position fixed block and translate it to the proper scroll position
1310      function disableBodyScroll() {
1311        var documentElement = $document[0].documentElement;
1312
1313        var prevDocumentStyle = documentElement.style.cssText || '';
1314        var prevBodyStyle = body.style.cssText || '';
1315
1316        var viewportTop = $mdUtil.getViewportTop();
1317        var clientWidth = body.clientWidth;
1318        var hasVerticalScrollbar = body.scrollHeight > body.clientHeight + 1;
1319
1320        // Scroll may be set on <html> element (for example by overflow-y: scroll)
1321        // but Chrome is reporting the scrollTop position always on <body>.
1322        // scrollElement will allow to restore the scrollTop position to proper target.
1323        var scrollElement = documentElement.scrollTop > 0 ? documentElement : body;
1324
1325        if (hasVerticalScrollbar) {
1326          angular.element(body).css({
1327            position: 'fixed',
1328            width: '100%',
1329            top: -viewportTop + 'px'
1330          });
1331        }
1332
1333        if (body.clientWidth < clientWidth) {
1334          body.style.overflow = 'hidden';
1335        }
1336
1337        // This should be applied after the manipulation to the body, because
1338        // adding a scrollbar can potentially resize it, causing the measurement
1339        // to change.
1340        if (hasVerticalScrollbar) {
1341          documentElement.style.overflowY = 'scroll';
1342        }
1343
1344        return function restoreScroll() {
1345          // Reset the inline style CSS to the previous.
1346          body.style.cssText = prevBodyStyle;
1347          documentElement.style.cssText = prevDocumentStyle;
1348
1349          // The scroll position while being fixed
1350          scrollElement.scrollTop = viewportTop;
1351        };
1352      }
1353
1354    },
1355
1356    enableScrolling: function() {
1357      var restoreFn = this.disableScrollAround._restoreScroll;
1358      restoreFn && restoreFn();
1359    },
1360
1361    floatingScrollbars: function() {
1362      if (this.floatingScrollbars.cached === undefined) {
1363        var tempNode = angular.element('<div><div></div></div>').css({
1364          width: '100%',
1365          'z-index': -1,
1366          position: 'absolute',
1367          height: '35px',
1368          'overflow-y': 'scroll'
1369        });
1370        tempNode.children().css('height', '60px');
1371
1372        $document[0].body.appendChild(tempNode[0]);
1373        this.floatingScrollbars.cached = (tempNode[0].offsetWidth == tempNode[0].childNodes[0].offsetWidth);
1374        tempNode.remove();
1375      }
1376      return this.floatingScrollbars.cached;
1377    },
1378
1379    // Mobile safari only allows you to set focus in click event listeners...
1380    forceFocus: function(element) {
1381      var node = element[0] || element;
1382
1383      document.addEventListener('click', function focusOnClick(ev) {
1384        if (ev.target === node && ev.$focus) {
1385          node.focus();
1386          ev.stopImmediatePropagation();
1387          ev.preventDefault();
1388          node.removeEventListener('click', focusOnClick);
1389        }
1390      }, true);
1391
1392      var newEvent = document.createEvent('MouseEvents');
1393      newEvent.initMouseEvent('click', false, true, window, {}, 0, 0, 0, 0,
1394        false, false, false, false, 0, null);
1395      newEvent.$material = true;
1396      newEvent.$focus = true;
1397      node.dispatchEvent(newEvent);
1398    },
1399
1400    /**
1401     * facade to build md-backdrop element with desired styles
1402     * NOTE: Use $compile to trigger backdrop postLink function
1403     */
1404    createBackdrop: function(scope, addClass) {
1405      return $compile($mdUtil.supplant('<md-backdrop class="{0}">', [addClass]))(scope);
1406    },
1407
1408    /**
1409     * supplant() method from Crockford's `Remedial Javascript`
1410     * Equivalent to use of $interpolate; without dependency on
1411     * interpolation symbols and scope. Note: the '{<token>}' can
1412     * be property names, property chains, or array indices.
1413     */
1414    supplant: function(template, values, pattern) {
1415      pattern = pattern || /\{([^\{\}]*)\}/g;
1416      return template.replace(pattern, function(a, b) {
1417        var p = b.split('.'),
1418          r = values;
1419        try {
1420          for (var s in p) {
1421            if (p.hasOwnProperty(s) ) {
1422              r = r[p[s]];
1423            }
1424          }
1425        } catch (e) {
1426          r = a;
1427        }
1428        return (typeof r === 'string' || typeof r === 'number') ? r : a;
1429      });
1430    },
1431
1432    fakeNgModel: function() {
1433      return {
1434        $fake: true,
1435        $setTouched: angular.noop,
1436        $setViewValue: function(value) {
1437          this.$viewValue = value;
1438          this.$render(value);
1439          this.$viewChangeListeners.forEach(function(cb) {
1440            cb();
1441          });
1442        },
1443        $isEmpty: function(value) {
1444          return ('' + value).length === 0;
1445        },
1446        $parsers: [],
1447        $formatters: [],
1448        $viewChangeListeners: [],
1449        $render: angular.noop
1450      };
1451    },
1452
1453    // Returns a function, that, as long as it continues to be invoked, will not
1454    // be triggered. The function will be called after it stops being called for
1455    // N milliseconds.
1456    // @param wait Integer value of msecs to delay (since last debounce reset); default value 10 msecs
1457    // @param invokeApply should the $timeout trigger $digest() dirty checking
1458    debounce: function(func, wait, scope, invokeApply) {
1459      var timer;
1460
1461      return function debounced() {
1462        var context = scope,
1463          args = Array.prototype.slice.call(arguments);
1464
1465        $timeout.cancel(timer);
1466        timer = $timeout(function() {
1467
1468          timer = undefined;
1469          func.apply(context, args);
1470
1471        }, wait || 10, invokeApply);
1472      };
1473    },
1474
1475    // Returns a function that can only be triggered every `delay` milliseconds.
1476    // In other words, the function will not be called unless it has been more
1477    // than `delay` milliseconds since the last call.
1478    throttle: function throttle(func, delay) {
1479      var recent;
1480      return function throttled() {
1481        var context = this;
1482        var args = arguments;
1483        var now = $mdUtil.now();
1484
1485        if (!recent || (now - recent > delay)) {
1486          func.apply(context, args);
1487          recent = now;
1488        }
1489      };
1490    },
1491
1492    /**
1493     * Measures the number of milliseconds taken to run the provided callback
1494     * function. Uses a high-precision timer if available.
1495     */
1496    time: function time(cb) {
1497      var start = $mdUtil.now();
1498      cb();
1499      return $mdUtil.now() - start;
1500    },
1501
1502    /**
1503     * Create an implicit getter that caches its `getter()`
1504     * lookup value
1505     */
1506    valueOnUse : function (scope, key, getter) {
1507      var value = null, args = Array.prototype.slice.call(arguments);
1508      var params = (args.length > 3) ? args.slice(3) : [ ];
1509
1510      Object.defineProperty(scope, key, {
1511        get: function () {
1512          if (value === null) value = getter.apply(scope, params);
1513          return value;
1514        }
1515      });
1516    },
1517
1518    /**
1519     * Get a unique ID.
1520     *
1521     * @returns {string} an unique numeric string
1522     */
1523    nextUid: function() {
1524      return '' + nextUniqueId++;
1525    },
1526
1527    // Stop watchers and events from firing on a scope without destroying it,
1528    // by disconnecting it from its parent and its siblings' linked lists.
1529    disconnectScope: function disconnectScope(scope) {
1530      if (!scope) return;
1531
1532      // we can't destroy the root scope or a scope that has been already destroyed
1533      if (scope.$root === scope) return;
1534      if (scope.$$destroyed) return;
1535
1536      var parent = scope.$parent;
1537      scope.$$disconnected = true;
1538
1539      // See Scope.$destroy
1540      if (parent.$$childHead === scope) parent.$$childHead = scope.$$nextSibling;
1541      if (parent.$$childTail === scope) parent.$$childTail = scope.$$prevSibling;
1542      if (scope.$$prevSibling) scope.$$prevSibling.$$nextSibling = scope.$$nextSibling;
1543      if (scope.$$nextSibling) scope.$$nextSibling.$$prevSibling = scope.$$prevSibling;
1544
1545      scope.$$nextSibling = scope.$$prevSibling = null;
1546
1547    },
1548
1549    // Undo the effects of disconnectScope above.
1550    reconnectScope: function reconnectScope(scope) {
1551      if (!scope) return;
1552
1553      // we can't disconnect the root node or scope already disconnected
1554      if (scope.$root === scope) return;
1555      if (!scope.$$disconnected) return;
1556
1557      var child = scope;
1558
1559      var parent = child.$parent;
1560      child.$$disconnected = false;
1561      // See Scope.$new for this logic...
1562      child.$$prevSibling = parent.$$childTail;
1563      if (parent.$$childHead) {
1564        parent.$$childTail.$$nextSibling = child;
1565        parent.$$childTail = child;
1566      } else {
1567        parent.$$childHead = parent.$$childTail = child;
1568      }
1569    },
1570
1571    /*
1572     * getClosest replicates jQuery.closest() to walk up the DOM tree until it finds a matching nodeName
1573     *
1574     * @param el Element to start walking the DOM from
1575     * @param check Either a string or a function. If a string is passed, it will be evaluated against
1576     * each of the parent nodes' tag name. If a function is passed, the loop will call it with each of
1577     * the parents and will use the return value to determine whether the node is a match.
1578     * @param onlyParent Only start checking from the parent element, not `el`.
1579     */
1580    getClosest: function getClosest(el, validateWith, onlyParent) {
1581      if ( angular.isString(validateWith) ) {
1582        var tagName = validateWith.toUpperCase();
1583        validateWith = function(el) {
1584          return el.nodeName.toUpperCase() === tagName;
1585        };
1586      }
1587
1588      if (el instanceof angular.element) el = el[0];
1589      if (onlyParent) el = el.parentNode;
1590      if (!el) return null;
1591
1592      do {
1593        if (validateWith(el)) {
1594          return el;
1595        }
1596      } while (el = el.parentNode);
1597
1598      return null;
1599    },
1600
1601    /**
1602     * Build polyfill for the Node.contains feature (if needed)
1603     */
1604    elementContains: function(node, child) {
1605      var hasContains = (window.Node && window.Node.prototype && Node.prototype.contains);
1606      var findFn = hasContains ? angular.bind(node, node.contains) : angular.bind(node, function(arg) {
1607        // compares the positions of two nodes and returns a bitmask
1608        return (node === child) || !!(this.compareDocumentPosition(arg) & 16)
1609      });
1610
1611      return findFn(child);
1612    },
1613
1614    /**
1615     * Functional equivalent for $element.filter(‘md-bottom-sheet’)
1616     * useful with interimElements where the element and its container are important...
1617     *
1618     * @param {[]} elements to scan
1619     * @param {string} name of node to find (e.g. 'md-dialog')
1620     * @param {boolean=} optional flag to allow deep scans; defaults to 'false'.
1621     * @param {boolean=} optional flag to enable log warnings; defaults to false
1622     */
1623    extractElementByName: function(element, nodeName, scanDeep, warnNotFound) {
1624      var found = scanTree(element);
1625      if (!found && !!warnNotFound) {
1626        $log.warn( $mdUtil.supplant("Unable to find node '{0}' in element '{1}'.",[nodeName, element[0].outerHTML]) );
1627      }
1628
1629      return angular.element(found || element);
1630
1631      /**
1632       * Breadth-First tree scan for element with matching `nodeName`
1633       */
1634      function scanTree(element) {
1635        return scanLevel(element) || (!!scanDeep ? scanChildren(element) : null);
1636      }
1637
1638      /**
1639       * Case-insensitive scan of current elements only (do not descend).
1640       */
1641      function scanLevel(element) {
1642        if ( element ) {
1643          for (var i = 0, len = element.length; i < len; i++) {
1644            if (element[i].nodeName.toLowerCase() === nodeName) {
1645              return element[i];
1646            }
1647          }
1648        }
1649        return null;
1650      }
1651
1652      /**
1653       * Scan children of specified node
1654       */
1655      function scanChildren(element) {
1656        var found;
1657        if ( element ) {
1658          for (var i = 0, len = element.length; i < len; i++) {
1659            var target = element[i];
1660            if ( !found ) {
1661              for (var j = 0, numChild = target.childNodes.length; j < numChild; j++) {
1662                found = found || scanTree([target.childNodes[j]]);
1663              }
1664            }
1665          }
1666        }
1667        return found;
1668      }
1669
1670    },
1671
1672    /**
1673     * Give optional properties with no value a boolean true if attr provided or false otherwise
1674     */
1675    initOptionalProperties: function(scope, attr, defaults) {
1676      defaults = defaults || {};
1677      angular.forEach(scope.$$isolateBindings, function(binding, key) {
1678        if (binding.optional && angular.isUndefined(scope[key])) {
1679          var attrIsDefined = angular.isDefined(attr[binding.attrName]);
1680          scope[key] = angular.isDefined(defaults[key]) ? defaults[key] : attrIsDefined;
1681        }
1682      });
1683    },
1684
1685    /**
1686     * Alternative to $timeout calls with 0 delay.
1687     * nextTick() coalesces all calls within a single frame
1688     * to minimize $digest thrashing
1689     *
1690     * @param callback
1691     * @param digest
1692     * @returns {*}
1693     */
1694    nextTick: function(callback, digest, scope) {
1695      //-- grab function reference for storing state details
1696      var nextTick = $mdUtil.nextTick;
1697      var timeout = nextTick.timeout;
1698      var queue = nextTick.queue || [];
1699
1700      //-- add callback to the queue
1701      queue.push({scope: scope, callback: callback});
1702
1703      //-- set default value for digest
1704      if (digest == null) digest = true;
1705
1706      //-- store updated digest/queue values
1707      nextTick.digest = nextTick.digest || digest;
1708      nextTick.queue = queue;
1709
1710      //-- either return existing timeout or create a new one
1711      return timeout || (nextTick.timeout = $timeout(processQueue, 0, false));
1712
1713      /**
1714       * Grab a copy of the current queue
1715       * Clear the queue for future use
1716       * Process the existing queue
1717       * Trigger digest if necessary
1718       */
1719      function processQueue() {
1720        var queue = nextTick.queue;
1721        var digest = nextTick.digest;
1722
1723        nextTick.queue = [];
1724        nextTick.timeout = null;
1725        nextTick.digest = false;
1726
1727        queue.forEach(function(queueItem) {
1728          var skip = queueItem.scope && queueItem.scope.$$destroyed;
1729          if (!skip) {
1730            queueItem.callback();
1731          }
1732        });
1733
1734        if (digest) $rootScope.$digest();
1735      }
1736    },
1737
1738    /**
1739     * Processes a template and replaces the start/end symbols if the application has
1740     * overriden them.
1741     *
1742     * @param template The template to process whose start/end tags may be replaced.
1743     * @returns {*}
1744     */
1745    processTemplate: function(template) {
1746      if (usesStandardSymbols) {
1747        return template;
1748      } else {
1749        if (!template || !angular.isString(template)) return template;
1750        return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
1751      }
1752    },
1753
1754    /**
1755     * Scan up dom hierarchy for enabled parent;
1756     */
1757    getParentWithPointerEvents: function (element) {
1758      var parent = element.parent();
1759
1760      // jqLite might return a non-null, but still empty, parent; so check for parent and length
1761      while (hasComputedStyle(parent, 'pointer-events', 'none')) {
1762        parent = parent.parent();
1763      }
1764
1765      return parent;
1766    },
1767
1768    getNearestContentElement: function (element) {
1769      var current = element.parent()[0];
1770      // Look for the nearest parent md-content, stopping at the rootElement.
1771      while (current && current !== $rootElement[0] && current !== document.body && current.nodeName.toUpperCase() !== 'MD-CONTENT') {
1772        current = current.parentNode;
1773      }
1774      return current;
1775    },
1776
1777    /**
1778     * Checks if the current browser is natively supporting the `sticky` position.
1779     * @returns {string} supported sticky property name
1780     */
1781    checkStickySupport: function() {
1782      var stickyProp;
1783      var testEl = angular.element('<div>');
1784      $document[0].body.appendChild(testEl[0]);
1785
1786      var stickyProps = ['sticky', '-webkit-sticky'];
1787      for (var i = 0; i < stickyProps.length; ++i) {
1788        testEl.css({
1789          position: stickyProps[i],
1790          top: 0,
1791          'z-index': 2
1792        });
1793
1794        if (testEl.css('position') == stickyProps[i]) {
1795          stickyProp = stickyProps[i];
1796          break;
1797        }
1798      }
1799
1800      testEl.remove();
1801
1802      return stickyProp;
1803    },
1804
1805    /**
1806     * Parses an attribute value, mostly a string.
1807     * By default checks for negated values and returns `false´ if present.
1808     * Negated values are: (native falsy) and negative strings like:
1809     * `false` or `0`.
1810     * @param value Attribute value which should be parsed.
1811     * @param negatedCheck When set to false, won't check for negated values.
1812     * @returns {boolean}
1813     */
1814    parseAttributeBoolean: function(value, negatedCheck) {
1815      return value === '' || !!value && (negatedCheck === false || value !== 'false' && value !== '0');
1816    },
1817
1818    hasComputedStyle: hasComputedStyle,
1819
1820    /**
1821     * Returns true if the parent form of the element has been submitted.
1822     *
1823     * @param element An AngularJS or HTML5 element.
1824     *
1825     * @returns {boolean}
1826     */
1827    isParentFormSubmitted: function(element) {
1828      var parent = $mdUtil.getClosest(element, 'form');
1829      var form = parent ? angular.element(parent).controller('form') : null;
1830
1831      return form ? form.$submitted : false;
1832    },
1833
1834    /**
1835     * Animate the requested element's scrollTop to the requested scrollPosition with basic easing.
1836     *
1837     * @param {!HTMLElement} element The element to scroll.
1838     * @param {number} scrollEnd The new/final scroll position.
1839     * @param {number=} duration Duration of the scroll. Default is 1000ms.
1840     */
1841    animateScrollTo: function(element, scrollEnd, duration) {
1842      var scrollStart = element.scrollTop;
1843      var scrollChange = scrollEnd - scrollStart;
1844      var scrollingDown = scrollStart < scrollEnd;
1845      var startTime = $mdUtil.now();
1846
1847      $$rAF(scrollChunk);
1848
1849      function scrollChunk() {
1850        var newPosition = calculateNewPosition();
1851
1852        element.scrollTop = newPosition;
1853
1854        if (scrollingDown ? newPosition < scrollEnd : newPosition > scrollEnd) {
1855          $$rAF(scrollChunk);
1856        }
1857      }
1858
1859      function calculateNewPosition() {
1860        var easeDuration = duration || 1000;
1861        var currentTime = $mdUtil.now() - startTime;
1862
1863        return ease(currentTime, scrollStart, scrollChange, easeDuration);
1864      }
1865
1866      function ease(currentTime, start, change, duration) {
1867        // If the duration has passed (which can occur if our app loses focus due to $$rAF), jump
1868        // straight to the proper position
1869        if (currentTime > duration) {
1870          return start + change;
1871        }
1872
1873        var ts = (currentTime /= duration) * currentTime;
1874        var tc = ts * currentTime;
1875
1876        return start + change * (-2 * tc + 3 * ts);
1877      }
1878    },
1879
1880    /**
1881     * Provides an easy mechanism for removing duplicates from an array.
1882     *
1883     *    var myArray = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
1884     *
1885     *    $mdUtil.uniq(myArray) => [1, 2, 3, 4]
1886     *
1887     * @param {array} array The array whose unique values should be returned.
1888     *
1889     * @returns {array} A copy of the array containing only unique values.
1890     */
1891    uniq: function(array) {
1892      if (!array) { return; }
1893
1894      return array.filter(function(value, index, self) {
1895        return self.indexOf(value) === index;
1896      });
1897    }
1898  };
1899
1900
1901// Instantiate other namespace utility methods
1902
1903  $mdUtil.dom.animator = $$mdAnimate($mdUtil);
1904
1905  return $mdUtil;
1906
1907  function getNode(el) {
1908    return el[0] || el;
1909  }
1910
1911}
1912
1913/*
1914 * Since removing jQuery from the demos, some code that uses `element.focus()` is broken.
1915 * We need to add `element.focus()`, because it's testable unlike `element[0].focus`.
1916 */
1917
1918angular.element.prototype.focus = angular.element.prototype.focus || function() {
1919    if (this.length) {
1920      this[0].focus();
1921    }
1922    return this;
1923  };
1924angular.element.prototype.blur = angular.element.prototype.blur || function() {
1925    if (this.length) {
1926      this[0].blur();
1927    }
1928    return this;
1929  };
1930
1931})();
1932(function(){
1933"use strict";
1934
1935/**
1936 * @ngdoc module
1937 * @name material.core.aria
1938 * @description
1939 * Aria Expectations for AngularJS Material components.
1940 */
1941MdAriaService.$inject = ["$$rAF", "$log", "$window", "$interpolate"];
1942angular
1943  .module('material.core')
1944  .provider('$mdAria', MdAriaProvider);
1945
1946/**
1947 * @ngdoc service
1948 * @name $mdAriaProvider
1949 * @module material.core.aria
1950 *
1951 * @description
1952 *
1953 * Modify options of the `$mdAria` service, which will be used by most of the AngularJS Material
1954 * components.
1955 *
1956 * You are able to disable `$mdAria` warnings, by using the following markup.
1957 *
1958 * <hljs lang="js">
1959 *   app.config(function($mdAriaProvider) {
1960 *     // Globally disables all ARIA warnings.
1961 *     $mdAriaProvider.disableWarnings();
1962 *   });
1963 * </hljs>
1964 *
1965 */
1966function MdAriaProvider() {
1967
1968  var config = {
1969    /** Whether we should show ARIA warnings in the console if labels are missing on the element */
1970    showWarnings: true
1971  };
1972
1973  return {
1974    disableWarnings: disableWarnings,
1975    $get: ["$$rAF", "$log", "$window", "$interpolate", function($$rAF, $log, $window, $interpolate) {
1976      return MdAriaService.apply(config, arguments);
1977    }]
1978  };
1979
1980  /**
1981   * @ngdoc method
1982   * @name $mdAriaProvider#disableWarnings
1983   * @description Disables all ARIA warnings generated by AngularJS Material.
1984   */
1985  function disableWarnings() {
1986    config.showWarnings = false;
1987  }
1988}
1989
1990/*
1991 * @ngInject
1992 */
1993function MdAriaService($$rAF, $log, $window, $interpolate) {
1994
1995  // Load the showWarnings option from the current context and store it inside of a scope variable,
1996  // because the context will be probably lost in some function calls.
1997  var showWarnings = this.showWarnings;
1998
1999  return {
2000    expect: expect,
2001    expectAsync: expectAsync,
2002    expectWithText: expectWithText,
2003    expectWithoutText: expectWithoutText,
2004    getText: getText,
2005    hasAriaLabel: hasAriaLabel,
2006    parentHasAriaLabel: parentHasAriaLabel
2007  };
2008
2009  /**
2010   * Check if expected attribute has been specified on the target element or child
2011   * @param element
2012   * @param attrName
2013   * @param {optional} defaultValue What to set the attr to if no value is found
2014   */
2015  function expect(element, attrName, defaultValue) {
2016
2017    var node = angular.element(element)[0] || element;
2018
2019    // if node exists and neither it nor its children have the attribute
2020    if (node &&
2021       ((!node.hasAttribute(attrName) ||
2022        node.getAttribute(attrName).length === 0) &&
2023        !childHasAttribute(node, attrName))) {
2024
2025      defaultValue = angular.isString(defaultValue) ? defaultValue.trim() : '';
2026      if (defaultValue.length) {
2027        element.attr(attrName, defaultValue);
2028      } else if (showWarnings) {
2029        $log.warn('ARIA: Attribute "', attrName, '", required for accessibility, is missing on node:', node);
2030      }
2031
2032    }
2033  }
2034
2035  function expectAsync(element, attrName, defaultValueGetter) {
2036    // Problem: when retrieving the element's contents synchronously to find the label,
2037    // the text may not be defined yet in the case of a binding.
2038    // There is a higher chance that a binding will be defined if we wait one frame.
2039    $$rAF(function() {
2040        expect(element, attrName, defaultValueGetter());
2041    });
2042  }
2043
2044  function expectWithText(element, attrName) {
2045    var content = getText(element) || "";
2046    var hasBinding = content.indexOf($interpolate.startSymbol()) > -1;
2047
2048    if (hasBinding) {
2049      expectAsync(element, attrName, function() {
2050        return getText(element);
2051      });
2052    } else {
2053      expect(element, attrName, content);
2054    }
2055  }
2056
2057  function expectWithoutText(element, attrName) {
2058    var content = getText(element);
2059    var hasBinding = content.indexOf($interpolate.startSymbol()) > -1;
2060
2061    if ( !hasBinding && !content) {
2062      expect(element, attrName, content);
2063    }
2064  }
2065
2066  function getText(element) {
2067    element = element[0] || element;
2068    var walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT, null, false);
2069    var text = '';
2070
2071    var node;
2072    while (node = walker.nextNode()) {
2073      if (!isAriaHiddenNode(node)) {
2074        text += node.textContent;
2075      }
2076    }
2077
2078    return text.trim() || '';
2079
2080    function isAriaHiddenNode(node) {
2081      while (node.parentNode && (node = node.parentNode) !== element) {
2082        if (node.getAttribute && node.getAttribute('aria-hidden') === 'true') {
2083          return true;
2084        }
2085      }
2086    }
2087  }
2088
2089  function childHasAttribute(node, attrName) {
2090    var hasChildren = node.hasChildNodes(),
2091        hasAttr = false;
2092
2093    function isHidden(el) {
2094      var style = el.currentStyle ? el.currentStyle : $window.getComputedStyle(el);
2095      return (style.display === 'none');
2096    }
2097
2098    if (hasChildren) {
2099      var children = node.childNodes;
2100      for (var i=0; i < children.length; i++) {
2101        var child = children[i];
2102        if (child.nodeType === 1 && child.hasAttribute(attrName)) {
2103          if (!isHidden(child)) {
2104            hasAttr = true;
2105          }
2106        }
2107      }
2108    }
2109    return hasAttr;
2110  }
2111
2112  /**
2113   * Check if expected element has aria label attribute
2114   * @param element
2115   */
2116  function hasAriaLabel(element) {
2117    var node = angular.element(element)[0] || element;
2118
2119    /* Check if compatible node type (ie: not HTML Document node) */
2120    if (!node.hasAttribute) {
2121      return false;
2122    }
2123
2124    /* Check label or description attributes */
2125    return node.hasAttribute('aria-label') || node.hasAttribute('aria-labelledby') || node.hasAttribute('aria-describedby');
2126  }
2127
2128  /**
2129   * Check if expected element's parent has aria label attribute and has valid role and tagName
2130   * @param element
2131   * @param {optional} level Number of levels deep search should be performed
2132   */
2133  function parentHasAriaLabel(element, level) {
2134    level = level || 1;
2135    var node = angular.element(element)[0] || element;
2136    if (!node.parentNode) {
2137      return false;
2138    }
2139    if (performCheck(node.parentNode)) {
2140      return true;
2141    }
2142    level--;
2143    if (level) {
2144      return parentHasAriaLabel(node.parentNode, level);
2145    }
2146    return false;
2147
2148    function performCheck(parentNode) {
2149      if (!hasAriaLabel(parentNode)) {
2150        return false;
2151      }
2152      /* Perform role blacklist check */
2153      if (parentNode.hasAttribute('role')) {
2154        switch(parentNode.getAttribute('role').toLowerCase()) {
2155          case 'command':
2156          case 'definition':
2157          case 'directory':
2158          case 'grid':
2159          case 'list':
2160          case 'listitem':
2161          case 'log':
2162          case 'marquee':
2163          case 'menu':
2164          case 'menubar':
2165          case 'note':
2166          case 'presentation':
2167          case 'separator':
2168          case 'scrollbar':
2169          case 'status':
2170          case 'tablist':
2171            return false;
2172        }
2173      }
2174      /* Perform tagName blacklist check */
2175      switch(parentNode.tagName.toLowerCase()) {
2176        case 'abbr':
2177        case 'acronym':
2178        case 'address':
2179        case 'applet':
2180        case 'audio':
2181        case 'b':
2182        case 'bdi':
2183        case 'bdo':
2184        case 'big':
2185        case 'blockquote':
2186        case 'br':
2187        case 'canvas':
2188        case 'caption':
2189        case 'center':
2190        case 'cite':
2191        case 'code':
2192        case 'col':
2193        case 'data':
2194        case 'dd':
2195        case 'del':
2196        case 'dfn':
2197        case 'dir':
2198        case 'div':
2199        case 'dl':
2200        case 'em':
2201        case 'embed':
2202        case 'fieldset':
2203        case 'figcaption':
2204        case 'font':
2205        case 'h1':
2206        case 'h2':
2207        case 'h3':
2208        case 'h4':
2209        case 'h5':
2210        case 'h6':
2211        case 'hgroup':
2212        case 'html':
2213        case 'i':
2214        case 'ins':
2215        case 'isindex':
2216        case 'kbd':
2217        case 'keygen':
2218        case 'label':
2219        case 'legend':
2220        case 'li':
2221        case 'map':
2222        case 'mark':
2223        case 'menu':
2224        case 'object':
2225        case 'ol':
2226        case 'output':
2227        case 'pre':
2228        case 'presentation':
2229        case 'q':
2230        case 'rt':
2231        case 'ruby':
2232        case 'samp':
2233        case 'small':
2234        case 'source':
2235        case 'span':
2236        case 'status':
2237        case 'strike':
2238        case 'strong':
2239        case 'sub':
2240        case 'sup':
2241        case 'svg':
2242        case 'tbody':
2243        case 'td':
2244        case 'th':
2245        case 'thead':
2246        case 'time':
2247        case 'tr':
2248        case 'track':
2249        case 'tt':
2250        case 'ul':
2251        case 'var':
2252          return false;
2253      }
2254      return true;
2255    }
2256  }
2257}
2258
2259})();
2260(function(){
2261"use strict";
2262
2263/**
2264 * @ngdoc module
2265 * @name material.core.compiler
2266 * @description
2267 * AngularJS Material template and element compiler.
2268 */
2269angular
2270  .module('material.core')
2271  .provider('$mdCompiler', MdCompilerProvider);
2272
2273/**
2274 * @ngdoc provider
2275 * @name $mdCompilerProvider
2276 *
2277 * @description
2278 */
2279/**
2280 * @ngdoc service
2281 * @name $mdCompiler
2282 * @module material.core.compiler
2283 * @description
2284 * The $mdCompiler service is an abstraction of AngularJS's compiler, that allows developers
2285 * to easily compile an element with options like in a Directive Definition Object.
2286 *
2287 * > The compiler powers a lot of components inside of AngularJS Material.
2288 * > Like the `$mdPanel` or `$mdDialog`.
2289 *
2290 * @usage
2291 *
2292 * Basic Usage with a template
2293 *
2294 * <hljs lang="js">
2295 *   $mdCompiler.compile({
2296 *     templateUrl: 'modal.html',
2297 *     controller: 'ModalCtrl',
2298 *     locals: {
2299 *       modal: myModalInstance;
2300 *     }
2301 *   }).then(function (compileData) {
2302 *     compileData.element; // Compiled DOM element
2303 *     compileData.link(myScope); // Instantiate controller and link element to scope.
2304 *   });
2305 * </hljs>
2306 *
2307 * Example with a content element
2308 *
2309 * <hljs lang="js">
2310 *
2311 *   // Create a virtual element and link it manually.
2312 *   // The compiler doesn't need to recompile the element each time.
2313 *   var myElement = $compile('<span>Test</span>')(myScope);
2314 *
2315 *   $mdCompiler.compile({
2316 *     contentElement: myElement
2317 *   }).then(function (compileData) {
2318 *     compileData.element // Content Element (same as above)
2319 *     compileData.link // This does nothing when using a contentElement.
2320 *   });
2321 * </hljs>
2322 *
2323 * > Content Element is a significant performance improvement when the developer already knows that the
2324 * > compiled element will be always the same and the scope will not change either.
2325 *
2326 * The `contentElement` option also supports DOM elements which will be temporary removed and restored
2327 * at its old position.
2328 *
2329 * <hljs lang="js">
2330 *   var domElement = document.querySelector('#myElement');
2331 *
2332 *   $mdCompiler.compile({
2333 *     contentElement: myElement
2334 *   }).then(function (compileData) {
2335 *     compileData.element // Content Element (same as above)
2336 *     compileData.link // This does nothing when using a contentElement.
2337 *   });
2338 * </hljs>
2339 *
2340 * The `$mdCompiler` can also query for the element in the DOM itself.
2341 *
2342 * <hljs lang="js">
2343 *   $mdCompiler.compile({
2344 *     contentElement: '#myElement'
2345 *   }).then(function (compileData) {
2346 *     compileData.element // Content Element (same as above)
2347 *     compileData.link // This does nothing when using a contentElement.
2348 *   });
2349 * </hljs>
2350 *
2351 */
2352MdCompilerProvider.$inject = ['$compileProvider'];
2353function MdCompilerProvider($compileProvider) {
2354
2355  var provider = this;
2356
2357  /**
2358   * @ngdoc method
2359   * @name  $mdCompilerProvider#respectPreAssignBindingsEnabled
2360   *
2361   * @param {boolean=} respected update the respectPreAssignBindingsEnabled state if provided, otherwise just return
2362   * the current Material preAssignBindingsEnabled state
2363   * @returns {*} current value if used as getter or itself (chaining) if used as setter
2364   *
2365   * @kind function
2366   *
2367   * @description
2368   * Call this method to enable/disable whether Material-specific (dialogs/toasts) controllers respect the AngularJS
2369   * `$compile.preAssignBindingsEnabled` flag. Note that this doesn't affect directives/components created via
2370   * regular AngularJS methods which constitute most Material & user-created components.
2371   *
2372   * @see [AngularJS documentation for `$compile.preAssignBindingsEnabled`
2373   * ](https://code.angularjs.org/1.6.4/docs/api/ng/provider/$compileProvider#preAssignBindingsEnabled)
2374   * for more information.
2375   *
2376   * If disabled (false), the compiler assigns the value of each of the bindings to the
2377   * properties of the controller object before the constructor of this object is called.
2378   *
2379   * If enabled (true) the behavior depends on the AngularJS version used:
2380   *
2381   *     - `<1.5.10` - bindings are pre-assigned
2382   *     - `>=1.5.10 <1.7` - behaves like set to whatever `$compileProvider.preAssignBindingsEnabled()` reports; if