https://www.nordkapp.kommune.no/Maler/Standard/Handlers/ScriptHand…=2&sprakID=1&designID=2&v=18.0.4951

1// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
2// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
3// requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel
4// MIT license
5
6(function () {
7  var lastTime = 0;
8  var vendors = ['ms', 'moz', 'webkit', 'o'];
9  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
10    window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
11    window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] ||
12      window[vendors[x] + 'CancelRequestAnimationFrame'];
13  }
14
15  if (!window.requestAnimationFrame)
16    window.requestAnimationFrame = function (callback, element) {
17      var currTime = new Date().getTime();
18      var timeToCall = Math.max(0, 16 - (currTime - lastTime));
19      var id = window.setTimeout(function () {
20          callback(currTime + timeToCall);
21        },
22        timeToCall);
23      lastTime = currTime + timeToCall;
24      return id;
25    };
26
27  if (!window.cancelAnimationFrame)
28    window.cancelAnimationFrame = function (id) {
29      clearTimeout(id);
30    };
31}());
32
33(function (root) {
34
35  // Store setTimeout reference so promise-polyfill will be unaffected by
36  // other code modifying setTimeout (like sinon.useFakeTimers())
37  var setTimeoutFunc = setTimeout;
38
39  function noop() {}
40
41  // Polyfill for Function.prototype.bind
42  function bind(fn, thisArg) {
43    return function () {
44      fn.apply(thisArg, arguments);
45    };
46  }
47
48  function Promise(fn) {
49    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
50    if (typeof fn !== 'function') throw new TypeError('not a function');
51    this._state = 0;
52    this._handled = false;
53    this._value = undefined;
54    this._deferreds = [];
55
56    doResolve(fn, this);
57  }
58
59  function handle(self, deferred) {
60    while (self._state === 3) {
61      self = self._value;
62    }
63    if (self._state === 0) {
64      self._deferreds.push(deferred);
65      return;
66    }
67    self._handled = true;
68    Promise._immediateFn(function () {
69      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
70      if (cb === null) {
71        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
72        return;
73      }
74      var ret;
75      try {
76        ret = cb(self._value);
77      } catch (e) {
78        reject(deferred.promise, e);
79        return;
80      }
81      resolve(deferred.promise, ret);
82    });
83  }
84
85  function resolve(self, newValue) {
86    try {
87      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
88      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
89      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
90        var then = newValue.then;
91        if (newValue instanceof Promise) {
92          self._state = 3;
93          self._value = newValue;
94          finale(self);
95          return;
96        } else if (typeof then === 'function') {
97          doResolve(bind(then, newValue), self);
98          return;
99        }
100      }
101      self._state = 1;
102      self._value = newValue;
103      finale(self);
104    } catch (e) {
105      reject(self, e);
106    }
107  }
108
109  function reject(self, newValue) {
110    self._state = 2;
111    self._value = newValue;
112    finale(self);
113  }
114
115  function finale(self) {
116    if (self._state === 2 && self._deferreds.length === 0) {
117      Promise._immediateFn(function () {
118        if (!self._handled) {
119          Promise._unhandledRejectionFn(self._value);
120        }
121      });
122    }
123
124    for (var i = 0, len = self._deferreds.length; i < len; i++) {
125      handle(self, self._deferreds[i]);
126    }
127    self._deferreds = null;
128  }
129
130  function Handler(onFulfilled, onRejected, promise) {
131    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
132    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
133    this.promise = promise;
134  }
135
136  /**
137   * Take a potentially misbehaving resolver function and make sure
138   * onFulfilled and onRejected are only called once.
139   *
140   * Makes no guarantees about asynchrony.
141   */
142  function doResolve(fn, self) {
143    var done = false;
144    try {
145      fn(function (value) {
146        if (done) return;
147        done = true;
148        resolve(self, value);
149      }, function (reason) {
150        if (done) return;
151        done = true;
152        reject(self, reason);
153      });
154    } catch (ex) {
155      if (done) return;
156      done = true;
157      reject(self, ex);
158    }
159  }
160
161  Promise.prototype['catch'] = function (onRejected) {
162    return this.then(null, onRejected);
163  };
164
165  Promise.prototype.then = function (onFulfilled, onRejected) {
166    var prom = new(this.constructor)(noop);
167
168    handle(this, new Handler(onFulfilled, onRejected, prom));
169    return prom;
170  };
171
172  Promise.all = function (arr) {
173    var args = Array.prototype.slice.call(arr);
174
175    return new Promise(function (resolve, reject) {
176      if (args.length === 0) return resolve([]);
177      var remaining = args.length;
178
179      function res(i, val) {
180        try {
181          if (val && (typeof val === 'object' || typeof val === 'function')) {
182            var then = val.then;
183            if (typeof then === 'function') {
184              then.call(val, function (val) {
185                res(i, val);
186              }, reject);
187              return;
188            }
189          }
190          args[i] = val;
191          if (--remaining === 0) {
192            resolve(args);
193          }
194        } catch (ex) {
195          reject(ex);
196        }
197      }
198
199      for (var i = 0; i < args.length; i++) {
200        res(i, args[i]);
201      }
202    });

203  };
204
205  Promise.resolve = function (value) {
206    if (value && typeof value === 'object' && value.constructor === Promise) {
207      return value;
208    }
209
210    return new Promise(function (resolve) {
211      resolve(value);
212    });
213  };
214
215  Promise.reject = function (value) {
216    return new Promise(function (resolve, reject) {
217      reject(value);
218    });
219  };
220
221  Promise.race = function (values) {
222    return new Promise(function (resolve, reject) {
223      for (var i = 0, len = values.length; i < len; i++) {
224        values[i].then(resolve, reject);
225      }
226    });
227  };
228
229  // Use polyfill for setImmediate for performance gains
230  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) {
231      setImmediate(fn);
232    }) ||
233    function (fn) {
234      setTimeoutFunc(fn, 0);
235    };
236
237  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
238    if (typeof console !== 'undefined' && console) {
239      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
240    }
241  };
242
243  /**
244   * Set the immediate function to execute callbacks
245   * @param fn {function} Function to execute
246   * @deprecated
247   */
248  Promise._setImmediateFn = function _setImmediateFn(fn) {
249    Promise._immediateFn = fn;
250  };
251
252  /**
253   * Change the function to execute on unhandled rejection
254   * @param {function} fn Function to execute on unhandled rejection
255   * @deprecated
256   */
257  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
258    Promise._unhandledRejectionFn = fn;
259  };
260
261  if (typeof module !== 'undefined' && module.exports) {
262    module.exports = Promise;
263  } else if (!root.Promise) {
264    root.Promise = Promise;
265  }
266
267})(this);
268
269
270
271
272
273
274
275
276
277
278/*! @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js*/
279;
280if ("document" in self && !("classList" in document.createElement("_"))) {
281  (function (j) {
282    "use strict";
283    if (!("Element" in j)) {
284      return
285    }
286    var a = "classList",
287      f = "prototype",
288      m = j.Element[f],
289      b = Object,
290      k = String[f].trim || function () {
291        return this.replace(/^\s+|\s+$/g, "")
292      },
293      c = Array[f].indexOf || function (q) {
294        var p = 0,
295          o = this.length;
296        for (; p < o; p++) {
297          if (p in this && this[p] === q) {
298            return p
299          }
300        }
301        return -1
302      },
303      n = function (o, p) {
304        this.name = o;
305        this.code = DOMException[o];
306        this.message = p
307      },
308      g = function (p, o) {
309        if (o === "") {
310          throw new n("SYNTAX_ERR", "An invalid or illegal string was specified")
311        }
312        if (/\s/.test(o)) {
313          throw new n("INVALID_CHARACTER_ERR", "String contains an invalid character")
314        }
315        return c.call(p, o)
316      },
317      d = function (s) {
318        var r = k.call(s.getAttribute("class") || ""),
319          q = r ? r.split(/\s+/) : [],
320          p = 0,
321          o = q.length;
322        for (; p < o; p++) {
323          this.push(q[p])
324        }
325        this._updateClassName = function () {
326          s.setAttribute("class", this.toString())
327        }
328      },
329      e = d[f] = [],
330      i = function () {
331        return new d(this)
332      };
333    n[f] = Error[f];
334    e.item = function (o) {
335      return this[o] || null
336    };
337    e.contains = function (o) {
338      o += "";
339      return g(this, o) !== -1
340    };
341    e.add = function () {
342      var s = arguments,
343        r = 0,
344        p = s.length,
345        q, o = false;
346      do {
347        q = s[r] + "";
348        if (g(this, q) === -1) {
349          this.push(q);
350          o = true
351        }
352      } while (++r < p);
353      if (o) {
354        this._updateClassName()
355      }
356    };
357    e.remove = function () {
358      var t = arguments,
359        s = 0,
360        p = t.length,
361        r, o = false;
362      do {
363        r = t[s] + "";
364        var q = g(this, r);
365        if (q !== -1) {
366          this.splice(q, 1);
367          o = true
368        }
369      } while (++s < p);
370      if (o) {
371        this._updateClassName()
372      }
373    };
374    e.toggle = function (p, q) {
375      p += "";
376      var o = this.contains(p),
377        r = o ? q !== true && "remove" : q !== false && "add";
378      if (r) {
379        this[r](p)
380      }
381      return !o
382    };
383    e.toString = function () {
384      return this.join(" ")
385    };
386    if (b.defineProperty) {
387      var l = {
388        get: i,
389        enumerable: true,
390        configurable: true
391      };

392      try {
393        b.defineProperty(m, a, l)
394      } catch (h) {
395        if (h.number === -2146823252) {
396          l.enumerable = false;
397          b.defineProperty(m, a, l)
398        }
399      }
400    } else {
401      if (b[f].__defineGetter__) {
402        m.__defineGetter__(a, i)
403      }
404    }
405  }(self))
406};
407
408
409
410
411
412/**
413 * Input Placeholder Polyfill
414 * MIT Licensed
415 * Created by Christopher Rolfe
416 */
417if (!('placeholder' in document.createElement("input"))) {
418
419  // Get all the inputs
420  var inputs = document.getElementsByTagName('input');
421
422  // Loop over them
423  for (var i = 0; i < inputs.length; i++) {
424    // If they don't have a preset value
425    if (!inputs[i].value) {
426      // The set the placeholder
427      inputs[i].value = inputs[i].getAttribute('placeholder');
428    }
429
430    // Attach event listeners for click and blur
431    // Click so that we can clear the placeholder if we need to
432    // Blur to re-add it if needed
433    if (inputs[i].addEventListener) {
434      inputs[i].addEventListener('click', hidePlaceholderOnFocus, false);
435      inputs[i].addEventListener('blur', unfocusOnAnElement, false);
436    } else if (inputs[i].attachEvent) {
437      inputs[i].attachEvent('onclick', hidePlaceholderOnFocus);
438      inputs[i].attachEvent('onblur', unfocusOnAnElement);
439    }
440  }
441
442  /**
443   * When the input value is the same as the placeholder clear it
444   */
445  function hidePlaceholderOnFocus(event) {
446    target = (event.currentTarget) ? event.currentTarget : event.srcElement;
447
448    if (target.value == target.getAttribute('placeholder')) {
449      target.value = '';
450    }
451  }
452
453  /**
454   * When the input has an empty value put the placeholder back in
455   */
456  function unfocusOnAnElement(event) {
457    target = (event.currentTarget) ? event.currentTarget : event.srcElement;
458
459    if (target.value == '') {
460      target.value = target.getAttribute('placeholder');
461    }
462  }
463}
464
465(function polyfillRequestFullscreen() {
466  if (!Element.prototype.requestFullscreen) {
467    if (Element.prototype.webkitRequestFullscreen) {
468      Element.prototype.requestFullscreen = Element.prototype.webkitRequestFullScreen;
469    } else if (Element.prototype.mozRequestFullScreen) {
470      Element.prototype.requestFullscreen = Element.prototype.mozRequestFullScreen;
471    }
472  }
473})();
474
475(function polyfillExitFullscreen() {
476  if (!Document.prototype.exitFullscreen) {
477    if (Document.prototype.webkitExitFullscreen) {
478      Document.prototype.exitFullscreen = Document.prototype.webkitExitFullscreen;
479    } else if (Document.prototype.mozExitFullScreen) {
480      Document.prototype.exitFullscreen = Document.prototype.mozExitFullScreen;
481    }
482  }
483})();
484
485(function polyfillClosest() {
486  if (!Element.prototype.matches)
487    Element.prototype.matches = Element.prototype.msMatchesSelector ||
488    Element.prototype.webkitMatchesSelector;
489
490  if (!Element.prototype.closest) {
491    Element.prototype.closest = function (s) {
492      var el = this;
493      if (!document.documentElement.contains(el)) return null;
494      do {
495        if (el.matches(s)) return el;
496        el = el.parentElement || el.parentNode;
497      } while (el !== null && el.nodeType === 1);
498      return null;
499    };
500  }
501})();
502var Templates;
503(function (Templates) {
504    var TemplateApplication = (function () {
505        function TemplateApplication() {
506            var _this = this;
507            this.timeout = 0;
508            this.delay = 250;
509            this.translations = {};
510            this.onWindowResize = function () {
511                var stateChanged = false;
512                var newWindowState = _this.getWindowState();
513                stateChanged = newWindowState != _this.lastWindowState;
514                if (stateChanged) {
515                    _this.bindTextSwaps(newWindowState);
516                    _this.bindAspectRatioElements(newWindowState);
517                    _this.bindToggleButtons(newWindowState, true);
518                    _this.lastWindowState = newWindowState;
519                }
520                _this.bindTables(newWindowState);
521            };
522            this.statusBars = [];

523            this.currentanchorElement = null;
524        }
525        TemplateApplication.prototype.init = function () {
526            var _this = this;
527            this.rootElement = document.querySelector('.ac-content-page');
528            if (this.rootElement == null) {
529                this.rootElement = document.querySelector('.ac-content-modal');
530            }
531            if (!this.rootElement) {
532                return;
533            }
534            this.lastWindowState = this.getWindowState();
535            if (window.StandardTemplateTranslations) {
536                var translations = window.StandardTemplateTranslations;
537                var map = {};
538                for (var i = 0, length_1 = translations.length; i < length_1; i++) {
539                    var translation = translations[i];
540                    map[translation.key] = translation.value;
541                }
542                this.translations = map;
543            }
544            this.bindTextSwaps(this.lastWindowState);
545            this.bindToggleButtons(this.lastWindowState, false);
546            this.bindContentListItemEvents();
547            this.bindContentDetailListItemEvents();
548            this.bindAspectRatioElements(this.lastWindowState);
549            this.bindStatusBars();
550            this.bindCalendars();
551            this.bindDisabledLinks();
552            this.bindMaps();
553            this.bindValidators();
554            this.bindFormControlEvents();
555            this.bindTables(this.lastWindowState);
556            this.bindImageGalleries(this.lastWindowState);
557            this.bindImageSliders(this.lastWindowState);
558            this.bindLightboxImages();
559            this.bindLoadingTriggers();
560            this.bindClickableItems();
561            this.bindTooltips();
562            window.addEventListener('keyup', function (event) {
563                var key = event.key;
564                if (key === 'Escape') {
565                    if (_this.currentTooltip) {
566                        _this.closeTooltip(_this.currentTooltip);
567                    }
568                }
569            });
570            window.addEventListener('resize', function () {
571                clearTimeout(_this.timeout);
572                _this.timeout = setTimeout(_this.onWindowResize, _this.delay);
573            });
574            window.addEventListener('click', function (event) {
575                if (_this.currentTooltip && !_this.currentTooltip.contains(event.target)) {
576                    _this.closeTooltip(_this.currentTooltip);
577                }
578            });
579        };
580        TemplateApplication.prototype.IsInLinkElement = function (element) {
581            var returnValue = false;
582            var cParent = element;
583            while (cParent != null) {
584                if (cParent.tagName == 'A') {
585                    returnValue = true;
586                    break;
587                }
588                cParent = cParent.parentElement;
589            }
590            return returnValue;
591        };
592        TemplateApplication.prototype.getStatusBar = function (clientId) {
593            for (var i = 0, length_2 = this.statusBars.length; i < length_2; i++) {
594                var statusBarComponent = this.statusBars[i];
595                if (statusBarComponent.clientId == clientId) {
596                    return statusBarComponent;
597                }
598            }
599            return null;
600        };
601        TemplateApplication.prototype.bindStatusBars = function () {
602            var statusBarElements = this.rootElement.querySelectorAll('.js-statusbar');
603            for (var i = 0, length_3 = statusBarElements.length; i < length_3; i++) {
604                var statusBarOptions = new Templates.Components.StatusBarOptions();
605                var statusBarElement = statusBarElements[i];
606                statusBarOptions.element = statusBarElement;
607                statusBarOptions.completedclassName = statusBarElement.getAttribute("data-completed-class-name");
608                var statusBarComponent = new Templates.Components.StatusBarComponent(statusBarOptions);
609                statusBarComponent.init();
610                this.statusBars.push(statusBarComponent);
611            }
612        };
613        TemplateApplication.prototype.bindImageGalleries = function (state) {
614            var imageGalleryElements = this.rootElement.querySelectorAll('.js-image-gallery');
615            for (var i = 0, length_4 = imageGalleryElements.length; i < length_4; i++) {
616                var imageGalleryElement = imageGalleryElements[i];
617            }
618        };
619        TemplateApplication.prototype.bindLightboxImages = function () {
620            if (!('lightboxApp' in window)) {
621                var appOptions = new Templates.Components.LightboxApplicationOptions();
622                var app = new Templates.Components.LightboxApplication(appOptions);
623                app.init();
624            }
625        };
626        TemplateApplication.prototype.bindImageSliders = function (state) {
627            var imageSliderElements = this.rootElement.querySelectorAll('.js-image-slider');
628            for (var i = 0, length_5 = imageSliderElements.length; i < length_5; i++) {
629                var imageSliderElement = imageSliderElements[i];
630                var itemsElement = imageSliderElement.querySelector('.ac-image-slider-items');
631                var navElement = imageSliderElement.querySelector('.ac-image-slider-nav');
632                var options = {
633                    slidesToShow: 1,
634                    slidesToScroll: 1,
635                    infinite: false,
636                    centerMode: true,
637                    arrows: true,
638                    fade: true,
639                };
640                if (navElement) {
641                    options.asNavFor = '#' + navElement.id;
642                }
643                $(itemsElement).slick(options);
644                if (navElement) {
645                    $(navElement).slick({
646                        slidesToShow: 3,
647                        slidesToScroll: 1,
648                        asNavFor: '#' + itemsElement.id,
649                        centerMode: true,
650                        infinite: false,
651                        focusOnSelect: true,
652                        variableWidth: true,
653                        dots: false,

654                        arrows: false
655                    });
656                }
657                var anchors = navElement.querySelectorAll('a');
658                for (var j = 0, length_6 = anchors.length; j < length_6; j++) {
659                    var anchor = anchors[j];
660                    anchor.addEventListener('click', function (e) {
661                        e.preventDefault();
662                    });
663                }
664            }
665        };
666        TemplateApplication.prototype.bindTables = function (state) {
667            var tableWrapperElements = this.rootElement.querySelectorAll('.ac-content-table-wrapper');
668            var _loop_1 = function (i, length_7) {
669                var tableContentBlock = tableWrapperElements[i];
670                var upperScrollbarElement = tableContentBlock.parentElement.querySelector('.ac-content-table-upper-scrollbar');
671                var table = tableContentBlock.querySelector('table');
672                if (table.classList.contains('ac-content-table--normal') ||
673                    (state === 'mobile' && table.classList.contains('ac-content-table--mobile-normal')) ||
674                    (state === 'tablet' && table.classList.contains('ac-content-table--tablet-normal')) ||
675                    (state === 'desktop' && table.classList.contains('ac-content-table--desktop-normal'))) {
676                    if (tableContentBlock.scrollWidth > tableContentBlock.clientWidth) {
677                        if (!upperScrollbarElement) {
678                            upperScrollbarElement = document.createElement('div');
679                            upperScrollbarElement.className = 'ac-content-table-upper-scrollbar';
680                            tableContentBlock.parentElement.insertBefore(upperScrollbarElement, tableContentBlock);
681                            var upperScrollbarElementContent = document.createElement('div');
682                            upperScrollbarElementContent.className = 'ac-content-table-upper-scrollbar-content';
683                            upperScrollbarElementContent.style.width = table.clientWidth + 'px';
684                            upperScrollbarElement.appendChild(upperScrollbarElementContent);
685                        }
686                        upperScrollbarElement.scrollLeft = tableContentBlock.scrollLeft;
687                        upperScrollbarElement.addEventListener('scroll', function () {
688                            tableContentBlock.scrollLeft = upperScrollbarElement.scrollLeft;
689                        });
690                        tableContentBlock.addEventListener('scroll', function () {
691                            upperScrollbarElement.scrollLeft = tableContentBlock.scrollLeft;
692                        });
693                    }
694                    else {
695                        if (upperScrollbarElement) {
696                            upperScrollbarElement.parentElement.removeChild(upper

696ScrollbarElement);
697                        }
698                    }
699                }
700                else {
701                    if (upperScrollbarElement) {
702                        upperScrollbarElement.parentElement.removeChild(upperScrollbarElement);
703                    }
704                }
705            };
706            for (var i = 0, length_7 = tableWrapperElements.length; i < length_7; i++) {
707                _loop_1(i, length_7);
708            }
709        };
710        TemplateApplication.prototype.translate = function (key) {
711            return this.translations[key];
712        };
713        TemplateApplication.prototype.getWindowState = function () {
714            return window.getComputedStyle(this.rootElement, ':after').getPropertyValue('content').replace(/"/g, '');
715        };
716        TemplateApplication.prototype.bindToggleButtons = function (windowState, rebind) {
717            var buttons = this.rootElement.querySelectorAll('.js-toggle-button');
718            var _loop_2 = function (i, length_8) {
719                var button = buttons[i];
720                if (button.hasAttribute('data-toggle')) {
721                    var defaultToggle = button.getAttribute('data-toggle') === 'true';
722                    button.removeAttribute('aria-expanded');
723                    var overridden = false;
724                    if (windowState === 'mobile') {
725                        if (button.hasAttribute('data-mobile-toggle')) {
726                            var mobileToggle = button.getAttribute('data-mobile-toggle') === 'true';
727                            if (mobileToggle && !defaultToggle) {
728                                button.setAttribute('aria-expanded', 'true');
729                                overridden = true;
730                            }
731                        }
732                    }
733                    else if (windowState === 'tablet') {
734                        if (button.hasAttribute('data-tablet-toggle')) {
735                            var tabletToggle = button.getAttribute('data-tablet-toggle') === 'true';
736                            if (tabletToggle && !defaultToggle) {
737                                button.setAttribute('aria-expanded', 'true');
738                                overridden = true;
739                            }
740                        }
741                    }
742                    else {
743                        if (button.hasAttribute('data-desktop-toggle')) {
744                            var desktopToggle = button.getAttribute('data-desktop-toggle') === 'true';
745                            if (desktopToggle && !defaultToggle) {
746                                button.setAttribute('aria-expanded', 'true');
747                                overridden = true;
748                            }
749                        }
750                    }
751                    if (!overridden && defaultToggle) {
752                        button.setAttribute('aria-expanded', 'true');
753                        if (button.hasAttribute('aria-controls')) {
754                            var togglePanelClientID = button.getAttribute('aria-controls');
755                            var togglePanel = document.getElementById(togglePanelClientID);
756                            if (togglePanel) {
757                                togglePanel.classList.add('js-toggle-panel--show');
758                            }
759                        }
760                    }
761                }
762                if (!rebind) {
763                    if (button.hasAttribute('aria-controls')) {
764                        var togglePanelClientID = button.getAttribute('aria-controls');
765                        var togglePanel = document.getElementById(togglePanelClientID);
766                        if (togglePanel) {
767                            togglePanel.classList.add('js-toggle-panel');
768                        }
769                    }
770                    button.addEventListener('click', function (event) {
771                        event.preventDefault();
772                        var text = button.getAttribute('data-text');
773                        var toggleText = button.getAttribute('data-toggle-text');
774                        var isExpanded = button.getAttribute('aria-expanded') === 'true';
775                        var textElement = button.querySelector('.js-toggle-button-text');
776                        var togglePanel = null;
777                        if (button.hasAttribute('aria-controls')) {
778                            var togglePanelClientID = button.getAttribute('aria-controls');
779                            togglePanel = document.getElementById(togglePanelClientID);
780                        }
781                        if (isExpanded) {
782                            button.setAttribute('aria-expanded', 'false');
783                            if (text) {
784                                textElement.innerHTML = '';
785                                var a = document.createTextNode(text);
786                                textElement.appendChild(a);
787                            }
788                            if (togglePanel) {
789                                togglePanel.classList.remove('js-toggle-panel--show');
790                            }
791                        }
792                        else {
793                            button.setAttribute('aria-expanded', 'true');
794                            if (toggleText) {
795                                textElement.innerHTML = '';
796                                var a = document.createTextNode(toggleText);
797                                textElement.appendChild(a);
798                            }
799                            if (togglePanel) {
800                                togglePanel.classList.add('js-toggle-panel--show');
801                            }
802                        }
803                    });
804                }
805            };
806            for (var i = 0, length_8 = buttons.length; i < length_8; i++) {
807                _loop_2(i, length_8);
808            }
809        };
810        TemplateApplication.prototype.bindContentListItemEvents = function () {
811            var itemElements = this.rootElement.querySelectorAll('.ac-content-list-item');
812            var _loop_3 = function (i, length_9) {
813                var itemElement = itemElements[i];
814                itemElement.addEventListener('mouseenter', function (event) {
815                    itemElement.classList.add('ac-content-list-item--highlight');
816                });
817                itemElement.addEventListener('focusin', function (event) {
818                    itemElement.classList.add('ac-content-list-item--focus');
819                });
820                itemElement.addEventListener('mouseleave', function (event) {
821                    itemElement.classList.remove('ac-content-list-item--highlight');
822                });
823                itemElement.addEventListener('focusout', function (event) {
824                    itemElement.classList.remove('ac-content-list-item--focus');
825                });
826            };
827            for (var i = 0, length_9 = itemElements.length; i < length_9; i++) {
828                _loop_3(i, length_9);
829            }
830        };
831        TemplateApplication.prototype.bindContentDetailListItemEvents = function () {
832            var _this = this;
833            var itemElements = this.rootElement.querySelectorAll('.ac-content-detail-list-item');
834            var _loop_4 = function () {
835                var item = itemElements[i];
836                var trigger = item.querySelector('.ac-content-detail-list-item-header-column-trigger');
837                var body = item.querySelector('.ac-content-detail-list-item-body');
838                var itemHeader = item.querySelector('.ac-content-detail-list-item-header');
839                itemHeader.addEventListener('click', function (e) {
840                    trigger.click();
841                });
842                trigger.addEventListener('click', function (e) {
843                    e.stopPropagation();
844                    var isOpen = trigger.getAttribute('aria-expanded') === 'true';
845                    if (!isOpen) {
846                        var openedTrigger = _this.rootElement.querySelector('.ac-content-detail-list-item-header-column-trigger[aria-expanded="true"]');
847                        var openItem = _this.rootElement.querySelector('.ac-content-detail-list-item--open');
848                        var openBody = _this.rootElement.querySelector('.ac-content-detail-list-item-body--open');
849                        if (openedTrigger != null) {
850                            openedTrigger.setAttribute('aria-expanded', 'false');
851                        }
852                        if (openItem != null) {
853                            openItem.classList.toggle('ac-content-detail-list-item--open');
854                        }
855                        if (openBody != null) {
856                            openBody.classList.toggle('ac-content-detail-list-item-body--open');
857                        }
858                        if (window.eventBus) {
859                            window.eventBus.dispatch('show-container', body);
860                        }
861                    }
862                    trigger.setAttribute('aria-expanded', (isOpen) ? 'false' : 'true');
863                    item.classList.toggle('ac-content-detail-list-item--open');
864                    body.classList.toggle('ac-content-detail-list-item-body--open');
865                });
866            };
867            for (var i = 0; i < itemElements.length; i++) {
868                _loop_4();
869            }
870        };
871        TemplateApplication.prototype.bindFormControlEvents = function () {
872            var itemElements = this.rootElement.querySelectorAll('.ac-content-form-control');
873            var _loop_5 = function (i, length_10) {
874                var itemElement = itemElements[i];
875                itemElement.addEventListener('mouseenter', function (event) {
876                    itemElement.classList.add('ac-content-form-control--hover');
877                });
878                itemElement.addEventListener('focusin', function (event) {
879                    itemElement.classList.add('ac-content-form-control--focus');
880                });
881                itemElement.addEventListener('mouseleave', function (event) {
882                    itemElement.classList.remove('ac-content-form-control--hover');
883                });
884                itemElement.addEventListener('focusout', function (event) {
885                    itemElement.classList.remove('ac-content-form-control--focus');
886                });
887            };
888            for (var i = 0, length_10 = itemElements.length; i < length_10; i++) {
889                _loop_5(i, length_10);
890            }
891        };
892        TemplateApplication.prototype.bindTextSwaps = function (state) {
893            var elements = this.rootElement.querySelectorAll('.js-text-swap');
894            for (var i = 0, length_11 = elements.length; i < length_11; i++) {
895                var element = elements[i];
896                var fallbackText = element.getAttribute('data-text');
897                var textElement = element.querySelector('.js-text-swap-text');
898                if (textElement && fallbackText) {
899                    var mobileText = element.getAttribute('data-mobile-text');
900                    var tabletText = element.getAttribute('data-tablet-text');
901                    var desktopText = element.getAttribute('data-desktop-text');
902                    var targetText = fallbackText;
903                    if (state == 'mobile') {
904                        if (mobileText) {
905                            targetText = mobileText;
906                        }
907                    }
908                    else if (state == 'tablet') {
909                        if (tabletText) {
910                            targetText = tabletText;
911                        }
912                    }
913                    else if (state == 'desktop') {
914                        if (desktopText) {
915                            targetText = desktopText;
916                        }
917                    }
918                    textElement.innerHTML = '';
919                    var a = document.createTextNode(targetText);
920                    textElement.appendChild(a);
921                }
922            }
923        };
924        TemplateApplication.prototype.bindAspectRatioElements = function (state) {
925            var elements = this.rootElement.querySelectorAll('.js-aspect-ratio');
926            for (var i = 0, length_12 = elements.length; i < length_12; i++) {
927                var element = elements[i];
928                var fallbackAspectRatio = element.getAttribute('data-aspect-ratio');
929                if (fallbackAspectRatio) {
930                    var mobileAspectRatio = element.getAttribute('data-mobile-aspect-ratio');
931                    var tabletAspectRatio = element.getAttribute('data-tablet-aspect-ratio');
932                    var desktopAspectRatio = element.getAttribute('data-desktop-aspect-ratio');
933                    var targetAspectRatio = fallbackAspectRatio;
934                    if (state == 'mobile') {
935                        if (mobileAspectRatio) {
936                            targetAspectRatio = mobileAspectRatio;
937                        }
938                    }
939                    else if (state == 'tablet') {
940                        if (tabletAspectRatio) {
941                            targetAspectRatio = tabletAspectRatio;
942                        }
943                    }
944                    else if (state == 'desktop') {
945                        if (desktopAspectRatio) {
946                            targetAspectRatio = desktopAspectRatio;
947                        }
948                    }
949                    element.style.paddingBottom = targetAspectRatio + '%';
950                }
951            }
952        };
953        TemplateApplication.prototype.bindCalendars = function () {
954            var elements = this.rootElement.querySelectorAll('.js-calendar');
955            var _loop_6 = function (i, length_13) {
956                var element = elements[i];
957                var calendar = new Templates.Components.CalendarComponent();
958                var options = new Templates.Components.CalendarOptions();
959                options.element = element;
960                if (element.hasAttribute('data-selected-date')) {
961                    options.selectedDate = new Date(element.getAttribute('data-selected-date'));
962                    element.removeAttribute('data-selected-date');
963                }
964                if (element.hasAttribute('data-show-selected-date-panel')) {
965                    options.showSelectedDatePanel = element.getAttribute('data-show-selected-date-panel') === 'true';
966                    element.removeAttribute('data-show-selected-date-panel');
967                }
968                if (element.hasAttribute('data-on-selected-date-changed-callback-name')) {
969                    options.onSelectedDateChangedCallbackName = element.getAttribute('data-on-selected-date-changed-callback-name');
970                    element.removeAttribute('data-on-selected-date-changed-callback-name');
971                }
972                if (element.hasAttribute('data-on-before-initilize-callback-name')) {
973                    options.onBeforeInitilizeCallbackName = element.getAttribute('data-on-before-initilize-callback-name');
974                    element.removeAttribute('data-on-before-initilize-callback-name');
975                }
976                if (element.hasAttribute('data-on-building-date-buttonelement-callback-name')) {
977                    options.onBuildingDateButtonElement = element.getAttribute('data-on-building-date-buttonelement-callback-name');
978                    element.removeAttribute('data-on-building-date-buttonelement-callback-name');
979                }
980                if (element.hasAttribute('data-on-before-initilize-callback-name')) {
981                    options.onSelectedDateChangedCallbackName = element.getAttribute('data-on-before-initilize-callback-name');
982                    element.removeAttribute('data-on-before-initilize-callback-name');
983                }
984                if (element.hasAttribute('data-on-previous-month-callback-name')) {
985                    options.onPreviousMonthCallback = element.get

985Attribute('data-on-previous-month-callback-name');
986                    element.removeAttribute('data-on-previous-month-callback-name');
987                }
988                if (element.hasAttribute('data-on-next-month-callback-name')) {
989                    options.onNextMonthCallback = element.getAttribute('data-on-next-month-callback-name');
990                    element.removeAttribute('data-on-next-month-callback-name');
991                }
992                if (element.hasAttribute('data-minimum-date')) {
993                    options.minimumDate = new Date(element.getAttribute('data-minimum-date'));
994                    element.removeAttribute('data-minimum-date');
995                }
996                if (element.hasAttribute('data-maximum-date')) {
997                    options.maximumDate = new Date(element.getAttribute('data-maximum-date'));
998                    element.removeAttribute('data-maximum-date');
999                }
1000                promiseBeforeInit = window[options.onBeforeInitilizeCallbackName];
1001                if (promiseBeforeInit == null) {
1002                    calendar.init(options);
1003                }
1004                else {
1005                    calendar.activateLoadingCalender(options.element);
1006                    promiseBeforeInit.then(function () {
1007                        calendar.deactivateLoadingCalender(options.element);
1008                        calendar.init(options);
1009                    });
1010                }
1011                if (element.hasAttribute('data-get-instance-callback-name')) {
1012                    var callback = window[element.getAttribute('data-get-instance-callback-name')];
1013                    callback(calendar);
1014                }
1015            };
1016            var promiseBeforeInit;
1017            for (var i = 0, length_13 = elements.length; i < length_13; i++) {
1018                _loop_6(i, length_13);
1019            }
1020        };
1021        TemplateApplication.prototype.bindDisabledLinks = function () {
1022            var elements = this.rootElement.querySelectorAll('a[aria-disabled="true"]');
1023            for (var i = 0, length_14 = elements.length; i < length_14; i++) {
1024                var element = elements[i];
1025                element.addEventListener('click', function (e) {
1026                    event.preventDefault();
1027                });
1028            }
1029        };
1030        TemplateApplication.prototype.bindMaps = function () {
1031            var elements = this.rootElement.querySelectorAll('.ac-map');
1032            window.mapComponents = [];
1033            for (var i = 0, length_15 = elements.length; i < length_15; i++) {
1034                var element = elements[i];
1035                var options = null;
1036                var provider = Templates.Components.MapProvider.Google;
1037                if (element.hasAttribute('data-provider')) {
1038                    provider = parseInt(element.getAttribute('data-provider'));
1039                    element.removeAttribute('data-provider');
1040                }
1041                if (provider === Templates.Components.MapProvider.NorkartWebatlas) {
1042                    options = new Templates.Components.NorkartWebatlasMapOptions();
1043                }
1044                else {
1045                    options = new Templates.Components.GoogleMapsMapOptions();
1046                }
1047                options.element = element;
1048                if (element.hasAttribute('data-items-variable-name')) {
1049                    var variableName = element.getAttribute('data-items-variable-name');
1050                    var jsonData = window[variableName];
1051                    options.items = JSON.parse(jsonData);
1052                    element.removeAttribute('data-items-variable-name');
1053                }
1054                if (element.hasAttribute('data-geojson-variable-name')) {
1055                    var variableName = element.getAttribute('data-geojson-variable-name');
1056                    var jsonData = window[variableName];
1057                    options.geoJSON = JSON.parse(jsonData);
1058                    element.removeAttribute('data-geojson-variable-name');
1059                }
1060                if (element.hasAttribute('data-initial-latitude')) {
1061                    options.initialLatitude = parseFloat(element.getAttribute('data-initial-latitude'));
1062                    element.removeAttribute('data-initial-latitude');
1063                }
1064                if (element.hasAttribute('data-initial-longitude')) {
1065                    options.initialLongitude = parseFloat(element.getAttribute('data-initial-longitude'));
1066                    element.removeAttribute('data-initial-longitude');
1067                }
1068                if (element.hasAttribute('data-initial-zoom-level')) {
1069                    options.initialZoomLevel = parseInt(element.getAttribute('data-initial-zoom-level'));

1070                    element.removeAttribute('data-initial-zoom-level');
1071                }
1072                if (element.hasAttribute('data-google-maps-api-key')) {
1073                    options.googleMapsApiKey = element.getAttribute('data-google-maps-api-key');
1074                    element.removeAttribute('data-google-maps-api-key');
1075                }
1076                var mapComponent = null;
1077                if (provider === Templates.Components.MapProvider.NorkartWebatlas) {
1078                    mapComponent = new Templates.Components.NorkartWebatlasMapComponent(options);
1079                }
1080                else {
1081                    mapComponent = new Templates.Components.GoogleMapsMapComponent(options);
1082                }
1083                window.mapComponents.push(mapComponent);
1084                mapComponent.init();
1085            }
1086        };
1087        TemplateApplication.prototype.bindValidators = function () {
1088            var _this = this;
1089            var validationButtons = this.rootElement.querySelectorAll('button[data-validation-group]');
1090            var _loop_7 = function (i, length_16) {
1091                var validationButton = validationButtons[i];
1092                validationButton.addEventListener('click', function (e) {
1093                    var validationGroup = validationButton.getAttribute('data-validation-group');
1094                    var query = '[data-validation-group="' + validationGroup + '"]';
1095                    var validationControls = _this.rootElement.querySelectorAll(query);
1096                    var isValid = true;
1097                    for (var j = 0, length_17 = validationControls.length; j < length_17; j++) {
1098                        var validationControl = validationControls[j];
1099                        if (validationControl.hasAttribute('data-validation-is-required')) {
1100                            var isRequred = validationControl.getAttribute('data-validation-is-required') == 'true';
1101                            var isRequiredErrorMessage = validationControl.getAttribute('data-validation-is-required-error-message');
1102                            if (isRequred && !validationControl.value) {
1103                                var formControl = validationControl.closest('.ac-content-form-control');
1104                                if (formControl != null) {
1105                                    formControl.classList.add('ac-content-form-control--invalid');
1106                                    if (isRequiredErrorMessage) {
1107                                        var validationErrorMessageControl = formControl.parentElement.querySelector('.ac-content-form-control-error-message');
1108                                        if (!validationErrorMessageControl) {
1109                                            validationErrorMessageControl = document.createElement("div");
1110                                            formControl.parentElement.appendChild(validationErrorMessageControl);
1111                                        }
1112                                        validationErrorMessageControl.className = "ac-content-form-control-error-message";
1113                                        validationErrorMessageControl.setAttribute('role', 'alert');
1114                                        validationErrorMessageControl.setAttribute('aria-live', 'assertive');
1115                                        validationErrorMessageControl.textContent = isRequiredErrorMessage;
1116                                    }
1117                                }
1118                                isValid = false;
1119                            }
1120                        }
1121                    }
1122                    if (!isValid) {
1123                        e.preventDefault();
1124                    }
1125                });
1126            };
1127            for (var i = 0, length_16 = validationButtons.length; i < length_16; i++) {
1128                _loop_7(i, length_16);
1129            }
1130        };
1131        TemplateApplication.prototype.bindLoadingTriggers = function () {
1132            var elements = this.rootElement.querySelectorAll('.js-loading-item');
1133            var _loop_8 = function (i, length_18) {
1134                var element = elements[i];
1135                var triggerElement = element.querySelector('.js-loading-trigger');
1136                if (triggerElement) {
1137                    var hasTargetBlank = triggerElement.getAttribute('target') === '_blank';
1138                    if (!hasTargetBlank) {
1139                        triggerElement.addEventListener('click', function (e) {
1140                            element.classList.add('js-loading');
1141                        });
1142                    }
1143                }
1144            };
1145            for (var i = 0, length_18 = elements.length; i < length_18; i++) {
1146                _loop_8(i, length_18);
1147            }
1148        };
1149        TemplateApplication.prototype.bindClickableItems = function () {
1150            var _this = this;
1151            var elements = this.rootElement.querySelectorAll('.js-clickable-item');
1152            var _loop_9 = function (i, length_19) {
1153                var element = elements[i];
1154                var triggerElement = element.querySelector('.js-click-trigger');
1155                if (triggerElement) {
1156                    element.addEventListener('click', function (event) {
1157                        if (!_this.IsInLinkElement(event.target)) {
1158                            triggerElement.click();
1159                        }
1160                    });
1161                }
1162            };
1163            for (var i = 0, length_19 = elements.length; i < length_19; i++) {
1164                _loop_9(i, length_19);
1165            }
1166        };
1167        TemplateApplication.prototype.bindTooltips = function () {
1168            var _this = this;
1169            var elements = this.rootElement.querySelectorAll('.js-tooltip');
1170            var _loop_10 = function (i, length_20) {
1171                var element = elements[i];
1172                var triggerElement = element.querySelector('.ac-tooltip-trigger');
1173                if (triggerElement) {
1174                    triggerElement.addEventListener('click', function (event) {
1175                        var isOpen = triggerElement.getAttribute('aria-expanded') === 'true';
1176                        if (!isOpen) {
1177                            if (_this.currentTooltip) {
1178                                _this.closeTooltip(_this.currentTooltip);
1179                            }
1180                            _this.currentTooltip = element;
1181                        }
1182                        triggerElement.setAttribute('aria-expanded', (isOpen) ? 'false' : 'true');
1183                    });
1184                }
1185            };
1186            for (var i = 0, length_20 = elements.length; i < length_20; i++) {
1187                _loop_10(i, length_20);
1188            }
1189        };
1190        TemplateApplication.prototype.closeTooltip = function (element) {
1191            if (element) {
1192                var triggerElement = element.querySelector('.ac-tooltip-trigger');
1193                if (triggerElement) {
1194                    triggerElement.setAttribute('aria-expanded', 'false');
1195                }
1196                this.currentTooltip = null;
1197            }
1198        };
1199        return TemplateApplication;
1200    }());
1201    Templates.TemplateApplication = TemplateApplication;
1202})(Templates || (Templates = {}));
1203var StandardTemplateApplication;
1204(function () {
1205    document.addEventListener('DOMContentLoaded', function () {
1206        var app = new Templates.TemplateApplication();
1207        StandardTemplateApplication = app;
1208        app.init();
1209    });

1210})();
1211var Templates;
1212(function (Templates) {
1213    var Components;
1214    (function (Components) {
1215        'use strict';
1216        var days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
1217        var daysShort = ['MondayAbbreviated', 'TuesdayAbbreviated', 'WednesdayAbbreviated', 'ThursdayAbbreviated', 'FridayAbbreviated', 'SaturdayAbbreviated', 'SundayAbbreviated'];
1218        var months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
1219        var CalendarOptions = (function () {
1220            function CalendarOptions() {
1221                this.showSelectedDatePanel = false;
1222                this.onSelectedDateChangedCallbackName = null;
1223                this.onBeforeInitilizeCallbackName = null;
1224                this.onBuildingDateButtonElement = null;
1225                this.onPreviousMonthCallback = null;
1226                this.onNextMonthCallback = null;
1227            }
1228            return CalendarOptions;
1229        }());
1230        Components.CalendarOptions = CalendarOptions;
1231        var CalendarComponent = (function () {
1232            function CalendarComponent() {
1233                var _this = this;
1234                this.element = null;
1235                this.weekRowCount = 6;
1236                this.currentMonthOffset = 0;
1237                this.onSelectedDateChangedCallbackCompleted = function () {
1238                    _this.isLoadingData = false;
1239                    _this.openSelectedDatePanel();
1240                    var elements = _this.calendarTableBody.querySelectorAll('button.js-loading');
1241                    for (var i = 0, length_21 = elements.length; i < length_21; i++) {
1242                        var element = elements[i];
1243                        element.classList.remove('js-loading');
1244                    }
1245                };
1246                this.onSelectedDateChangedCallbackError = function () {
1247                    _this.isLoadingData = false;
1248                    _this.openSelectedDatePanel();
1249                    var elements = _this.calendarTableBody.querySelectorAll('button.js-loading');
1250                    for (var i = 0, length_22 = elements.length; i < length_22; i++) {
1251                        var element = elements[i];
1252                        element.classList.remove('js-loading');
1253                    }
1254                };
1255                this.onInitilizeCallbackError = function () {
1256                    alert("callback error");
1257                };
1258                this.activateLoadingCalender = function (element) {
1259                    if (element != null) {
1260                        element.insertAdjacentHTML("afterbegin", "<span class='server-loading__message'>"
1261                            + StandardTemplateApplication.translate("Components.Booking.Templates.WebControls.BookingCalendarControl.LoadingMessage") +
1262                            "</span>");
1263                        element.classList.add("server-loading");
1264                    }
1265                };
1266                this.deactivateLoadingCalender = function (element) {
1267                    if (element != null) {
1268                        element.classList.remove("server-loading");
1269                        var messageElement = element.querySelector('.server-loading__message');
1270                        if (messageElement) {
1271                            element.removeChild(messageElement);
1272                        }
1273                    }
1274                };
1275                this.activateLoadingMonth = function (element, isPreviousMonth) {
1276                    if (element != null) {
1277                        _this.closeSelectedDatePanel();
1278                        var startDate = new Date(_this.options.selectedDate.getFullYear(), _this.options.selectedDate.getMonth() + _this.currentMonthOffset + (isPreviousMonth ? -1 : 1));
1279                        var currentMonth = startDate.getMonth();
1280                        var monthTranslated = StandardTemplateApplication.translate(months[currentMonth]).toLocaleLowerCase();
1281                        element.insertAdjacentHTML("afterbegin", "<span class='server-loading__message'>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t  ".concat(StandardTemplateApplication.translate("C

1281omponents.Booking.Templates.WebControls.BookingCalendarControl.LoadingMonthMessage"), " ").concat(monthTranslated, ". \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t  </span>"));
1282                        element.classList.add("ac-calendar-loading-month-visible");
1283                        element.classList.add("server-loading");
1284                        element.classList.add("server-loading-secondary");
1285                        var table = document.getElementById('js-calendar-table');
1286                        table.setAttribute("style", "visibility: hidden");
1287                    }
1288                };
1289                this.deactivateLoadingMonth = function (element) {
1290                    if (element != null) {
1291                        element.classList.remove("ac-calendar-loading-month-visible");
1292                        element.classList.remove("server-loading");
1293                        element.classList.remove("server-loading-secondary");
1294                        var messageElement = element.querySelector('.server-loading__message');
1295                        if (messageElement) {
1296                            element.removeChild(messageElement);
1297                        }
1298                        var table = document.getElementById('js-calendar-table');
1299                        table.setAttribute("style", "");
1300                    }
1301                };
1302            }
1303            CalendarComponent.prototype.init = function (options) {
1304                if (options.element) {
1305                    this.element = options.element;
1306                }
1307                else if (this.options.elementClientID) {
1308                    this.element = document.getElementById(options.elementClientID);
1309                }
1310                this.options = options;
1311                if (!this.options.selectedDate) {
1312                    this.options.selectedDate = new Date();
1313                    this.selectedOnInitIsNull = true;
1314                }
1315                this.calendarHeader = this.buildCalendarHeader();
1316                this.element.appendChild(this.calendarHeader);
1317                this.calendarTable = this.buildCalendarTable();
1318                this.element.appendChild(this.calendarTable);
1319                var jsLoadingMonth = document.createElement('div');
1320                jsLoadingMonth.setAttribute("id", "js-loading-month");
1321                jsLoadingMonth.classList.add('ac-calendar-loading-month');
1322                this.element.appendChild(jsLoadingMonth);
1323                this.element.classList.add("ac-calendar-loaded");
1324            };
1325            CalendarComponent.prototype.rebind = function () {
1326                this.selectedDate = null;
1327                this.closeSelectedDatePanel();
1328                this.buildCalendarTableBodyRows();
1329            };
1330            CalendarComponent.prototype.buildCalendarHeader = function () {
1331                var _this = this;
1332                var calendarHeaderElement = document.createElement('div');
1333                calendarHeaderElement.classList.add('ac-calendar-header');
1334                var previousMonthButton = document.createElement('button');
1335                previousMonthButton.type = 'button';
1336                previousMonthButton.classList.add('ac-calendar-header-change-month-button');
1337                previousMonthButton.classList.add('ac-icon');
1338                previousMonthButton.classList.add('ac-icon--left');
1339                previousMonthButton.classList.add('ac-icon--angle-left');
1340                var previousMonthButtonSpan = document.createElement('span');
1341                previousMonthButtonSpan.innerText = StandardTemplateApplication.translate('Templates.Standard.WebControls.TemplateControls.Calendar.PreviousMonth');
1342                previousMonthButton.appendChild(previousMonthButtonSpan);
1343                previousMonthButton.addEventListener('click', function (e) {
1344                    e.preventDefault();
1345                    if (_this.isLoadingData) {
1346                        return;
1347                    }
1348                    var callback = window[_this.options.onPreviousMonthCallback];
1349                    _this.isLoadingData = true;
1350                    if (_this.enablePreviousMonthButton()) {
1351                        var startDate = new Date(_this.options.selectedDate.getFullYear(), _this.options.selectedDate.getMonth() + _this.currentMonthOffset - 1);
1352                        if (typeof callback === "function") {
1353                            _this.isLoadingData = true;
1354                            callback(startDate.getFullYear(), startDate.getMonth(), function () {
1355                                nextMonthButton.disabled = false;
1356                                _this.isLoadingData = false;
1357                                _this.changeMonth(-1);
1358                                if (!_this.enablePreviousMonthButton()) {
1359                                    previousMonthButton.disabled = true;
1360                                }
1361                            });
1362                        }
1363                        else {
1364                            _this.changeMonth(-1);
1365                            if (!_this.enablePreviousMonthButton()) {
1366                                previousMonthButton.disabled = true;
1367                            }
1368                            nextMonthButton.disabled = false;
1369                        }
1370                    }
1371                    _this.isLoadingData = false;
1372                });
1373                if (!this.enablePreviousMonthButton()) {
1374                    previousMonthButton.disabled = true;
1375                }
1376                calendarHeaderElement.appendChild(previousMonthButton);
1377                var calendarHeaderTitleElement = document.createElement('div');
1378                calendarHeaderTitleElement.classList.add('ac-calendar-header-title');
1379                calendarHeaderElement.appendChild(calendarHeaderTitleElement);
1380                this.calendarHeaderTitle = calendarHeaderTitleElement;
1381                var nextMonthButton = document.createElement('button');

1382                previousMonthButton.type = 'button';
1383                nextMonthButton.classList.add('ac-calendar-header-change-month-button');
1384                nextMonthButton.classList.add('ac-icon');
1385                nextMonthButton.classList.add('ac-icon--right');
1386                nextMonthButton.classList.add('ac-icon--angle-right');
1387                var nextMonthButtonSpan = document.createElement('span');
1388                nextMonthButtonSpan.innerText = StandardTemplateApplication.translate('Templates.Standard.WebControls.TemplateControls.Calendar.NextMonth');
1389                nextMonthButton.appendChild(nextMonthButtonSpan);
1390                nextMonthButton.addEventListener('click', function (e) {
1391                    e.preventDefault();
1392                    if (_this.isLoadingData) {
1393                        return;
1394                    }
1395                    var callback = window[_this.options.onNextMonthCallback];
1396                    if (_this.enableNextMonthButton()) {
1397                        var startDate = new Date(_this.options.selectedDate.getFullYear(), _this.options.selectedDate.getMonth() + _this.currentMonthOffset + 1);
1398                        if (typeof callback === "function") {
1399                            _this.isLoadingData = true;
1400                            callback(startDate.getFullYear(), startDate.getMonth(), function () {
1401                                previousMonthButton.disabled = false;
1402                                _this.isLoadingData = false;
1403                                _this.changeMonth(1);
1404                                if (!_this.enableNextMonthButton()) {
1405                                    nextMonthButton.disabled = true;
1406                                }
1407                            });
1408                        }
1409                        else {
1410                            _this.changeMonth(1);
1411                            if (!_this.enableNextMonthButton()) {
1412                                nextMonthButton.disabled = true;
1413                            }
1414                            previousMonthButton.disabled = false;
1415                            _this.isLoadingData = false;
1416                        }
1417                    }
1418                });
1419                if (!this.enableNextMonthButton()) {
1420                    nextMonthButton.disabled = true;
1421                }
1422                calendarHeaderElement.appendChild(nextMonthButton);
1423                return calendarHeaderElement;
1424            };
1425            CalendarComponent.prototype.enablePreviousMonthButton = function () {
1426                var lastDayOfPreviousMonth = new Date(this.options.selectedDate.getFullYear(), this.options.selectedDate.getMonth() + (this.currentMonthOffset));
1427                lastDayOfPreviousMonth.setHours(-24);
1428                return !this.options.minimumDate || this.options.minimumDate < lastDayOfPreviousMonth;
1429            };
1430            CalendarComponent.prototype.enableNextMonthButton = function () {
1431                var firstDayOfNextMonth = new Date(this.options.selectedDate.getFullYear(), this.options.selectedDate.getMonth() + (this.currentMonthOffset + 1));
1432                return !this.options.maximumDate || this.options.maximumDate > firstDayOfNextMonth;
1433            };
1434            CalendarComponent.prototype.setCalendarHeaderTitle = function (text) {
1435                this.calendarHeaderTitle.textContent = text;
1436            };
1437            CalendarComponent.prototype.buildCalendarTable = function () {
1438                var tableElement = document.createElement('table');
1439                tableElement.setAttribute("id", 'js-calendar-table');
1440                tableElement.classList.add('ac-calendar-table');
1441                this.calendarTableHead = this.buildCalendarTableHead();
1442                tableElement.appendChild(this.calendarTableHead);
1443                this.calendarTableBody = this.buildCalendarTableBody();
1444                tableElement.appendChild(this.calendarTableBody);
1445                this.calendarSelectedDatePanel = this.buildSelectedDatePanel();
1446                this.calendarTableBody.appendChild(this.calendarSelectedDatePanel);
1447                this.buildCalendarTableBodyRows();
1448                return tableElement;
1449            };
1450            CalendarComponent.prototype.buildCalendarTableHead = function () {
1451                var theadElement = document.createElement('thead');
1452                theadElement.setAttribute("id", 'js-calendar-table-head');
1453                theadElement.classList.add('ac-calendar-table-head');
1454                var trElement = document.createElement('tr');
1455                trElement.classList.add('ac-calendar-table-row');
1456                theadElement.appendChild(trElement);
1457                for (var _i = 0, daysShort_1 = daysShort; _i < daysShort_1.length; _i++) {
1458                    var day = daysShort_1[_i];
1459                    var thElement = document.createElement('th');
1460                    thElement.classList.add('ac-calendar-table-cell');
1461                    thElement.setAttribute('scope', 'col');
1462                    thElement.innerText = StandardTemplateApplication.translate(day);
1463                    trElement.appendChild(thElement);
1464                }
1465                return theadElement;
1466            };
1467            CalendarComponent.prototype.buildCalendarTableBody = function () {
1468                var tbodyElement = document.createElement('tbody');
1469                tbodyElement.classList.add('ac-calendar-table-body');
1470                return tbodyElement;
1471            };
1472            CalendarComponent.prototype.buildCalendarTableBodyRows = function () {
1473                var _this = this;
1474                var startDate = new Date(this.options.selectedDate.getFullYear(), this.options.selectedDate.getMonth() + this.currentMonthOffset);
1475                this.currentMonth = startDate.getMonth();
1476                var currentYear = startDate.getFullYear();
1477                var startDateInt = startDate.getDate() - startDate.getDay() - 6;
1478                if (startDate.getDay() != 0) {
1479                    startDateInt += 7;
1480                }
1481                startDate.setDate(startDateInt);
1482                var queuedDate = startDate;
1483                this.setCalendarHeaderTitle(StandardTemplateApplication.translate(months[this.currentMonth]) + ' ' + currentYear);
1484                this.clearCalendarTableBodyRows();
1485                var _loop_11 = function (w) {
1486                    var trElement = document.createElement('tr');
1487                    trElement.classList.add('ac-calendar-table-row');
1488                    this_1.calendarTableBody.appendChild(trElement);
1489                    var _loop_12 = function (d) {
1490                        var tdElement = document.createElement('td');
1491                        tdElement.classList.add('ac-calendar-table-cell');
1492                        trElement.appendChild(tdElement);
1493                        var year = queuedDate.getFullYear();

1494                        var month = queuedDate.getMonth();
1495                        var day = queuedDate.getDate();
1496                        var buttonElement = document.createElement('button');
1497                        buttonElement.type = 'button';
1498                        buttonElement.classList.add('calendar-day-button');
1499                        buttonElement.setAttribute('data-date', year + '-' + month + '-' + day);
1500                        buttonElement.setAttribute('aria-label', StandardTemplateApplication.translate(days[d]) + ' ' + day + ' ' + StandardTemplateApplication.translate(months[month]) + ' ' + year);
1501                        buttonElement.setAttribute('aria-expanded', 'false');
1502                        buttonElement.setAttribute('aria-controls', this_1.calendarSelectedDatePanel.id);
1503                        buttonElement.tabIndex = -1;
1504                        if (month == this_1.currentMonth && (this_1.options.minimumDate && queuedDate.getDate() == this_1.options.minimumDate.getDate())) {
1505                            buttonElement.tabIndex = 0;
1506                        }
1507                        if (!this_1.selectedOnInitIsNull && this_1.areEqual(queuedDate, this_1.options.selectedDate)) {
1508                            buttonElement.setAttribute('aria-selected', 'true');
1509                            buttonElement.tabIndex = 0;
1510                        }
1511                        if (queuedDate.getMonth() != this_1.currentMonth) {
1512                            buttonElement.classList.add('ac-visually-hidden');
1513                        }
1514                        if (queuedDate.getMonth() != this_1.currentMonth ||
1515                            (this_1.options.minimumDate && queuedDate < this_1.options.minimumDate) ||
1516                            (this_1.options.maximumDate && queuedDate > this_1.options.maximumDate)) {
1517                            buttonElement.disabled = true;
1518                        }
1519                        if (this_1.options.onBuildingDateButtonElement != null) {
1520                            var callback = window[this_1.options.onBuildingDateButtonElement];
1521                            callback(buttonElement, queuedDate);
1522                        }
1523                        buttonElement.addEventListener('click', function (e) {
1524                            if (_this.isLoadingData) {
1525                                return;
1526                            }
1527                            _this.isLoadingData = true;
1528                            _this.changeDate(buttonElement);
1529                        });
1530                        buttonElement.addEventListener('keydown', function (e) {
1531                            if ([37, 38, 39, 40].indexOf(e.keyCode) > -1) {
1532                                e.preventDefault();
1533                            }
1534                        });
1535                        buttonElement.addEventListener('keyup', function (e) {
1536                            if ([37, 38, 39, 40].indexOf(e.keyCode) > -1) {
1537                                if (e.keyCode == 37) {
1538                                    var previousTdElement = _this.getPreviousCalendarBodyCell(tdElement);
1539                                    if (previousTdElement) {
1540                                        var previousDateButton = _this.getCalendarBodyDateButton(previousTdElement);
1541                                        if (previousDateButton && !previousDateButton.disabled) {
1542                                            buttonElement.tabIndex = -1;
1543                                            previousDateButton.tabIndex = 0;
1544                                            previousDateButton.focus();
1545                                        }
1546                                    }
1547                                }
1548                                else if (e.keyCode == 38) {
1549                                    var previousRow = _this.getPreviousCalendarBodyRow(trElement);
1550                                    if (previousRow) {
1551                                        var previousTdElement = previousRow.children[d];
1552                                        var previousDateButton = _this.getCalendarBodyDateButton(previousTdElement);
1553                                        if (previousDateButton && !previousDateButton.disabled) {
1554                                            buttonElement.tabIndex = -1;
1555                                            previousDateButton.tabIndex = 0;
1556                                            previousDateButton.focus();
1557                                        }
1558                                    }
1559                                }
1560                                else if (e.keyCode == 39) {
1561                                    var nextTdElement = _this.getNextCalendarBodyCell(tdElement);
1562                                    if (nextTdElement) {
1563                                        var nextDateButton = _this.getCalendarBodyDateButton(nextTdElement);
1564                                        if (nextDateButton && !nextDateButton.disabled) {
1565                                            buttonElement.tabIndex = -1;
1566                                            nextDateButton.tabIndex = 0;
1567                                            nextDateButton.focus();
1568                                        }
1569                                    }
1570                                }
1571                                else if (e.keyCode == 40) {
1572                                    var nextRow = _this.getNextCalendarBodyRow(trElement);
1573                                    if (nextRow) {
1574                                        var nextTdElement = nextRow.children[d];
1575                                        var nextDateButton = _this.getCalendarBodyDateButton(nextTdElement);
1576                                        if (nextDateButton && !nextDateButton.disabled) {
1577                                            buttonElement.tabIndex = -1;
1578                                            nextDateButton.tabIndex = 0;
1579                                            nextDateButton.focus();
1580                                        }
1581                                    }
1582                                }
1583                            }
1584                        });
1585                        buttonElement.innerHTML = '<span>' + queuedDate.getDate().toString() + '</span>';
1586                        tdElement.appendChild(buttonElement);
1587                        queuedDate.setDate(queuedDate.getDate() + 1);
1588                    };
1589                    for (var d = 0; d < 7; d++) {
1590                        _loop_12(d);
1591                    }
1592                };
1593                var this_1 = this;
1594                for (var w = 0; w < this.weekRowCount; w++) {
1595                    _loop_11(w);
1596                }
1597            };
1598            CalendarComponent.prototype.getCalendarBodyDateButton = function (currentCell) {
1599                return currentCell.firstChild;
1600            };
1601            CalendarComponent.prototype.getNextCalendarBodyCell = function (currentCell) {
1602                var nextTdElement = currentCell.nextElementSibling;
1603                if (nextTdElement) {
1604                    return nextTdElement;
1605                }
1606                else {
1607                    var nextTrElement = this.getNextCalendarBodyRow(currentCell.parentElement);
1608                    if (nextTrElement) {
1609                        var firstTdElement = nextTrElement.firstElementChild;
1610                        if (firstTdElement) {
1611                            return firstTdElement;
1612                        }
1613                    }
1614                }
1615                return null;
1616            };
1617            CalendarComponent.prototype.getPreviousCalendarBodyCell = function (currentCell) {
1618                var previousTdElement = currentCell.previousElementSibling;
1619                if (previousTdElement) {
1620                    return previousTdElement;
1621                }
1622                else {
1623                    var nextTrElement = this.getPreviousCalendarBodyRow(currentCell.parentElement);
1624                    if (nextTrElement) {
1625                        var lastTdElement = nextTrElement.lastElementChild;
1626                        if (lastTdElement) {
1627                            return lastTdElement;
1628                        }
1629                    }
1630                }
1631                return null;
1632            };
1633            CalendarComponent.prototype.getNextCalendarBodyRow = function (currentRow) {
1634                var nextTrElement = currentRow.nextElementSibling;
1635                if (nextTrElement) {
1636                    if (nextTrElement == this.calendarSelectedDatePanel) {
1637                        return this.getNextCalendarBodyRow(this.calendarSelectedDatePanel);
1638                    }
1639                    return nextTrElement;
1640                }
1641                return null;
1642            };
1643            CalendarComponent.prototype.getPreviousCalendarBodyRow = function (currentRow) {
1644                var previousRow = currentRow.previousElementSibling;
1645                if (previousRow) {
1646                    if (previousRow == this.calendarSelectedDatePanel) {
1647                        return this.getPreviousCalendarBodyRow(this.calendarSelectedDatePanel);
1648                    }
1649                    return previousRow;
1650                }
1651                return null;
1652            };
1653            CalendarComponent.prototype.clearCalendarTableBodyRows = function () {
1654                var trElements = this.calendarTableBody.querySelectorAll('tr');
1655                for (var i = 0, length_23 = trElements.length; i < length_23; i++) {
1656                    var trElement = trElements[i];
1657                    if (trElement != this.calendarSelectedDatePanel) {
1658                        trElement.parentElement.removeChild(trElement);
1659                    }
1660                }
1661            };
1662            CalendarComponent.prototype.buildSelectedDatePanel = function () {
1663                var trElement = document.createElement('tr');

1664                trElement.id = this.element.id + '-calendar-selected-date-panel';
1665                trElement.classList.add('ac-calendar-selected-date-panel');
1666                trElement.setAttribute('role', 'alert');
1667                trElement.setAttribute('aria-live', 'assertive');
1668                var tdElement = document.createElement('td');
1669                tdElement.colSpan = 7;
1670                trElement.appendChild(tdElement);
1671                var divElement = document.createElement('div');
1672                divElement.classList.add('ac-calendar-selected-date-panel-content');
1673                tdElement.appendChild(divElement);
1674                this.calendarSelectedDatePanelContent = divElement;
1675                return trElement;
1676            };
1677            CalendarComponent.prototype.openSelectedDatePanel = function () {
1678                if (this.options.showSelectedDatePanel) {
1679                    this.calendarSelectedDatePanel.classList.add('ac-calendar-selected-date-panel--open');
1680                }
1681            };
1682            CalendarComponent.prototype.closeSelectedDatePanel = function () {
1683                this.calendarSelectedDatePanel.classList.remove('ac-calendar-selected-date-panel--open');
1684            };
1685            CalendarComponent.prototype.changeMonth = function (offset) {
1686                this.selectedDate = null;
1687                this.currentMonthOffset += offset;
1688                this.closeSelectedDatePanel();
1689                this.buildCalendarTableBodyRows();
1690            };
1691            CalendarComponent.prototype.changeDate = function (button) {
1692                var dateString = button.getAttribute('data-date').split('-');
1693                var year = parseInt(dateString[0]);
1694                var month = parseInt(dateString[1]);
1695                var day = parseInt(dateString[2]);
1696                var selected = this.calendarTableBody.querySelector('[aria-selected]');
1697                if (selected && selected != button) {
1698                    selected.removeAttribute('aria-selected');
1699                    selected.setAttribute('aria-expanded', 'false');
1700                }
1701                var expanded = button.getAttribute('aria-expanded');
1702                if (expanded == 'true') {
1703                    this.selectedDate = null;
1704                    selected.removeAttribute('aria-selected');
1705                    selected.setAttribute('aria-expanded', 'false');
1706                    this.closeSelectedDatePanel();
1707                    this.calendarSelectedDatePanelContent.innerHTML = '';
1708                    this.isLoadingData = false;
1709                }
1710                else {
1711                    button.setAttribute('aria-selected', 'true');
1712                    button.setAttribute('aria-expanded', 'true');
1713                    this.closeSelectedDatePanel();
1714                    var inputDate = new Date(year, month, day);
1715                    this.selectedDate = inputDate;
1716                    this.setCalendarHeaderTitle(StandardTemplateApplication.translate(months[this.currentMonth]) + ' ' + year);
1717                    this.selectedTableBodyRow = button.parentElement.parentElement;
1718                    this.updateSelectedDatePanelContent();
1719                    if (this.options.onSelectedDateChangedCallbackName) {
1720                        button.classList.add('js-loading');
1721                        this.openSelectedDatePanel();
1722                        var callback = window[this.options.onSelectedDateChangedCallbackName];
1723                        if (typeof callback === "function") {
1724                            callback(this.calendarSelectedDatePanelContent, this.selectedDate, this.onSelectedDateChangedCallbackCompleted, this.onSelectedDateChangedCallbackError);
1725                        }
1726                        else {
1727                            this.isLoadingData = false;
1728                        }
1729                    }
1730                    else {
1731                        this.openSelectedDatePanel();
1732                        this.isLoadingData = false;
1733                    }
1734                }
1735            };
1736            CalendarComponent.prototype.updateSelectedDatePanelContent = function () {
1737                this.calendarSelectedDatePanelContent.innerHTML = '';
1738                this.calendarSelectedDatePanel.parentNode.insertBefore(this.calendarSelectedDatePanel, this.selectedTableBodyRow.nextSibling);
1739            };
1740            CalendarComponent.prototype.areEqual = function (x, y) {
1741                if (typeof (x) != 'object' || typeof (y) != 'object' || x == null || y == null) {
1742                    return false;
1743                }
1744                return (x.getDate() == y.getDate() && x.getMonth() == y.getMonth() && x.getFullYear() == y.getFullYear());
1745            };
1746            CalendarComponent.prototype.log = function (message) {
1747                if (typeof console !== 'undefined') {
1748                    console.log(message);
1749                }
1750            };
1751            return CalendarComponent;
1752        }());
1753        Components.CalendarComponent = CalendarComponent;
1754    })(Components = Templates.Components || (Templates.Components = {}));
1755})(Templates || (Templates = {}));
1756var Templates;
1757(function (Templates) {
1758    var Components;
1759    (function (Components) {
1760        var LightboxWindow = (function () {
1761            function LightboxWindow() {
1762                this.translations = {};

1763                this._mode = 'DetailView';
1764                this._images = [];
1765                this._currentIndex = 0;
1766            }
1767            Object.defineProperty(LightboxWindow.prototype, "element", {
1768                get: function () {
1769                    return this._element;
1770                },
1771                enumerable: false,
1772                configurable: true
1773            });
1774            Object.defineProperty(LightboxWindow.prototype, "mode", {
1775                get: function () {
1776                    return this._mode;
1777                },
1778                enumerable: false,
1779                configurable: true
1780            });
1781            Object.defineProperty(LightboxWindow.prototype, "images", {
1782                get: function () {
1783                    return this._images;
1784                },
1785                enumerable: false,
1786                configurable: true
1787            });
1788            LightboxWindow.prototype.init = function () {
1789                var _this = this;
1790                this.bindFunctions();
1791                if (window.StandardTemplateTranslations) {
1792                    var translations = window.StandardTemplateTranslations;
1793                    var map = {};
1794                    for (var i = 0, length_24 = translations.length; i < length_24; i++) {
1795                        var translation = translations[i];
1796                        map[translation.key] = translation.value;
1797                    }
1798                    this.translations = map;
1799                }
1800                var overlayElement = document.createElement('div');
1801                overlayElement.className = 'ac-lightbox-overlay';
1802                var lightboxElement = document.createElement('div');
1803                lightboxElement.className = 'ac-lightbox';
1804                overlayElement.appendChild(lightboxElement);
1805                var headerElement = document.createElement('div');
1806                headerElement.className = 'ac-lightbox-header';
1807                lightboxElement.appendChild(headerElement);
1808                var fullScreenToggleElement = document.createElement('button');
1809                fullScreenToggleElement.className = 'ac-lightbox-button ac-lightbox-button--fullscreen';
1810                fullScreenToggleElement.type = 'button';
1811                fullScreenToggleElement.addEventListener('click', function () {
1812                    if (_this._isFullscreen) {
1813                        fullScreenToggleElement.classList.remove('ac-lightbox-button--fullscreen-open');
1814                    }
1815                    else {
1816                        fullScreenToggleElement.classList.add('ac-lightbox-button--fullscreen-open');
1817                    }
1818                    _this.toggleFullscreen();
1819                });
1820                headerElement.appendChild(fullScreenToggleElement);
1821                var fullScreenToggleTextElement = document.createElement('span');
1822                fullScreenToggleTextElement.textContent = this.translate('Templates.Components.Lightbox.Fullscreen') || 'Fullscreen';
1823                fullScreenToggleTextElement.className = 'ac-visually-hidden';
1824                fullScreenToggleElement.appendChild(fullScreenToggleTextElement);
1825                var lightboxIndexTextElement = document.createElement('div');
1826                lightboxIndexTextElement.className = 'ac-lightbox-index-indicator';
1827                lightboxIndexTextElement.textContent = '0 / 0';
1828                headerElement.appendChild(lightboxIndexTextElement);
1829                this._indexTextElement = lightboxIndexTextElement;
1830                var lightboxIndexTextLabelElement = document.createElement('span');
1831                lightboxIndexTextLabelElement.className = 'ac-visually-hidden';
1832                lightboxIndexTextLabelElement.textContent = "".concat(this.translate('Templates.Components.Lightbox.Image'), " ");
1833                this._indexTextElement.appendChild(lightboxIndexTextLabelElement);
1834                var lightboxModeButtonElement = document.createElement('button');
1835                lightboxModeButtonElement.className = 'ac-lightbox-button ac-lightbox-button--mode';
1836                lightboxModeButtonElement.type = 'button';
1837                lightboxModeButtonElement.addEventListener('click', function (event) {
1838                    _this.toggleView();
1839                });
1840                headerElement.appendChild(lightboxModeButtonElement);
1841                this._modeButtonElement = lightboxModeButtonElement;
1842                var lightboxModeButtonTextElement = document.createElement('span');
1843                lightboxModeButtonTextElement.className = 'ac-lightbox-button-text';
1844                lightboxModeButtonTextElement.textContent = (this.mode === 'DetailVie

1844w') ? this.translate('Templates.Components.Lightbox.ListView') : this.translate('Templates.Components.Lightbox.DetailView');
1845                lightboxModeButtonElement.appendChild(lightboxModeButtonTextElement);
1846                this._modeButtonTextElement = lightboxModeButtonTextElement;
1847                var closeButtonElement = document.createElement('button');
1848                closeButtonElement.className = 'ac-lightbox-button ac-lightbox-button--close';
1849                closeButtonElement.type = 'button';
1850                closeButtonElement.addEventListener('click', function (event) {
1851                    _this.close();
1852                });
1853                headerElement.appendChild(closeButtonElement);
1854                this._closeButtonElement = closeButtonElement;
1855                var closeButtonTextElement = document.createElement('span');
1856                closeButtonTextElement.className = 'ac-lightbox-button-text';
1857                closeButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.Close');
1858                closeButtonElement.appendChild(closeButtonTextElement);
1859                var bodyElement = document.createElement('div');
1860                bodyElement.className = 'ac-lightbox-body';
1861                lightboxElement.appendChild(bodyElement);
1862                this._bodyElement = bodyElement;
1863                var footerElement = document.createElement('div');
1864                footerElement.className = 'ac-lightbox-footer';
1865                lightboxElement.appendChild(footerElement);
1866                var previousImageButtonElement = document.createElement('button');
1867                previousImageButtonElement.className = 'ac-lightbox-button ac-lightbox-button--previous';
1868                previousImageButtonElement.type = 'button';
1869                previousImageButtonElement.addEventListener('click', function (event) {
1870                    _this.showPreviousImage();
1871                });
1872                footerElement.appendChild(previousImageButtonElement);
1873                this._previousImageButtonElement = previousImageButtonElement;
1874                var previousImageButtonTextElement = document.createElement('span');
1875                previousImageButtonTextElement.className = 'ac-lightbox-button-text';
1876                previousImageButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.PreviousImage');
1877                previousImageButtonElement.appendChild(previousImageButtonTextElement);
1878                var nextImageButtonElement = document.createElement('button');
1879                nextImageButtonElement.className = 'ac-lightbox-button ac-lightbox-button--next';
1880                nextImageButtonElement.type = 'button';
1881                nextImageButtonElement.addEventListener('click', function (event) {
1882                    _this.showNextImage();
1883                });
1884                footerElement.appendChild(nextImageButtonElement);
1885                this._nextImageButtonElement = nextImageButtonElement;
1886                var nextImageButtonTextElement = document.createElement('span');
1887                nextImageButtonTextElement.className = 'ac-lightbox-button-text';
1888                nextImageButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.NextImage');
1889                nextImageButtonElement.appendChild(nextImageButtonTextElement);
1890                this._element = overlayElement;
1891                document.addEventListener('keydown', function (event) {
1892                    var keyCode = event.which || event.keyCode;
1893                    if (event.keyCode === 9) {
1894                        if (_this.isOpen()) {
1895                            var focusableElements = overlayElement.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
1896                            var firstFocusableElement = focusableElements[0];
1897                            var lastFocusableElement = focusableElements[focusableElements.length - 1];
1898                            var targetElement = event.target;
1899                            if (!targetElement.closest('.ac-lightbox-overlay')) {
1900                                event.preventDefault();
1901                            }
1902                            else {
1903                                if (event.target === lastFocusableElement && !event.shiftKey) {
1904                                    event.preventDefault();
1905                                    firstFocusableElement.focus();
1906                                }
1907                                else if (event.target === firstFocusableElement && event.shiftKey) {
1908                                    event.preventDefault();
1909                                    lastFocusableElement.focus();
1910                                }
1911                            }
1912                        }
1913                    }
1914                });
1915                document.addEventListener('keyup', function (event) {
1916                    var keyCode = event.which || event.keyCode;
1917                    if (keyCode === 27) {
1918                        _this.close();
1919                    }
1920                });
1921                document.addEventListener('fullscreenchange', function (event) {
1922                    var notFullscreen = !document.fullscreen && !document.fullscreenEnabled && !document.webkitFullscreenElement && !document.mozFullscreenElement;
1923                    if (notFullscreen) {
1924                        _this.exitFullscreen();
1925                    }
1926                });
1927                this.addSwipeGestures();
1928            };
1929            LightboxWindow.prototype.translate = function (key) {
1930                return this.translations[key];
1931            };
1932            LightboxWindow.prototype.clear = function () {
1933                this._images = [];
1934                this._currentIndex = 0;
1935            };
1936            LightboxWindow.prototype.addImage = function (image) {
1937                this._images.push(image);
1938            };
1939            LightboxWindow.prototype.open = function (startIndex, initiator) {
1940                this._currentIndex = startIndex;
1941                this._currentInitiator = initiator;

1942                this.showDetailView();
1943                this.element.className = 'ac-lightbox-overlay ac-lightbox-overlay--open';
1944            };
1945            LightboxWindow.prototype.close = function () {
1946                if (this._currentInitiator) {
1947                    this._currentInitiator.focus();
1948                }
1949                this._currentInitiator = null;
1950                this.element.className = 'ac-lightbox-overlay';
1951                this.exitFullscreen();
1952            };
1953            LightboxWindow.prototype.bindFunctions = function () {
1954                this.toggleFullscreen = this.toggleFullscreen.bind(this);
1955            };
1956            LightboxWindow.prototype.toggleView = function () {
1957                if (this.mode === 'DetailView') {
1958                    this.showListView();
1959                }
1960                else {
1961                    this.showDetailView();
1962                }
1963            };
1964            LightboxWindow.prototype.showDetailView = function () {
1965                var _this = this;
1966                this._mode = 'DetailView';
1967                this._indexTextElement.textContent = "".concat(this._currentIndex + 1, " ").concat(this.translate('Templates.Components.Lightbox.Of'), " ").concat(this.images.length);
1968                this._modeButtonElement.classList.remove('detail-view');
1969                this._modeButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.ListView');
1970                this._nextImageButtonElement.hidden = false;
1971                this._nextImageButtonElement.disabled = !this.hasNextImage();
1972                this._previousImageButtonElement.hidden = false;
1973                this._previousImageButtonElement.disabled = !this.hasPreviousImage();
1974                setTimeout(function () {
1975                    if (!_this.hasNextImage()) {
1976                        if (!_this.hasPreviousImage()) {
1977                            _this._closeButtonElement.focus();
1978                        }
1979                        else {
1980                            _this._previousImageButtonElement.focus();
1981                        }
1982                    }
1983                    else if (!_this.hasPreviousImage()) {
1984                        if (!_this.hasNextImage()) {
1985                            _this._closeButtonElement.focus();
1986                        }
1987                        else {
1988                            _this._nextImageButtonElement.focus();
1989                        }
1990                    }
1991                }, 100);
1992                this.clearBodyContent();
1993                if (this.images.length > 0) {
1994                    var currentImage = this.images[this._currentIndex];
1995                    var imageElement = document.createElement('img');
1996                    imageElement.className = 'ac-lightbox-image';
1997                    imageElement.src = currentImage.imageUrl;
1998                    imageElement.alt = currentImage.alttext;
1999                    this._bodyElement.appendChild(imageElement);
2000                    if (currentImage.description) {
2001                        var descriptionElement = document.createElement('div');
2002                        descriptionElement.className = 'ac-lightbox-image-description';
2003                        descriptionElement.innerHTML = currentImage.description;
2004                        this._bodyElement.appendChild(descriptionElement);
2005                    }
2006                }
2007            };
2008            LightboxWindow.prototype.isOpen = function () {
2009                return this.element.classList.contains('ac-lightbox-overlay--open');
2010            };
2011            LightboxWindow.prototype.hasPreviousImage = function () {
2012                return this._currentIndex > 0;
2013            };
2014            LightboxWindow.prototype.hasNextImage = function () {
2015                return this._currentIndex < this.images.length - 1;
2016            };
2017            LightboxWindow.prototype.showPreviousImage = function () {
2018                if (this.hasPreviousImage()) {
2019                    this._currentIndex--;

2020                    this.showDetailView();
2021                }
2022            };
2023            LightboxWindow.prototype.showNextImage = function () {
2024                if (this.hasNextImage()) {
2025                    this._currentIndex++;
2026                    this.showDetailView();
2027                }
2028            };
2029            LightboxWindow.prototype.showListView = function () {
2030                var _this = this;
2031                this._mode = 'ListView';
2032                this._modeButtonElement.classList.add('detail-view');
2033                this._modeButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.DetailView');
2034                this._nextImageButtonElement.hidden = true;
2035                this._previousImageButtonElement.hidden = true;
2036                setTimeout(function () { _this._closeButtonElement.focus(); }, 100);
2037                this.clearBodyContent();
2038                if (this.images.length > 0) {
2039                    var ulElement = document.createElement('ul');
2040                    ulElement.className = 'ac-lightbox-thumbnail-list';
2041                    var _loop_13 = function (j, length_25) {
2042                        var image = this_2.images[j];
2043                        var liElement = document.createElement('li');
2044                        liElement.className = 'ac-lightbox-thumbnail';
2045                        ulElement.appendChild(liElement);
2046                        var anchorElement = document.createElement('a');
2047                        anchorElement.className = 'ac-lightbox-thumbnail-anchor';
2048                        anchorElement.href = '#';
2049                        anchorElement.addEventListener('click', function (event) {
2050                            event.preventDefault();
2051                            _this._currentIndex = j;
2052                            _this.toggleView();
2053                            setTimeout(function () {
2054                                if (!_this.hasNextImage()) {
2055                                    if (!_this.hasPreviousImage()) {
2056                                        _this._closeButtonElement.focus();
2057                                    }
2058                                    else {
2059                                        _this._previousImageButtonElement.focus();
2060                                    }
2061                                }
2062                                else if (!_this.hasPreviousImage()) {
2063                                    if (!_this.hasNextImage()) {
2064                                        _this._closeButtonElement.focus();
2065                                    }
2066                                    else {
2067                                        _this._nextImageButtonElement.focus();
2068                                    }
2069                                }
2070                                else {
2071                                    _this._nextImageButtonElement.focus();
2072                                }
2073                            }, 100);
2074                        });
2075                        liElement.appendChild(anchorElement);
2076                        var imageElement = document.createElement('img');
2077                        imageElement.className = 'ac-lightbox-thumbnail-image';
2078                        imageElement.src = image.thumbnailUrl;
2079                        imageElement.alt = image.alttext;
2080                        anchorElement.appendChild(imageElement);
2081                    };
2082                    var this_2 = this;
2083                    for (var j = 0, length_25 = this.images.length; j < length_25; j++) {
2084                        _loop_13(j, length_25);
2085                    }
2086                    this._bodyElement.appendChild(ulElement);
2087                }
2088            };
2089            LightboxWindow.prototype.clearBodyContent = function () {
2090                while (this._bodyElement.firstChild) {
2091                    this._bodyElement.removeChild(this._bodyElement.firstChild);
2092                }
2093            };
2094            LightboxWindow.prototype.requestFullscreen = function () {
2095                if (this._isFullscreen) {
2096                    return;
2097                }
2098                if (this.supportsFullscreen()) {
2099                    this._element.requestFullscreen();
2100                }
2101                this._isFullscreen = true;
2102                this._element.classList.add('ac-lightbox-overlay--fullscreen');
2103            };
2104            LightboxWindow.prototype.exitFullscreen = function () {
2105                if (!this._isFullscreen) {
2106                    return;
2107                }
2108                if (this.supportsFullscreen()) {
2109                    document.exitFullscreen();
2110                }
2111                this._isFullscreen = false;
2112                this._element.classList.remove('ac-lightbox-overlay--fullscreen');
2113            };
2114            LightboxWindow.prototype.toggleFullscreen = function () {
2115                if (this._isFullscreen) {
2116                    this.exitFullscreen();
2117                }
2118                else {
2119                    this.requestFullscreen();
2120                }
2121            };
2122            LightboxWindow.prototype.supportsFullscreen = function () {
2123                return (!!document.body.requestFullscreen && !!document.exitFullscreen);
2124            };
2125            LightboxWindow.prototype.addSwipeGestures = function () {
2126                this._element.addEventListener('mousedown', lock.bind(this));
2127                this._element.addEventListener('touchstart', lock.bind(this));
2128                this._element.addEventListener('mouseup', move.bind(this));
2129                this._element.addEventListener('touchend', move.bind(this));
2130                var x0 = null;
2131                function lock(event) {
2132                    x0 = unify(event).clientX;
2133                }
2134                function move(event) {

2135                    if (this._mode !== 'DetailView') {
2136                        return;
2137                    }
2138                    if (x0 || x0 === 0) {
2139                        var dx = unify(event).clientX - x0;
2140                        var movingToTheLeft = dx < 0;
2141                        var movingToTheRight = dx > 0;
2142                        if (movingToTheLeft) {
2143                            this.showNextImage();
2144                        }
2145                        else if (movingToTheRight) {
2146                            this.showPreviousImage();
2147                        }
2148                        x0 = null;
2149                    }
2150                }
2151                function unify(event) {
2152                    return event.changedTouches ? event.changedTouches[0] : event;
2153                }
2154            };
2155            return LightboxWindow;
2156        }());
2157        Components.LightboxWindow = LightboxWindow;
2158        var LightboxImage = (function () {
2159            function LightboxImage() {
2160            }
2161            return LightboxImage;
2162        }());
2163        Components.LightboxImage = LightboxImage;
2164        var LightboxApplicationOptions = (function () {
2165            function LightboxApplicationOptions() {
2166                this.anchorSelector = '.js-lightbox-image-anchor';
2167                this.imageSelector = '.js-lightbox-image';
2168                this.collectionSelector = '.js-lightbox-image-collection';
2169                this.imageUrlDataAttributteName = 'data-lightbox-image-url';
2170                this.thumbnailUrlDataAttributteName = 'data-lightbox-thumbnail-url';
2171                this.descriptionDataAttributteName = 'data-lightbox-image-description';
2172                this.alttextDataAttributteName = 'data-lightbox-image-alttext';
2173            }
2174            return LightboxApplicationOptions;
2175        }());
2176        Components.LightboxApplicationOptions = LightboxApplicationOptions;
2177        var LightboxApplication = (function () {
2178            function LightboxApplication(options) {
2179                var _this = this;
2180                this.clickHandler = function (e) {
2181                    e.preventDefault();
2182                    var anchorElements = document.body.querySelectorAll(_this.options.anchorSelector);
2183                    var anchorElement = event.currentTarget;
2184                    _this.window.clear();
2185                    var _imageElements = [];
2186                    var _imageElement = anchorElement.querySelector(_this.options.imageSelector);
2187                    if (_imageElement) {
2188                        var imageCollectionElement = anchorElement.closest(_this.options.collectionSelector);
2189                        if (imageCollectionElement) {
2190                            var imageElements = imageCollectionElement.querySelectorAll(_this.options.imageSelector);
2191                            if (imageElements) {
2192                                for (var j = 0, length_26 = imageElements.length; j < length_26; j++) {
2193                                    var imageElement = imageElements[j];
2194                                    var imageUrl = imageElement.getAttribute(_this.options.imageUrlDataAttributteName);
2195                                    var thumbnailUrl = imageElement.getAttribute(_this.options.thumbnailUrlDataAttributteName);
2196                                    var description = imageElement.getAttribute(_this.options.descriptionDataAttributteName);
2197                                    var alttext = imageElement.getAttribute(_this.options.alttextDataAttributteName);
2198                                    if (imageUrl && thumbnailUrl) {
2199                                        var image = new LightboxImage();
2200                                        image.imageUrl = imageUrl;
2201                                        image.thumbnailUrl = thumbnailUrl;
2202                                        image.description = description;
2203                                        image.alttext = alttext;
2204                                        _this.window.addImage(image);
2205                                        _imageElements.push(imageElement);
2206                                    }
2207                                }
2208                            }
2209                        }
2210                        else {
2211                            for (var j = 0, length_27 = anchorElements.length; j < length_27; j++) {
2212                                var ab = anchorElements[j];
2213                                if (!ab.closest(_this.options.collectionSelector)) {
2214                                    var imageElement = ab.querySelector(_this.options.imageSelector);
2215                                    if (imageElement) {
2216                                        var imageUrl = imageElement.getAttribute(_this.options.imageUrlDataAttributteName);
2217                                        var thumbnailUrl = imageElement.getAttribute(_this.options.thumbnailUrlDataAttributteName);
2218                                        var description = imageElement.getAttribute(_this.options.descriptionDataAttributteName);
2219                                        var alttext = imageElement.getAttribute(_this.options.alttextDataAttributteName);
2220                                        if (imageUrl && thumbnailUrl) {
2221                                            var image = new LightboxImage();
2222                                            image.imageUrl = imageUrl;
2223                                            image.thumbnailUrl = thumbnailUrl;
2224                                            image.description = description;
2225                                            image.alttext = alttext;
2226                                            _this.window.addImage(image);
2227                                            _imageElements.push(imageElement);
2228                                        }
2229                                    }
2230                                }
2231                            }
2232                        }
2233                        var imageIndex = ([].slice.call(_imageElements)).indexOf(_imageElement);
2234                        _this.window.open(imageIndex, anchorElement);
2235                    }
2236                };
2237                this._options = options;
2238                this._window = new Components.LightboxWindow();
2239            }
2240            Object.defineProperty(LightboxApplication.prototype, "options", {
2241                get: function () {
2242                    return this._options;
2243                },
2244                enumerable: false,
2245                configurable: true
2246            });
2247            Object.defineProperty(LightboxApplication.prototype, "window", {
2248                get: function () {
2249                    return this._window;
2250                },
2251                enumerable: false,
2252                configurable: true
2253            });
2254            LightboxApplication.prototype.init = function () {
2255                var _this = this;
2256                this.window.init();
2257                document.body.appendChild(this.window.element);
2258                this.bindAnchors();

2259                if (window.eventBus) {
2260                    window.eventBus.addEventListener('init-lightbox', function (event) {
2261                        _this.bindAnchors();
2262                    });
2263                    window.eventBus.addEventListener('show-container', function (event) {
2264                        _this.bindAnchors();
2265                    });
2266                }
2267            };
2268            ;
2269            LightboxApplication.prototype.bindAnchors = function () {
2270                var anchorElements = document.body.querySelectorAll(this.options.anchorSelector);
2271                if (anchorElements) {
2272                    for (var i = 0, length_28 = anchorElements.length; i < length_28; i++) {
2273                        var anchorElement = anchorElements[i];
2274                        anchorElement.removeEventListener('click', this.clickHandler);
2275                        anchorElement.addEventListener('click', this.clickHandler);
2276                    }
2277                }
2278            };
2279            return LightboxApplication;
2280        }());
2281        Components.LightboxApplication = LightboxApplication;
2282    })(Components = Templates.Components || (Templates.Components = {}));
2283})(Templates || (Templates = {}));
2284var Templates;
2285(function (Templates) {
2286    var Components;
2287    (function (Components) {
2288        'use strict';

2289        var MapProvider;
2290        (function (MapProvider) {
2291            MapProvider[MapProvider["Google"] = 1] = "Google";
2292            MapProvider[MapProvider["NorkartWebatlas"] = 2] = "NorkartWebatlas";
2293        })(MapProvider = Components.MapProvider || (Components.MapProvider = {}));
2294        var GoogleMapsMapOptions = (function () {
2295            function GoogleMapsMapOptions() {
2296                this.items = [];
2297                this.initialLatitude = 60.3470988;
2298                this.initialLongitude = 5.1324035;
2299                this.initialZoomLevel = 16;
2300            }
2301            return GoogleMapsMapOptions;
2302        }());
2303        Components.GoogleMapsMapOptions = GoogleMapsMapOptions;
2304        var NorkartWebatlasMapOptions = (function () {
2305            function NorkartWebatlasMapOptions() {
2306                this.items = [];
2307                this.initialLatitude = 60.3470988;
2308                this.initialLongitude = 5.1324035;
2309                this.initialZoomLevel = 16;
2310            }
2311            return NorkartWebatlasMapOptions;
2312        }());
2313        Components.NorkartWebatlasMapOptions = NorkartWebatlasMapOptions;
2314        var GoogleMapsMapComponent = (function () {
2315            function GoogleMapsMapComponent(options) {
2316                this.items = [];
2317                this.element = options.element;
2318                this.options = options;
2319                this.items = options.items;
2320            }
2321            Object.defineProperty(GoogleMapsMapComponent.prototype, "$typeName", {
2322                get: function () {
2323                    return 'Google';
2324                },
2325                enumerable: false,
2326                configurable: true
2327            });
2328            GoogleMapsMapComponent.prototype.init = function () {
2329                if (!window.initMap) {
2330                    var s = document.createElement('script');
2331                    s.type = 'text/javascript';
2332                    s.async = true;
2333                    s.src = 'https://maps.googleapis.com/maps/api/js?key=' + this.options.googleMapsApiKey + '&language=no&region=no&callback=initMap';
2334                    var x = document.getElementsByTagName('script')[0];
2335                    x.parentNode.insertBefore(s, x);
2336                    window.initMap = function () {
2337                        var elements = window['mapComponents'];
2338                        if (elements) {
2339                            for (var i = 0, length_29 = elements.length; i < length_29; i++) {
2340                                var mapComponent = elements[i];
2341                                if (mapComponent.$typeName === 'Google') {
2342                                    var mapControl = mapComponent.element.querySelector('.ac-map-canvas');
2343                                    mapComponent.map = new google.maps.Map(mapControl, {
2344                                        center: { lat: mapComponent.options.initialLatitude, lng: mapComponent.options.initialLongitude },
2345                                        zoom: mapComponent.options.initialZoomLevel
2346                                    });
2347                                    mapComponent.markers = [];
2348                                    if (mapComponent.items.length > 0 || mapComponent.options.geoJSON) {
2349                                        mapComponent.render();
2350                                    }
2351                                }
2352                            }
2353                        }
2354                    };
2355                }
2356            };
2357            GoogleMapsMapComponent.prototype.render = function () {
2358                this.renderMap();
2359            };
2360            GoogleMapsMapComponent.prototype.renderMap = function () {
2361                var _this = this;
2362                if (this.map) {
2363                    var markerBounds = new google.maps.LatLngBounds();
2364                    var itemTemplate = void 0;
2365                    var itemTemplateElement = this.element.querySelector('.item-template');
2366                    if (itemTemplateElement) {
2367                        var itemTemplateHtml = itemTemplateElement.innerHTML;
2368                        itemTemplate = Handlebars.compile(itemTemplateHtml);
2369                    }
2370                    var _loop_14 = function (i, length_30) {
2371                        var item = this_3.items[i];
2372                        myLatLng = { lat: item.Latitude, lng: item.Longitude };
2373                        var marker = new google.maps.Marker({
2374                            position: myLatLng,
2375                            map: this_3.map
2376                        });
2377                        if (item.IconUrl) {
2378                            marker.setIcon(item.IconUrl);
2379                        }
2380                        if (itemTemplate) {
2381                            var infowindow_1 = new google.maps.InfoWindow({
2382                                content: itemTemplate(item)
2383                            });
2384                            marker.addListener('click', function () {
2385                                infowindow_1.open(this.map, marker);
2386                            });
2387                        }
2388                        markerBounds.extend(myLatLng);
2389                        this_3.markers.push(marker);
2390                    };
2391                    var this_3 = this, myLatLng;
2392                    for (var i = 0, length_30 = this.items.length; i < length_30; i++) {
2393                        _loop_14(i, length_30);
2394                    }
2395                    if (this.options.geoJSON) {
2396                        var bounds = new google.maps.LatLngBounds();
2397                        this.map.data.addListener('addfeature', function (e) {
2398                            _this.processPoints(e.feature.getGeometry(), bounds.extend, bounds);
2399                            _this.map.fitBounds(bounds);
2400                        });
2401                        var geoJsonObject = {
2402                            type: "FeatureCollection",
2403                            features: []
2404                        };
2405                        for (var i = 0, length_31 = this.options.geoJSON.length; i < length_31; i++) {
2406                            var layer = this.options.geoJSON[i];
2407                            geoJsonObject.features.push({
2408                                type: "Feature",
2409                                properties: {},
2410                                geometry: layer
2411                            });
2412                        }
2413                        this.map.data.setStyle({
2414                            fillColor: 'green'
2415                        });
2416                        this.map.data.addGeoJson(geoJsonObject);
2417                    }
2418                    if (this.markers.length == 1) {
2419                        this.map.setZoom(this.options.initialZoomLevel);
2420                        this.map.setCenter(this.markers[0].getPosition());
2421                    }
2422                    else {
2423                        if (this.markers.length > 0) {
2424                            this.map.fitBounds(markerBounds);
2425                            var zoomLevel = this.map.getZoom();
2426                            this.map.setZoom((zoomLevel > this.options.initialZoomLevel) ? this.options.initialZoomLevel : zoomLevel);
2427                        }
2428                    }
2429                }
2430            };
2431            GoogleMapsMapComponent.prototype.processPoints = function (geometry, callback, thisArg) {
2432                var _this = this;
2433                if (geometry instanceof google.maps.LatLng) {
2434                    callback.call(thisArg, geometry);
2435                }
2436                else if (geometry instanceof google.maps.Data.Point) {
2437                    callback.call(thisArg, geometry.get());
2438                }
2439                else {

2440                    geometry.getArray().forEach(function (g) {
2441                        _this.processPoints(g, callback, thisArg);
2442                    });
2443                }
2444            };
2445            return GoogleMapsMapComponent;
2446        }());
2447        Components.GoogleMapsMapComponent = GoogleMapsMapComponent;
2448        var NorkartWebatlasMapComponent = (function () {
2449            function NorkartWebatlasMapComponent(options) {
2450                this.items = [];
2451                this.element = options.element;
2452                this.options = options;
2453                this.items = options.items;
2454            }
2455            Object.defineProperty(NorkartWebatlasMapComponent.prototype, "$typeName", {
2456                get: function () {
2457                    return 'Norkart';
2458                },
2459                enumerable: false,
2460                configurable: true
2461            });
2462            NorkartWebatlasMapComponent.prototype.init = function () {
2463                if (!window.initNorkartMaps) {
2464                    var styleSheets = [
2465                        'https://unpkg.com/[email protected]/dist/leaflet.css'
2466                    ];
2467                    styleSheets.forEach(function (style) {
2468                        var linkElement = document.createElement('link');
2469                        linkElement.type = 'text/css';
2470                        linkElement.rel = 'stylesheet';
2471                        linkElement.href = style;
2472                        document.head.appendChild(linkElement);
2473                    });
2474                    var scriptElement = document.createElement('script');
2475                    scriptElement.src = 'https://unpkg.com/[email protected]/dist/leaflet.js';
2476                    scriptElement.onload = function () {
2477                        var innerScriptElement = document.createElement('script');
2478                        innerScriptElement.src = 'https://norkart.github.io/L.TileLayer.Webatlas/L.TileLayer.Webatlas.min.js';
2479                        innerScriptElement.onload = function () {
2480                            window.setTimeout(function () {
2481                                window.initNorkartMaps();
2482                            }, 1000);
2483                        };
2484                        document.head.appendChild(innerScriptElement);
2485                    };
2486                    document.head.appendChild(scriptElement);
2487                    window.initNorkartMaps = function () {
2488                        var elements = window['mapComponents'];
2489                        if (elements) {
2490                            var _loop_15 = function (i, length_32) {
2491                                var mapComponent = elements[i];
2492                                if (mapComponent.$typeName === 'Norkart') {
2493                                    var mapControl = mapComponent.element.querySelector('.ac-map-canvas');
2494                                    mapComponent.map = L.map(mapControl, {
2495                                        center: [mapComponent.options.initialLatitude, mapComponent.options.initialLongitude],
2496                                        zoom: mapComponent.options.initialZoomLevel,
2497                                        fullscreenControl: true,
2498                                        fullscreenControlOptions: {
2499                                            position: 'topleft'
2500                                        }
2501                                    });
2502                                    if (window.eventBus) {
2503                                        window.eventBus.addEventListener('show-container', function (event) {
2504                                            var element = event.target.contains(mapComponent.element);
2505                                            if (element) {
2506                                                mapComponent.reRenderMap();
2507                                            }
2508                                        });
2509                                    }
2510                                    if (mapComponent.items.length > 0 || mapComponent.options.geoJSON) {
2511                                        mapComponent.render();
2512                                    }
2513                                }
2514                            };
2515                            for (var i = 0, length_32 = elements.length; i < length_32; i++) {
2516                                _loop_15(i, length_32);
2517                            }
2518                        }
2519                    };
2520                }
2521            };
2522            NorkartWebatlasMapComponent.prototype.render = function () {
2523                this.renderMap();
2524            };
2525            NorkartWebatlasMapComponent.prototype.reRenderMap = function () {
2526                var _this = this;
2527                if (this.map) {
2528                    window.setTimeout(function () {
2529                        _this.map.invalidateSize();
2530                    }, 500);
2531                }
2532            };
2533            NorkartWebatlasMapComponent.prototype.renderMap = function () {
2534                if (this.map) {
2535                    var applicationOptions = window.applicationOptions;
2536                    var url = "/Maler/Standard/Handlers/ResourceHandler.ashx?type=map-tiles&tileSet={tileset}&z={z}&x={x}&y={y}";
2537                    var baseLayers = {
2538                        'Kart': L.tileLayer.webatlas({
2539                            mapType: 'vector',
2540                            url: url,
2541                            apikey: 'DUMMY'
2542                        })
2543                            .addTo(this.map),
2544                        'Foto': L.tileLayer.webatlas({
2545                            mapType: 'aerial',
2546                            url: url,
2547                            apikey: 'DUMMY'
2548                        }),
2549                        'Hybrid': L.tileLayer.webatlas({
2550                            mapType: 'hybrid',
2551                            url: url,
2552                            apikey: 'DUMMY'
2553                        })
2554                    };
2555                    L.control.layers(baseLayers, {}).addTo(this.map);
2556                    if (this.items.length > 0) {
2557                        var x = this.items[0].Longitude;
2558                        var y = this.items[0].Latitude;

2559                        this.map.setView([y, x], 18);
2560                        var startMarker = L.marker([y, x]).addTo(this.map);
2561                        var adressePunktList = null;
2562                    }
2563                    if (this.options.geoJSON) {
2564                        var geoJsonObject = {
2565                            type: "FeatureCollection",
2566                            features: []
2567                        };
2568                        for (var i = 0, length_33 = this.options.geoJSON.length; i < length_33; i++) {
2569                            var layer = this.options.geoJSON[i];
2570                            geoJsonObject.features.push({
2571                                type: "Feature",
2572                                properties: {},
2573                                geometry: layer
2574                            });
2575                        }
2576                        var geojsonLayer = L.geoJSON(geoJsonObject).addTo(this.map);
2577                        this.map.fitBounds(geojsonLayer.getBounds());
2578                    }
2579                }
2580            };
2581            return NorkartWebatlasMapComponent;
2582        }());
2583        Components.NorkartWebatlasMapComponent = NorkartWebatlasMapComponent;
2584    })(Components = Templates.Components || (Templates.Components = {}));
2585})(Templates || (Templates = {}));
2586var Templates;
2587(function (Templates) {
2588    var Components;
2589    (function (Components) {
2590        var ModalWindow = (function () {
2591            function ModalWindow() {
2592                this.translations = {};
2593            }
2594            Object.defineProperty(ModalWindow.prototype, "element", {
2595                get: function () {
2596                    return this._element;
2597                },
2598                enumerable: false,
2599                configurable: true
2600            });
2601            ModalWindow.prototype.init = function () {
2602                var _this = this;
2603                this.bindFunctions();
2604                if (window.StandardTemplateTranslations) {
2605                    var translations = window.StandardTemplateTranslations;
2606                    var map = {};
2607                    for (var i = 0, length_34 = translations.length; i < length_34; i++) {
2608                        var translation = translations[i];
2609                        map[translation.key] = translation.value;
2610                    }
2611                    this.translations = map;
2612                }
2613                var overlayElement = document.createElement('div');
2614                overlayElement.className = 'ac-modal-overlay';
2615                var modalElement = document.createElement('div');
2616                modalElement.className = 'ac-modal';
2617                this._modalElement = modalElement;
2618                overlayElement.appendChild(modalElement);
2619                var headerElement = document.createElement('div');
2620                headerElement.className = 'ac-modal-header';
2621                modalElement.appendChild(headerElement);
2622                var closeButtonElement = document.createElement('button');
2623                closeButtonElement.className = 'ac-modal-button ac-modal-button--close';
2624                closeButtonElement.type = 'button';
2625                closeButtonElement.addEventListener('click', function (event) {
2626                    _this.close();
2627                });
2628                headerElement.appendChild(closeButtonElement);
2629                this._closeButtonElement = closeButtonElement;
2630                var closeButtonTextElement = document.createElement('span');
2631                closeButtonTextElement.className = 'ac-modal-button-text';
2632                closeButtonTextElement.textContent = this.translate('Templates.Components.Lightbox.Close');
2633                closeButtonElement.appendChild(closeButtonTextElement);
2634                var bodyElement = document.createElement('div');
2635                bodyElement.className = 'ac-modal-body';
2636                modalElement.appendChild(bodyElement);
2637                this._bodyElement = bodyElement;
2638                var footerElement = document.createElement('div');
2639                footerElement.className = 'ac-modal-footer';
2640                modalElement.appendChild(footerElement);
2641                this._element = overlayElement;
2642                document.addEventListener('keydown', function (event) {
2643                    var keyCode = event.which || event.keyCode;
2644                    if (event.keyCode === 9) {
2645                        if (_this.isOpen()) {
2646                            var focusableElements = overlayElement.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not

2646([tabindex="-1"])');
2647                            var firstFocusableElement = focusableElements[0];
2648                            var lastFocusableElement = focusableElements[focusableElements.length - 1];
2649                            var targetElement = event.target;
2650                            if (!targetElement.closest('.ac-modal-overlay')) {
2651                                event.preventDefault();
2652                            }
2653                            else {
2654                                if (event.target === lastFocusableElement && !event.shiftKey) {
2655                                    event.preventDefault();
2656                                    firstFocusableElement.focus();
2657                                }
2658                                else if (event.target === firstFocusableElement && event.shiftKey) {
2659                                    event.preventDefault();
2660                                    lastFocusableElement.focus();
2661                                }
2662                            }
2663                        }
2664                    }
2665                });
2666                document.addEventListener('keyup', function (event) {
2667                    var keyCode = event.which || event.keyCode;
2668                    if (keyCode === 27) {
2669                        _this.close();
2670                    }
2671                });
2672                document.addEventListener('fullscreenchange', function (event) {
2673                    var notFullscreen = !document.fullscreen && !document.fullscreenEnabled && !document.webkitFullscreenElement && !document.mozFullscreenElement;
2674                    if (notFullscreen) {
2675                        _this.exitFullscreen();
2676                    }
2677                });
2678            };
2679            ModalWindow.prototype.translate = function (key) {
2680                return this.translations[key];
2681            };
2682            ModalWindow.prototype.clear = function () {
2683            };
2684            ModalWindow.prototype.open = function (options, initiator) {
2685                this._currentInitiator = initiator;
2686                this.showDetailView(options);
2687                this.element.className = 'ac-modal-overlay ac-modal-overlay--open';
2688                this._modalElement.classList.add((options.type === 'Confirm') ? 'ac-modal--confirm' : 'ac-modal-dialog');
2689                var clientRect = this._modalElement.getBoundingClientRect();
2690                var top = window.scrollY + (window.innerHeight / 2) - (clientRect.height / 2);
2691                this._modalElement.style.top = top + 'px';
2692                this._closeButtonElement.focus();
2693            };
2694            ModalWindow.prototype.close = function () {
2695                if (this._currentInitiator) {
2696                    this._currentInitiator.focus();
2697                }
2698                this._currentInitiator = null;
2699                this.element.className = 'ac-modal-overlay';
2700                this._modalElement.classList.remove('ac-modal--confirm');
2701                this._modalElement.classList.remove('ac-modal-dialog');
2702                this.exitFullscreen();
2703            };
2704            ModalWindow.prototype.bindFunctions = function () {
2705                this.toggleFullscreen = this.toggleFullscreen.bind(this);
2706            };
2707            ModalWindow.prototype.showDetailView = function (options) {
2708                this.clearBodyContent();
2709                var iframeElement = document.createElement('iframe');
2710                iframeElement.className = 'ac-modal-iframe';
2711                iframeElement.src = options.iframeUrl;
2712                iframeElement.title = options.title;
2713                this._bodyElement.appendChild(iframeElement);
2714            };
2715            ModalWindow.prototype.isOpen = function () {
2716                return this.element.classList.contains('ac-modal-overlay--open');
2717            };
2718            ModalWindow.prototype.clearBodyContent = function () {
2719                while (this._bodyElement.firstChild) {
2720                    this._bodyElement.removeChild(this._bodyElement.firstChild);
2721                }
2722            };
2723            ModalWindow.prototype.requestFullscreen = function () {
2724                if (this._isFullscreen) {
2725                    return;
2726                }
2727                if (this.supportsFullscreen()) {
2728                    this._element.requestFullscreen();
2729                }
2730                this._isFullscreen = true;
2731                this._element.classList.add('ac-modal-overlay--fullscreen');
2732            };
2733            ModalWindow.prototype.exitFullscreen = function () {
2734                if (!this._isFullscreen) {
2735                    return;
2736                }
2737                if (this.supportsFullscreen()) {
2738                    document.exitFullscreen();
2739                }
2740                this._isFullscreen = false;
2741                this._element.classList.remove('ac-modal-overlay--fullscreen');
2742            };
2743            ModalWindow.prototype.toggleFullscreen = function () {
2744                if (this._isFullscreen) {
2745                    this.exitFullscreen();
2746                }
2747                else {
2748                    this.requestFullscreen();
2749                }
2750            };
2751            ModalWindow.prototype.supportsFullscreen = function () {
2752                return (!!document.body.requestFullscreen && !!document.exitFullscreen);
2753            };
2754            return ModalWindow;
2755        }());
2756        Components.ModalWindow = ModalWindow;
2757        var ModalOptions = (function () {
2758            function ModalOptions() {
2759                this.type = 'Dialog';
2760            }
2761            return ModalOptions;
2762        }());
2763        Components.ModalOptions = ModalOptions;
2764        var ModalApplicationOptions = (function () {
2765            function ModalApplicationOptions() {
2766            }
2767            return ModalApplicationOptions;
2768        }());
2769        Components.ModalApplicationOptions = ModalApplicationOptions;
2770        var ModalApplication = (function () {
2771            function ModalApplication(options) {
2772                this._options = options;
2773                this._window = new Components.ModalWindow();
2774            }
2775            Object.defineProperty(ModalApplication.prototype, "options", {
2776                get: function () {
2777                    return this._options;
2778                },
2779                enumerable: false,
2780                configurable: true
2781            });
2782            Object.defineProperty(ModalApplication.prototype, "window", {
2783                get: function () {
2784                    return this._window;
2785                },
2786                enumerable: false,
2787                configurable: true
2788            });
2789            ModalApplication.prototype.init = function () {
2790                var _this = this;
2791                this.window.init();
2792                document.body.appendChild(this.window.element);
2793                if (window.eventBus) {
2794                    window.eventBus.addEventListener('close-modal', function (event) {
2795                        _this.closeModal();
2796                    });
2797                }
2798            };
2799            ;
2800            ModalApplication.prototype.openModal = function (options, initiator) {
2801                this.window.clear();
2802                this.window.open(options, initiator);
2803            };
2804            ModalApplication.prototype.closeModal = function () {
2805                this.window.clear();
2806                this.window.close();
2807            };
2808            return ModalApplication;
2809        }());
2810        Components.ModalApplication = ModalApplication;
2811    })(Components = Templates.Components || (Templates.Components = {}));
2812})(Templates || (Templates = {}));
2813var Templates;
2814(function (Templates) {
2815    var Components;
2816    (function (Components) {
2817        var StatusBarOptions = (function () {
2818            function StatusBarOptions() {
2819            }
2820            return StatusBarOptions;
2821        }());
2822        Components.StatusBarOptions = StatusBarOptions;
2823        var StatusBarComponent = (function () {
2824            function StatusBarComponent(options) {
2825                this.element = options.element;